hexsha stringlengths 40 40 | size int64 22 2.4M | ext stringclasses 5
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 3 260 | max_stars_repo_name stringlengths 5 109 | max_stars_repo_head_hexsha stringlengths 40 78 | max_stars_repo_licenses listlengths 1 9 | max_stars_count float64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 3 260 | max_issues_repo_name stringlengths 5 109 | max_issues_repo_head_hexsha stringlengths 40 78 | max_issues_repo_licenses listlengths 1 9 | max_issues_count float64 1 67k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 260 | max_forks_repo_name stringlengths 5 109 | max_forks_repo_head_hexsha stringlengths 40 78 | max_forks_repo_licenses listlengths 1 9 | max_forks_count float64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 22 2.4M | avg_line_length float64 5 169k | max_line_length int64 5 786k | alphanum_fraction float64 0.06 0.95 | matches listlengths 1 11 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
8058cf92c986e6dd53f9ed01537227b0845a79d2 | 3,610 | h | C | src/hildon2/modest-hildon2-window-mgr.h | community-ssu/modest | 47e30072309811dc24abc9809952ed1ea846ebfa | [
"BSD-3-Clause"
] | null | null | null | src/hildon2/modest-hildon2-window-mgr.h | community-ssu/modest | 47e30072309811dc24abc9809952ed1ea846ebfa | [
"BSD-3-Clause"
] | null | null | null | src/hildon2/modest-hildon2-window-mgr.h | community-ssu/modest | 47e30072309811dc24abc9809952ed1ea846ebfa | [
"BSD-3-Clause"
] | 2 | 2020-11-15T13:57:11.000Z | 2021-09-01T16:32:55.000Z | /* Copyright (c) 2008, Nokia Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Nokia Corporation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __MODEST_HILDON2_WINDOW_MGR_H__
#define __MODEST_HILDON2_WINDOW_MGR_H__
#include <glib-object.h>
#include "widgets/modest-window-mgr.h"
#include "widgets/modest-msg-view-window.h"
G_BEGIN_DECLS
/* convenience macros */
#define MODEST_TYPE_HILDON2_WINDOW_MGR (modest_hildon2_window_mgr_get_type())
#define MODEST_HILDON2_WINDOW_MGR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MODEST_TYPE_HILDON2_WINDOW_MGR,ModestHildon2WindowMgr))
#define MODEST_HILDON2_WINDOW_MGR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),MODEST_TYPE_HILDON2_WINDOW_MGR,ModestHildon2WindowMgrClass))
#define MODEST_IS_HILDON2_WINDOW_MGR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),MODEST_TYPE_HILDON2_WINDOW_MGR))
#define MODEST_IS_HILDON2_WINDOW_MGR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),MODEST_TYPE_HILDON2_WINDOW_MGR))
#define MODEST_HILDON2_WINDOW_MGR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),MODEST_TYPE_HILDON2_WINDOW_MGR,ModestHildon2WindowMgrClass))
typedef struct _ModestHildon2WindowMgr ModestHildon2WindowMgr;
typedef struct _ModestHildon2WindowMgrClass ModestHildon2WindowMgrClass;
struct _ModestHildon2WindowMgr {
ModestWindowMgr parent;
};
struct _ModestHildon2WindowMgrClass {
ModestWindowMgrClass parent_class;
};
/* member functions */
GType modest_hildon2_window_mgr_get_type (void) G_GNUC_CONST;
/* typical parameter-less _new function */
ModestWindowMgr* modest_hildon2_window_mgr_new (void);
/**
* modest_hildon2_window_mgr_set_account_store:
* @self: a #ModestHildon2WindowMgr
* @acc_store: a #TnyAccountStore
*
* The window manager will use this function to connect itself to the
* account-created and account-removed signals of the
* #TnyAccountStore, because it ill create/destroy the accounts window
* depending on the existence of 0, 1 or more accounts.
**/
void modest_hildon2_window_mgr_set_account_store (ModestHildon2WindowMgr *self,
TnyAccountStore *acc_store);
G_END_DECLS
#endif /* __MODEST_HILDON2_WINDOW_MGR_H__ */
| 42.97619 | 144 | 0.794183 | [
"object"
] |
805912bc8d6b5999f0ee3db5eae2e9bab2828e12 | 15,720 | c | C | Dmf/Modules.Template/Dmf_SampleInterfaceTransport1.c | hansmbakker/DMF | 3a67cb056a42637ce98fc489e355efc0fc8beeba | [
"MIT"
] | 1 | 2020-01-06T18:15:37.000Z | 2020-01-06T18:15:37.000Z | Dmf/Modules.Template/Dmf_SampleInterfaceTransport1.c | hansmbakker/DMF | 3a67cb056a42637ce98fc489e355efc0fc8beeba | [
"MIT"
] | null | null | null | Dmf/Modules.Template/Dmf_SampleInterfaceTransport1.c | hansmbakker/DMF | 3a67cb056a42637ce98fc489e355efc0fc8beeba | [
"MIT"
] | null | null | null | /*++
Copyright (c) Microsoft Corporation. All rights reserved.
Module Name:
Dmf_SampleInterfaceTransport1.c
Abstract:
Interface Transport (1) for "Sample Interface".
Environment:
Kernel-mode Driver Framework
User-mode Driver Framework
--*/
// DMF and this Module's Library specific definitions.
//
#include "DmfModule.h"
#include "DmfModules.Template.h"
#include "DmfModules.Template.Trace.h"
#include "Dmf_SampleInterfaceTransport1.tmh"
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Module Private Enumerations and Structures
///////////////////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Module Private Context
///////////////////////////////////////////////////////////////////////////////////////////////////////
//
typedef struct
{
// Stores the DMF Module of the Protocol this Module is bound to.
//
DMFINTERFACE SampleInterfaceHandle;
} DMF_CONTEXT_SampleInterfaceTransport1;
// This macro declares the following function:
// DMF_CONTEXT_GET()
//
DMF_MODULE_DECLARE_CONTEXT(SampleInterfaceTransport1)
// This macro declares the following function:
// DMF_CONFIG_GET()
//
DMF_MODULE_DECLARE_CONFIG(SampleInterfaceTransport1)
///////////////////////////////////////////////////////////////////////////////////////////////////////
// DMF Module Support Code
///////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Private context the Protocol Module associates with an Interface.
//
typedef struct _DMF_INTERFACE_TRANSPORT1_CONTEXT
{
// Stores the Id of the Protocol Module.
//
ULONG ProtocolId;
}DMF_INTERFACE_TRANSPORT1_CONTEXT;
WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DMF_INTERFACE_TRANSPORT1_CONTEXT, DMF_SampleInterfaceTransport1ContextGet)
///////////////////////////////////////////////////////////////////////////////////////////////////////
// WDF Module Callbacks
///////////////////////////////////////////////////////////////////////////////////////////////////////
//
_Function_class_(DMF_ModuleD0Entry)
_IRQL_requires_max_(PASSIVE_LEVEL)
_Must_inspect_result_
static
NTSTATUS
DMF_SampleInterfaceTransport1_ModuleD0Entry(
_In_ DMFMODULE DmfModule,
_In_ WDF_POWER_DEVICE_STATE PreviousState
)
/*++
Routine Description:
SampleInterfaceTransport1 callback for ModuleD0Entry for a given DMF Module.
Arguments:
DmfModule - This Module's handle.
PreviousState - The WDF Power State that the given DMF Module should exit from.
Return Value:
NTSTATUS
--*/
{
NTSTATUS ntStatus;
UNREFERENCED_PARAMETER(PreviousState);
UNREFERENCED_PARAMETER(DmfModule);
FuncEntry(DMF_TRACE);
ntStatus = STATUS_SUCCESS;
FuncExit(DMF_TRACE, "ntStatus=%!STATUS!", ntStatus);
return ntStatus;
}
_Function_class_(DMF_ModuleD0Exit)
_IRQL_requires_max_(PASSIVE_LEVEL)
static
NTSTATUS
DMF_SampleInterfaceTransport1_ModuleD0Exit(
_In_ DMFMODULE DmfModule,
_In_ WDF_POWER_DEVICE_STATE TargetState
)
/*++
Routine Description:
SampleInterfaceTransport1 callback for ModuleD0Exit for a given DMF Module.
Arguments:
DmfModule - This Module's handle.
TargetState - The WDF Power State that the given DMF Module will enter.
Return Value:
NTSTATUS
--*/
{
NTSTATUS ntStatus;
UNREFERENCED_PARAMETER(DmfModule);
UNREFERENCED_PARAMETER(TargetState);
FuncEntry(DMF_TRACE);
ntStatus = STATUS_SUCCESS;
FuncExitVoid(DMF_TRACE);
return ntStatus;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
// DMF Module Callbacks
///////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Transport Generic Callbacks.
// (Implementation of publicly accessible callbacks required by the Interface.)
//
#pragma code_seg("PAGE")
_IRQL_requires_max_(PASSIVE_LEVEL)
_IRQL_requires_same_
VOID
DMF_SampleInterfaceTransport1_PostBind(
_In_ DMFINTERFACE DmfInterface
)
/*++
Routine Description:
This callback tells the given Transport Module that it is bound to the given
Protocol Module.
Arguments:
DmfModule - This Module's handle. (The given Transport Module).
ProtocolModule - The given Protocol Module.
Return Value:
NTSTATUS
--*/
{
PAGED_CODE();
UNREFERENCED_PARAMETER(DmfInterface);
FuncEntry(DMF_TRACE);
// It is now possible to use Methods provided by the Protocol.
//
FuncExitVoid(DMF_TRACE);
}
#pragma code_seg()
#pragma code_seg("PAGE")
_IRQL_requires_max_(PASSIVE_LEVEL)
_IRQL_requires_same_
VOID
DMF_SampleInterfaceTransport1_PreUnbind(
_In_ DMFINTERFACE DmfInterface
)
/*++
Routine Description:
This callback tells the given Transport Module that it is about to be unbound from
the given Protocol Module.
Arguments:
DmfModule - This Module's handle. (The given Transport Module).
ProtocolModule - The given Transport Module.
Return Value:
None
--*/
{
PAGED_CODE();
UNREFERENCED_PARAMETER(DmfInterface);
FuncEntry(DMF_TRACE);
// Free any resources allocated during Bind.
//
// Stop using Methods provided by Protocol after this callback completes (except for Unbind).
//
FuncExitVoid(DMF_TRACE);
}
#pragma code_seg()
#pragma code_seg("PAGE")
_IRQL_requires_max_(PASSIVE_LEVEL)
_IRQL_requires_same_
NTSTATUS
DMF_SampleInterfaceTransport1_Bind(
_In_ DMFINTERFACE DmfInterface,
_In_ DMF_INTERFACE_PROTOCOL_SampleInterface_BIND_DATA* ProtocolBindData,
_Out_ DMF_INTERFACE_TRANSPORT_SampleInterface_BIND_DATA* TransportBindData
)
/*++
Routine Description:
Binds the given Transport Module to the given Protocol Module.
Arguments:
TransportModule - The given Transport Module.
ProtocolModule - This Module's handle. (The given Protocol Module).
ProtocolBindData - Bind data provided by Protocol for the Transport.
TransportBindData - Bind data provided by Transport for the Protocol.
Return Value:
NTSTATUS
--*/
{
NTSTATUS ntStatus;
DMFMODULE transportModule;
DMF_CONTEXT_SampleInterfaceTransport1* moduleContext;
DMF_INTERFACE_TRANSPORT1_CONTEXT* transportContext;
DMF_CONFIG_SampleInterfaceTransport1* moduleConfig;
PAGED_CODE();
FuncEntry(DMF_TRACE);
UNREFERENCED_PARAMETER(ProtocolBindData);
ntStatus = STATUS_SUCCESS;
transportModule = DMF_InterfaceTransportModuleGet(DmfInterface);
moduleContext = DMF_CONTEXT_GET(transportModule);
moduleConfig = DMF_CONFIG_GET(transportModule);
// Save the Bind Data provided by the Protocol in Transport1's Context
// associated with this Protocol.
//
transportContext = DMF_SampleInterfaceTransport1ContextGet(DmfInterface);
transportContext->ProtocolId = ProtocolBindData->ProtocolId;
// Save the Interface Handle representing the Interface binding.
//
moduleContext->SampleInterfaceHandle = DmfInterface;
// Populate the Transport Bind Data structure that the Protocol is requesting for.
//
TransportBindData->TransportId = moduleConfig->ModuleId;
TraceEvents(TRACE_LEVEL_INFORMATION, DMF_TRACE, "DMF_INTERFACE_TRANSPORT_SampleInterfaceTransport1_Bind success");
FuncExit(DMF_TRACE, "ntStatus=%!STATUS!", ntStatus);
return ntStatus;
}
#pragma code_seg()
#pragma code_seg("PAGE")
_IRQL_requires_max_(PASSIVE_LEVEL)
_IRQL_requires_same_
VOID
DMF_SampleInterfaceTransport1_Unbind(
_In_ DMFINTERFACE DmfInterface
)
/*++
Routine Description:
Unbinds the given Transport Module from the given Protocol Module.
Arguments:
TransportModule - The given Transport Module.
ProtocolModule - This Module's handle. (The given Protocol Module).
Return Value:
None
--*/
{
UNREFERENCED_PARAMETER(DmfInterface);
PAGED_CODE();
FuncEntry(DMF_TRACE);
TraceEvents(TRACE_LEVEL_INFORMATION, DMF_TRACE, "DMF_INTERFACE_PROTOCOL_SampleInterfaceTransport1_Unbind success");
FuncExitVoid(DMF_TRACE);
}
#pragma code_seg()
#pragma code_seg("PAGE")
_Function_class_(DMF_Open)
_IRQL_requires_max_(PASSIVE_LEVEL)
_Must_inspect_result_
static
NTSTATUS
DMF_SampleInterfaceTransport1_Open(
_In_ DMFMODULE DmfModule
)
/*++
Routine Description:
Initialize an instance of a DMF Module of type SampleInterfaceTransport1.
Arguments:
DmfModule - This Module's handle.
Return Value:
STATUS_SUCCESS
--*/
{
NTSTATUS ntStatus;
PAGED_CODE();
UNREFERENCED_PARAMETER(DmfModule);
FuncEntry(DMF_TRACE);
ntStatus = STATUS_SUCCESS;
FuncExit(DMF_TRACE, "ntStatus=%!STATUS!", ntStatus);
return ntStatus;
}
#pragma code_seg()
#pragma code_seg("PAGE")
_Function_class_(DMF_Close)
_IRQL_requires_max_(PASSIVE_LEVEL)
static
VOID
DMF_SampleInterfaceTransport1_Close(
_In_ DMFMODULE DmfModule
)
/*++
Routine Description:
Uninitialize an instance of a DMF Module of type SampleInterfaceTransport1.
Arguments:
DmfModule - This Module's handle.
Return Value:
None
--*/
{
PAGED_CODE();
UNREFERENCED_PARAMETER(DmfModule);
FuncEntry(DMF_TRACE);
FuncExitVoid(DMF_TRACE);
}
#pragma code_seg()
// Interface Specific Transport Module Methods
//
#pragma code_seg("PAGE")
_IRQL_requires_max_(PASSIVE_LEVEL)
_IRQL_requires_same_
NTSTATUS
DMF_SampleInterfaceTransport1_Method1(
_In_ DMFINTERFACE DmfInterface
)
{
NTSTATUS ntStatus;
DMFMODULE transportModule;
DMF_CONFIG_SampleInterfaceTransport1* moduleConfig;
DMF_INTERFACE_TRANSPORT1_CONTEXT* transportContext;
PAGED_CODE()
FuncEntry(DMF_TRACE);
ntStatus = STATUS_SUCCESS;
transportModule = DMF_InterfaceTransportModuleGet(DmfInterface);
moduleConfig = DMF_CONFIG_GET(transportModule);
transportContext = DMF_SampleInterfaceTransport1ContextGet(DmfInterface);
TraceEvents(TRACE_LEVEL_INFORMATION, DMF_TRACE,
"SampleInterface Method1: TransportId=%d TransportName=%s ProtocolId=%d ntStatus=%!STATUS!",
moduleConfig->ModuleId,
moduleConfig->ModuleName,
transportContext->ProtocolId,
ntStatus);
EVT_SampleInterface_ProtocolCallback1(DmfInterface);
FuncExit(DMF_TRACE, "ntStatus=%!STATUS!", ntStatus);
return ntStatus;
}
#pragma code_seg()
///////////////////////////////////////////////////////////////////////////////////////////////////////
// Public Calls by Protocol
///////////////////////////////////////////////////////////////////////////////////////////////////////
//
#pragma code_seg("PAGE")
_IRQL_requires_max_(PASSIVE_LEVEL)
_Must_inspect_result_
NTSTATUS
DMF_SampleInterfaceTransport1_Create(
_In_ WDFDEVICE Device,
_In_ DMF_MODULE_ATTRIBUTES* DmfModuleAttributes,
_In_ WDF_OBJECT_ATTRIBUTES* ObjectAttributes,
_Out_ DMFMODULE* DmfModule
)
/*++
Routine Description:
Create an instance of a DMF Module of type SampleInterfaceTransport1.
Arguments:
Device - Protocol driver's WDFDEVICE object.
DmfModuleAttributes - Opaque structure that contains parameters DMF needs to initialize the Module.
ObjectAttributes - WDF object attributes for DMFMODULE.
DmfModule - Address of the location where the created DMFMODULE handle is returned.
Return Value:
NTSTATUS
--*/
{
NTSTATUS ntStatus;
DMF_INTERFACE_TRANSPORT_SampleInterface_DECLARATION_DATA transportDeclarationData;
DMF_MODULE_DESCRIPTOR dmfModuleDescriptor_SampleInterfaceTransport1;
DMF_CALLBACKS_DMF dmfCallbacksDmf_SampleInterfaceTransport1;
DMF_CALLBACKS_WDF dmfCallbacksWdf_SampleInterfaceTransport1;
PAGED_CODE();
FuncEntry(DMF_TRACE);
DMF_CALLBACKS_DMF_INIT(&dmfCallbacksDmf_SampleInterfaceTransport1);
dmfCallbacksDmf_SampleInterfaceTransport1.DeviceOpen = DMF_SampleInterfaceTransport1_Open;
dmfCallbacksDmf_SampleInterfaceTransport1.DeviceClose = DMF_SampleInterfaceTransport1_Close;
DMF_CALLBACKS_WDF_INIT(&dmfCallbacksWdf_SampleInterfaceTransport1);
dmfCallbacksWdf_SampleInterfaceTransport1.ModuleD0Entry = DMF_SampleInterfaceTransport1_ModuleD0Entry;
dmfCallbacksWdf_SampleInterfaceTransport1.ModuleD0Exit = DMF_SampleInterfaceTransport1_ModuleD0Exit;
DMF_MODULE_DESCRIPTOR_INIT_CONTEXT_TYPE(dmfModuleDescriptor_SampleInterfaceTransport1,
SampleInterfaceTransport1,
DMF_CONTEXT_SampleInterfaceTransport1,
DMF_MODULE_OPTIONS_PASSIVE,
DMF_MODULE_OPEN_OPTION_OPEN_Create);
dmfModuleDescriptor_SampleInterfaceTransport1.CallbacksDmf = &dmfCallbacksDmf_SampleInterfaceTransport1;
dmfModuleDescriptor_SampleInterfaceTransport1.CallbacksWdf = &dmfCallbacksWdf_SampleInterfaceTransport1;
ntStatus = DMF_ModuleCreate(Device,
DmfModuleAttributes,
ObjectAttributes,
&dmfModuleDescriptor_SampleInterfaceTransport1,
DmfModule);
if (! NT_SUCCESS(ntStatus))
{
TraceEvents(TRACE_LEVEL_ERROR, DMF_TRACE, "DMF_ModuleCreate fails: ntStatus=%!STATUS!", ntStatus);
goto Exit;
}
// Initialize the Transport Declaration Data.
//
DMF_INTERFACE_TRANSPORT_SampleInterface_DESCRIPTOR_INIT(&transportDeclarationData,
DMF_SampleInterfaceTransport1_PostBind,
DMF_SampleInterfaceTransport1_PreUnbind,
DMF_SampleInterfaceTransport1_Bind,
DMF_SampleInterfaceTransport1_Unbind,
DMF_SampleInterfaceTransport1_Method1);
// An optional context can be set by the Transport module on the bind instance.
// This is a unique context for each instance of Protocol Transport binding.
// E.g. in case a transport module is bound to multiple protocol modules, the transport
// module will get a unique instance of this context each binding.
//
DMF_INTERFACE_DESCRIPTOR_SET_CONTEXT_TYPE(&transportDeclarationData,
DMF_INTERFACE_TRANSPORT1_CONTEXT);
// Add the interface to the Transport Module.
//
ntStatus = DMF_ModuleInterfaceDescriptorAdd(*DmfModule,
(DMF_INTERFACE_DESCRIPTOR*)&transportDeclarationData);
if (!NT_SUCCESS(ntStatus))
{
TraceEvents(TRACE_LEVEL_ERROR, DMF_TRACE, "DMF_ModuleInterfaceDescriptorAdd fails: ntStatus=%!STATUS!", ntStatus);
goto Exit;
}
Exit:
FuncExit(DMF_TRACE, "ntStatus=%!STATUS!", ntStatus);
return(ntStatus);
}
#pragma code_seg()
// eof: Dmf_SampleInterfaceTransport1.c
//
| 27.578947 | 123 | 0.646756 | [
"object"
] |
805e01d92a289dbb28f4e4884b823ead202d8980 | 3,461 | h | C | fast_planner/src/dyn_planner/plan_env/include/plan_env/sdf_map.h | Sunshinehualong/motion_Planning | ea127de8cd8f32e9994538416d0c74b99054214f | [
"MIT"
] | 11 | 2019-08-24T08:28:17.000Z | 2021-04-28T05:23:42.000Z | fast_planner/src/dyn_planner/plan_env/include/plan_env/sdf_map.h | lvhualong/motion_Planning | ea127de8cd8f32e9994538416d0c74b99054214f | [
"MIT"
] | null | null | null | fast_planner/src/dyn_planner/plan_env/include/plan_env/sdf_map.h | lvhualong/motion_Planning | ea127de8cd8f32e9994538416d0c74b99054214f | [
"MIT"
] | 6 | 2019-08-24T08:28:19.000Z | 2020-10-19T12:47:20.000Z | #ifndef _SDF_MAP_H
#define _SDF_MAP_H
#include <visualization_msgs/Marker.h>
#include <Eigen/Eigen>
#include <iostream>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
// #include <pcl/search/kdtree.h>
#include <pcl/kdtree/kdtree_flann.h>
#include <pcl_conversions/pcl_conversions.h>
#include <nav_msgs/Odometry.h>
using namespace std;
namespace dyn_planner
{
class SDFMap
{
private:
// data are saved in vector
std::vector<int> occupancy_buffer_; // 0 is free, 1 is occupied
std::vector<double> distance_buffer_;
std::vector<double> distance_buffer_neg_;
std::vector<double> tmp_buffer1_, tmp_buffer2_;
// map property
Eigen::Vector3d min_range_, max_range_; // map range in pos
Eigen::Vector3i grid_size_; // map range in index
Eigen::Vector3i min_vec_, max_vec_; // the min and max updated range, unit is 1
bool isInMap(Eigen::Vector3d pos);
void posToIndex(Eigen::Vector3d pos, Eigen::Vector3i& id);
void indexToPos(Eigen::Vector3i id, Eigen::Vector3d& pos);
template <typename F_get_val, typename F_set_val>
void fillESDF(F_get_val f_get_val, F_set_val f_set_val, int start, int end, int dim);
/* ---------- parameter ---------- */
double inflate_, update_range_, radius_ignore_;
Eigen::Vector3d origin_, map_size_;
double resolution_sdf_, resolution_inv_;
double ceil_height_;
double update_rate_;
/* ---------- callback ---------- */
nav_msgs::Odometry odom_;
bool have_odom_;
pcl::PointCloud<pcl::PointXYZ> latest_cloud_, cloud_inflate_vis_;
bool new_map_, map_valid_;
ros::NodeHandle node_;
ros::Subscriber odom_sub_, cloud_sub_;
ros::Publisher inflate_cloud_pub_;
ros::Timer update_timer_;
void cloudCallback(const sensor_msgs::PointCloud2ConstPtr& msg);
void odomCallback(const nav_msgs::OdometryConstPtr& msg);
void updateCallback(const ros::TimerEvent& e);
/* --------------------------------- */
public:
SDFMap() {}
SDFMap(Eigen::Vector3d origin, double resolution, Eigen::Vector3d map_size);
~SDFMap() {}
void init(ros::NodeHandle& nh);
/* get state */
bool odomValid() { return have_odom_; }
bool mapValid() { return map_valid_; }
nav_msgs::Odometry getOdom() { return odom_; }
void getRegion(Eigen::Vector3d& ori, Eigen::Vector3d& size) { ori = origin_, size = map_size_; }
double getResolution() { return resolution_sdf_; }
double getIgnoreRadius() { return radius_ignore_; }
void getInterpolationData(const Eigen::Vector3d& pos, vector<Eigen::Vector3d>& pos_vec,
Eigen::Vector3d& diff);
// occupancy management
void resetBuffer(Eigen::Vector3d min, Eigen::Vector3d max);
void setOccupancy(Eigen::Vector3d pos, int occ = 1);
int getOccupancy(Eigen::Vector3d pos);
int getOccupancy(Eigen::Vector3i id);
void getOccupancyMarker(visualization_msgs::Marker& m, int id, Eigen::Vector4d color);
// distance field management
double getDistance(Eigen::Vector3d pos);
double getDistance(Eigen::Vector3i id);
double getDistWithGradTrilinear(Eigen::Vector3d pos, Eigen::Vector3d& grad);
double getDistTrilinear(Eigen::Vector3d pos);
void setUpdateRange(Eigen::Vector3d min_pos, Eigen::Vector3d max_pos);
void updateESDF3d(bool neg = false);
void getESDFMarker(vector<visualization_msgs::Marker>& markers, int id, Eigen::Vector3d color);
double getMaxDistance();
void publishESDF();
typedef shared_ptr<SDFMap> Ptr;
};
} // namespace dyn_planner
#endif | 32.961905 | 98 | 0.719156 | [
"vector"
] |
805f6f3c3a0cf60a8f180450e9954dbb5a007286 | 10,382 | h | C | Drivers/ScanLabOIE/Headers/CppDynamic/libmcdriver_scanlaboie_dynamic.h | FabianSpangler/AutodeskMachineControlFramework | da257a4a609edbbdf3d7c5d834d61f8555c68e09 | [
"BSD-3-Clause"
] | null | null | null | Drivers/ScanLabOIE/Headers/CppDynamic/libmcdriver_scanlaboie_dynamic.h | FabianSpangler/AutodeskMachineControlFramework | da257a4a609edbbdf3d7c5d834d61f8555c68e09 | [
"BSD-3-Clause"
] | null | null | null | Drivers/ScanLabOIE/Headers/CppDynamic/libmcdriver_scanlaboie_dynamic.h | FabianSpangler/AutodeskMachineControlFramework | da257a4a609edbbdf3d7c5d834d61f8555c68e09 | [
"BSD-3-Clause"
] | null | null | null | /*++
Copyright (C) 2020 Autodesk Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the Autodesk Inc. nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL AUTODESK INC. BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
This file has been generated by the Automatic Component Toolkit (ACT) version 1.7.0-develop.
Abstract: This is an autogenerated C++-Header file in order to allow an easy
use of MC Driver ScanLab Open Interface Extension
Interface version: 1.0.0
*/
#ifndef __LIBMCDRIVER_SCANLABOIE_DYNAMICHEADER_CPPTYPES
#define __LIBMCDRIVER_SCANLABOIE_DYNAMICHEADER_CPPTYPES
#include "libmcdriver_scanlaboie_types.hpp"
#include "libmcdriverenv_types.hpp"
/*************************************************************************************************************************
Class definition for Base
**************************************************************************************************************************/
/*************************************************************************************************************************
Class definition for Driver
**************************************************************************************************************************/
/**
* returns the name identifier of the driver
*
* @param[in] pDriver - Driver instance.
* @param[in] nNameBufferSize - size of the buffer (including trailing 0)
* @param[out] pNameNeededChars - will be filled with the count of the written bytes, or needed buffer size.
* @param[out] pNameBuffer - buffer of Name of the driver., may be NULL
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEDriver_GetNamePtr) (LibMCDriver_ScanLabOIE_Driver pDriver, const LibMCDriver_ScanLabOIE_uint32 nNameBufferSize, LibMCDriver_ScanLabOIE_uint32* pNameNeededChars, char * pNameBuffer);
/**
* returns the type identifier of the driver
*
* @param[in] pDriver - Driver instance.
* @param[in] nTypeBufferSize - size of the buffer (including trailing 0)
* @param[out] pTypeNeededChars - will be filled with the count of the written bytes, or needed buffer size.
* @param[out] pTypeBuffer - buffer of Type of the driver., may be NULL
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEDriver_GetTypePtr) (LibMCDriver_ScanLabOIE_Driver pDriver, const LibMCDriver_ScanLabOIE_uint32 nTypeBufferSize, LibMCDriver_ScanLabOIE_uint32* pTypeNeededChars, char * pTypeBuffer);
/**
* returns the version identifiers of the driver
*
* @param[in] pDriver - Driver instance.
* @param[out] pMajor - Major version.
* @param[out] pMinor - Minor version.
* @param[out] pMicro - Micro version.
* @param[in] nBuildBufferSize - size of the buffer (including trailing 0)
* @param[out] pBuildNeededChars - will be filled with the count of the written bytes, or needed buffer size.
* @param[out] pBuildBuffer - buffer of Build identifier., may be NULL
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEDriver_GetVersionPtr) (LibMCDriver_ScanLabOIE_Driver pDriver, LibMCDriver_ScanLabOIE_uint32 * pMajor, LibMCDriver_ScanLabOIE_uint32 * pMinor, LibMCDriver_ScanLabOIE_uint32 * pMicro, const LibMCDriver_ScanLabOIE_uint32 nBuildBufferSize, LibMCDriver_ScanLabOIE_uint32* pBuildNeededChars, char * pBuildBuffer);
/**
* returns the header information
*
* @param[in] pDriver - Driver instance.
* @param[in] nNameSpaceBufferSize - size of the buffer (including trailing 0)
* @param[out] pNameSpaceNeededChars - will be filled with the count of the written bytes, or needed buffer size.
* @param[out] pNameSpaceBuffer - buffer of NameSpace of the driver., may be NULL
* @param[in] nBaseNameBufferSize - size of the buffer (including trailing 0)
* @param[out] pBaseNameNeededChars - will be filled with the count of the written bytes, or needed buffer size.
* @param[out] pBaseNameBuffer - buffer of BaseName of the driver., may be NULL
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEDriver_GetHeaderInformationPtr) (LibMCDriver_ScanLabOIE_Driver pDriver, const LibMCDriver_ScanLabOIE_uint32 nNameSpaceBufferSize, LibMCDriver_ScanLabOIE_uint32* pNameSpaceNeededChars, char * pNameSpaceBuffer, const LibMCDriver_ScanLabOIE_uint32 nBaseNameBufferSize, LibMCDriver_ScanLabOIE_uint32* pBaseNameNeededChars, char * pBaseNameBuffer);
/*************************************************************************************************************************
Class definition for Driver_ScanLab_OIE
**************************************************************************************************************************/
/*************************************************************************************************************************
Global functions
**************************************************************************************************************************/
/**
* retrieves the binary version of this library.
*
* @param[out] pMajor - returns the major version of this library
* @param[out] pMinor - returns the minor version of this library
* @param[out] pMicro - returns the micro version of this library
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEGetVersionPtr) (LibMCDriver_ScanLabOIE_uint32 * pMajor, LibMCDriver_ScanLabOIE_uint32 * pMinor, LibMCDriver_ScanLabOIE_uint32 * pMicro);
/**
* Returns the last error recorded on this object
*
* @param[in] pInstance - Instance Handle
* @param[in] nErrorMessageBufferSize - size of the buffer (including trailing 0)
* @param[out] pErrorMessageNeededChars - will be filled with the count of the written bytes, or needed buffer size.
* @param[out] pErrorMessageBuffer - buffer of Message of the last error, may be NULL
* @param[out] pHasError - Is there a last error to query
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEGetLastErrorPtr) (LibMCDriver_ScanLabOIE_Base pInstance, const LibMCDriver_ScanLabOIE_uint32 nErrorMessageBufferSize, LibMCDriver_ScanLabOIE_uint32* pErrorMessageNeededChars, char * pErrorMessageBuffer, bool * pHasError);
/**
* Releases shared ownership of an Instance
*
* @param[in] pInstance - Instance Handle
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEReleaseInstancePtr) (LibMCDriver_ScanLabOIE_Base pInstance);
/**
* Acquires shared ownership of an Instance
*
* @param[in] pInstance - Instance Handle
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEAcquireInstancePtr) (LibMCDriver_ScanLabOIE_Base pInstance);
/**
* Injects an imported component for usage within this component
*
* @param[in] pNameSpace - NameSpace of the injected component
* @param[in] pSymbolAddressMethod - Address of the SymbolAddressMethod of the injected component
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEInjectComponentPtr) (const char * pNameSpace, LibMCDriver_ScanLabOIE_pvoid pSymbolAddressMethod);
/**
* Returns the address of the SymbolLookupMethod
*
* @param[out] pSymbolLookupMethod - Address of the SymbolAddressMethod
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIEGetSymbolLookupMethodPtr) (LibMCDriver_ScanLabOIE_pvoid * pSymbolLookupMethod);
/**
* Creates a driver instance with a specific name.
*
* @param[in] pName - Name of driver to be created.
* @param[in] pType - Type of driver to be created.
* @param[in] pDriverEnvironment - Environment of this driver.
* @param[out] pInstance - New Driver instance
* @return error code or 0 (success)
*/
typedef LibMCDriver_ScanLabOIEResult (*PLibMCDriver_ScanLabOIECreateDriverPtr) (const char * pName, const char * pType, LibMCDriverEnv_DriverEnvironment pDriverEnvironment, LibMCDriver_ScanLabOIE_Driver * pInstance);
/*************************************************************************************************************************
Function Table Structure
**************************************************************************************************************************/
typedef struct {
void * m_LibraryHandle;
PLibMCDriver_ScanLabOIEDriver_GetNamePtr m_Driver_GetName;
PLibMCDriver_ScanLabOIEDriver_GetTypePtr m_Driver_GetType;
PLibMCDriver_ScanLabOIEDriver_GetVersionPtr m_Driver_GetVersion;
PLibMCDriver_ScanLabOIEDriver_GetHeaderInformationPtr m_Driver_GetHeaderInformation;
PLibMCDriver_ScanLabOIEGetVersionPtr m_GetVersion;
PLibMCDriver_ScanLabOIEGetLastErrorPtr m_GetLastError;
PLibMCDriver_ScanLabOIEReleaseInstancePtr m_ReleaseInstance;
PLibMCDriver_ScanLabOIEAcquireInstancePtr m_AcquireInstance;
PLibMCDriver_ScanLabOIEInjectComponentPtr m_InjectComponent;
PLibMCDriver_ScanLabOIEGetSymbolLookupMethodPtr m_GetSymbolLookupMethod;
PLibMCDriver_ScanLabOIECreateDriverPtr m_CreateDriver;
} sLibMCDriver_ScanLabOIEDynamicWrapperTable;
#endif // __LIBMCDRIVER_SCANLABOIE_DYNAMICHEADER_CPPTYPES
| 51.91 | 405 | 0.713254 | [
"object"
] |
45ecea21526cfeb24091f64ca00d8456c2f6668e | 5,172 | h | C | include/fengine/Core/TreeHierarchy/ImageTreeNode.h | LukasBanana/ForkENGINE | 8b575bd1d47741ad5025a499cb87909dbabc3492 | [
"BSD-3-Clause"
] | 13 | 2017-03-21T22:46:18.000Z | 2020-07-30T01:31:57.000Z | include/fengine/Core/TreeHierarchy/ImageTreeNode.h | LukasBanana/ForkENGINE | 8b575bd1d47741ad5025a499cb87909dbabc3492 | [
"BSD-3-Clause"
] | null | null | null | include/fengine/Core/TreeHierarchy/ImageTreeNode.h | LukasBanana/ForkENGINE | 8b575bd1d47741ad5025a499cb87909dbabc3492 | [
"BSD-3-Clause"
] | 2 | 2018-07-23T19:56:41.000Z | 2020-07-30T01:32:01.000Z | /*
* Image tree node header
*
* This file is part of the "ForkENGINE" (Copyright (c) 2014 by Lukas Hermanns)
* See "LICENSE.txt" for license information.
*/
#ifndef __FORK_IMAGE_TREE_NODE_H__
#define __FORK_IMAGE_TREE_NODE_H__
#include "Math/Core/Rect.h"
#include <memory>
namespace Fork
{
/**
The ImageTreeNode class is used to store and pack 2D images into a single rectangle.
\tparam I Specifies the image object type. This is stored as non-owning raw-pointer.
This class must implement to following function:
\code
// Confirms the image insertion for the specified image tree node.
void ConfirmInsertion(ImageTreeNode<I>* node);
\endcode
*/
template <class I> class ImageTreeNode
{
public:
//! Unique ownership for image tree nodes.
typedef std::unique_ptr<ImageTreeNode<I>> NodePtr;
ImageTreeNode() = default;
ImageTreeNode(const Math::Recti& rect) :
rect_{ rect }
{
}
ImageTreeNode(const Math::Size2i& size) :
rect_{ { 0, 0 }, size }
{
}
ImageTreeNode(const ImageTreeNode<I>&) = delete;
ImageTreeNode& operator = (const ImageTreeNode<I>&) = delete;
/**
Tries to insert the specified image object into the tree.
\param[in] image Pointer to the image object.
\param[in] imageSize Specifies the image size.
\return Non-owning raw pointer to the image tree node which contains the inserted image.
*/
ImageTreeNode<I>* Insert(I* image, const Math::Size2i& imageSize)
{
if (!image)
return 0;
if (childA_)
{
/* Try to find a suitable tree node */
auto node = childA_->Insert(image, imageSize);
if (node)
return node;
return childB_->Insert(image, imageSize);
}
/* Check if this node already contians an image and check image size */
if (image_ || imageSize.width > rect_.Width() || imageSize.height > rect_.Height())
return 0;
/* Check if image fits exactly into this node */
if (imageSize == rect_.Size())
{
image_ = image;
image_->ConfirmInsertion(this);
return this;
}
/* Create children and split into two spaces */
childA_ = std::make_unique<ImageTreeNode<I>>();
childB_ = std::make_unique<ImageTreeNode<I>>();
if (rect_.Width() - imageSize.width > rect_.Height() - imageSize.height)
{
childA_->rect_ = Math::Recti(rect_.left, rect_.top, rect_.left + imageSize.width, rect_.bottom);
childB_->rect_ = Math::Recti(rect_.left + imageSize.width, rect_.top, rect_.right, rect_.bottom);
}
else
{
childA_->rect_ = Math::Recti(rect_.left, rect_.top, rect_.right, rect_.top + imageSize.height);
childB_->rect_ = Math::Recti(rect_.left, rect_.top + imageSize.height, rect_.right, rect_.bottom);
}
/* Try to insert the image into the new first child */
return childA_->Insert(image, imageSize);
}
/**
Releases the child nodes. To take over the ownership of the nodes, use the othwer "ReleaseChildren" function.
\see ReleaseChildren(NodePtr&, NodePtr&)
*/
void ReleaseChildren()
{
childA_.reset();
childB_.reset();
}
/**
Releases the child nodes and transfers the ownership to the specified output parameters.
\param[out] childA Specifies the first child node. Its previous managed pointer will be released and overwritten by the tree node's first child.
\param[out] childB Specifies the second child node. Its previous managed pointer will be released and overwritten by the tree node's second child.
*/
void ReleaseChildren(NodePtr& childA, NodePtr& childB)
{
childA = std::move(childA_);
childB = std::move(childB_);
}
//! Returns the first child node.
inline ImageTreeNode<I>* GetChildA() const
{
return childA_.get();
}
//! Returns the second child node.
inline ImageTreeNode<I>* GetChildB() const
{
return childB_.get();
}
//! Returns the rectangle where this node is embedded.
inline const Math::Recti& GetRect() const
{
return rect_;
}
//! Returns the data container.
inline I* GetImage() const
{
return image_;
}
private:
/* === Members === */
NodePtr childA_; //!< First child node.
NodePtr childB_; //!< Second child node.
Math::Recti rect_; //!< Rectangle where the image is stored.
I* image_ = nullptr; //!< Pointer reference to the image object.
};
} // /namespace Fork
#endif
// ======================== | 30.785714 | 154 | 0.569026 | [
"object"
] |
45ede2623c5c0cba5b9508626a57c113b9f008e9 | 825 | h | C | MainPage.h | gusmccallum/potato-generator | 4985b431c2e8f4ea2069c22eaef75da51ee8eccc | [
"MIT"
] | null | null | null | MainPage.h | gusmccallum/potato-generator | 4985b431c2e8f4ea2069c22eaef75da51ee8eccc | [
"MIT"
] | null | null | null | MainPage.h | gusmccallum/potato-generator | 4985b431c2e8f4ea2069c22eaef75da51ee8eccc | [
"MIT"
] | null | null | null | /*
* This program is A Static Site Generator (SSG) Tool coded in C++ language.
* Author: Chi Kien Nguyen
* Git Hub: https://github.com/kiennguyenchi/potato-generator
*/
/* This is the file containing functionalities of a main page */
#include <iostream>
#include <vector>
#include <filesystem>
#include "HTMLFile.h"
using namespace std;
namespace fs = std::filesystem;
class MainPage{
string folderName;
vector<HTMLFile> sites;
string htmlFile;
string language;
public:
MainPage(){
folderName = "";
htmlFile = "";
language = "";
}
void setMainPage(string name, vector<string> textFiles, string lang);
string getMainPage();
void displayMainPage();
void setHTMLMainPage();
void writeHTML();
void setFolderName(string name);
string getFolderName();
};
| 24.264706 | 75 | 0.678788 | [
"vector"
] |
45ee5cf5e62d223dbc9b7e8577fd9629a30b310c | 25,044 | h | C | src/pdp/sched_proc.h | emer/pdpp | ccce243ae356dc5908cdd667419a7afd74cf22ad | [
"BSD-3-Clause"
] | null | null | null | src/pdp/sched_proc.h | emer/pdpp | ccce243ae356dc5908cdd667419a7afd74cf22ad | [
"BSD-3-Clause"
] | null | null | null | src/pdp/sched_proc.h | emer/pdpp | ccce243ae356dc5908cdd667419a7afd74cf22ad | [
"BSD-3-Clause"
] | null | null | null | /* -*- C++ -*- */
/*=============================================================================
// //
// This file is part of the PDP++ software package. //
// //
// Copyright (C) 1995 Randall C. O'Reilly, Chadley K. Dawson, //
// James L. McClelland, and Carnegie Mellon University //
// //
// Permission to use, copy, and modify this software and its documentation //
// for any purpose other than distribution-for-profit is hereby granted //
// without fee, provided that the above copyright notice and this permission //
// notice appear in all copies of the software and related documentation. //
// //
// Permission to distribute the software or modified or extended versions //
// thereof on a not-for-profit basis is explicitly granted, under the above //
// conditions. HOWEVER, THE RIGHT TO DISTRIBUTE THE SOFTWARE OR MODIFIED OR //
// EXTENDED VERSIONS THEREOF FOR PROFIT IS *NOT* GRANTED EXCEPT BY PRIOR //
// ARRANGEMENT AND WRITTEN CONSENT OF THE COPYRIGHT HOLDERS. //
// //
// Note that the taString class, which is derived from the GNU String class, //
// is Copyright (C) 1988 Free Software Foundation, written by Doug Lea, and //
// is covered by the GNU General Public License, see ta_string.h. //
// The iv_graphic library and some iv_misc classes were derived from the //
// InterViews morpher example and other InterViews code, which is //
// Copyright (C) 1987, 1988, 1989, 1990, 1991 Stanford University //
// Copyright (C) 1991 Silicon Graphics, Inc. //
// //
// THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, //
// EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY //
// WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. //
// //
// IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE FOR ANY SPECIAL, //
// INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES //
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT //
// ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, //
// ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS //
// SOFTWARE. //
==============================================================================*/
#ifndef sched_proc_h
#define sched_proc_h
#include <pdp/stats.h>
#include <pdp/enviro.h>
#include <pdp/pdplog.h>
class Counter : public taBase {
// #INLINE ##NO_TOKENS #NO_UPDATE_AFTER Holds the value of a loop counter
public:
String name; // #HIDDEN not an taNBase to hide name
int val; // #IV_READ_ONLY #SHOW value of the counter
int max; // maximum value of the counter
virtual bool Crit()
{ if(max >= 0) return (val >= max); else return false; }
virtual void Inc() { val++; }
virtual void operator=(int i) { val = i; }
virtual bool operator==(int i) { return val==i; }
virtual bool operator<(int i) { return val<i; }
virtual bool operator>(int i) { return val>i; }
virtual bool operator>=(int i) { return val>=i; } virtual bool operator<=(int i) { return val<=i; }
virtual bool operator!=(int i) { return val!=i; }
virtual void SetMax(int i) { max = i; }
void Initialize() { val = 0; max = 1; }
void Destroy() { };
void Copy_(const Counter& cp) { name = cp.name; val = cp.val; max = cp.max; }
COPY_FUNS(Counter, taBase);
TA_BASEFUNS(Counter);
};
class StepParams : public taBase {
// #INLINE ##NO_TOKENS #NO_UPDATE_AFTER Holds steping process parameters
public:
SchedProcess* owner; // #READ_ONLY #NO_SAVE use this to find the subtypes
SchedProcess* proc; // #SUBTYPE_SchedProcess process to step
int n; // number of steps to take
TAPtr GetOwner() const;
TAPtr GetOwner(TypeDef* tp) const;
TAPtr SetOwner(TAPtr ta);
void Initialize();
void Destroy() { CutLinks(); }
void InitLinks();
void CutLinks();
void Copy_(const StepParams& cp);
COPY_FUNS(StepParams, taBase);
TA_BASEFUNS(StepParams);
};
class SchedProcess : public Process {
// ##MEMB_IN_GPMENU Generic scheduling, looping process
public:
enum StatLoc { // locations for statistics
DEFAULT,
LOOP_STATS,
FINAL_STATS
};
enum ProcLoc { // locations for processes
INIT_PROCS,
LOOP_PROCS,
FINAL_PROCS
};
enum SchedProcLoc { // locations for schedule processes
SUPER_PROC,
SUB_PROC
};
static bool stop_flag; // #READ_ONLY #NO_SAVE the Stop button was hit: stop running!
static bool stepping; // #READ_ONLY #NO_SAVE the Step button started us running
static bool bailing; // #READ_ONLY #NO_SAVE abort all further processing: stop was triggered below
static bool running; // #READ_ONLY #NO_SAVE some process is running
bool im_step_proc; // #READ_ONLY #NO_SAVE i'm the stepping process
bool im_run_proc; // #READ_ONLY #NO_SAVE i'm the process that initiated the interactive run
Counter* cntr; // #READ_ONLY #NO_SAVE pointer to the counter
DataItem_List cntr_items; // #READ_ONLY data item representations for cntrs
bool re_init; // #HIDDEN Flag for re-initialization
SchedProcess* super_proc; // #READ_ONLY #NO_SAVE #NO_SUBTYPE Process which calls this
TypeDef* sub_proc_type; // #DETAIL #TYPE_SchedProcess #NULL_OK type of sub-process to use
SchedProcess* sub_proc; // #DETAIL Sub-process called by this
StepParams step; // #CONTROL_PANEL Which process to step and n_steps
Stat_Group loop_stats; // #DETAIL #IN_GPMENU Statistics Computed in Loop
Stat_Group final_stats; // #DETAIL #IN_GPMENU Statistics Computed after Loop
Process_Group init_procs; // #DETAIL #IN_GPMENU Misc procs run when process is initialized
Process_Group loop_procs; // #DETAIL #IN_GPMENU Misc procs run in the loop, using mod based on loop counter
Process_Group final_procs; // #DETAIL #IN_GPMENU Misc procs run after process is finished
WinView_Group displays; // #LINK_GROUP #HIDDEN views to update
PDPLog_Group logs; // #LINK_GROUP #HIDDEN Logs to log to
bool log_loop; // Log the loop state (instead of final state)
bool log_counter; // Log the counter values for this process
virtual int GetCounter() { if (cntr) return cntr->val; else return 0; }
void C_Code(); // orchestrates the whole loop
// main user interface functions for running:
void NewInit();
void ReInit();
void Run_gui();
// #BUTTON #LABEL_Run #GHOST_OFF_running #NO_SCRIPT run the process in an interactive fashion: can be stopped and sets flags for only running one process
virtual void Step();
// #BUTTON #GHOST_OFF_running #NO_SCRIPT runs the next step of process
virtual void Step_gui() { Step(); } // backwards compatibility: gui is same as step: step implies interactive processing
virtual void Stop();
// #BUTTON #NO_APPLY_BEFORE #GHOST_ON_running #NO_SCRIPT stops any interactively running process
virtual void GoTo(int goto_val); // #BUTTON #GHOST_OFF_running go to given specific counter value
virtual void StepUp(); // #BUTTON move up one step in hierarchy, remove updater to network at previous level
virtual void StepDn(); // #BUTTON move down one step in hierarchy, add updater to network at new level
virtual void NotifyNetObjects(); // #IGNORE notify all network objects of impending modification prior to running a process
virtual void NotifyProcDialogs(); // #IGNORE notify all process dialogs when starting or stopping running
// initialization: before the loop
void Init(); // initializes process state variables (and sub_procs)
virtual void InitProcs(); // run the initialize processes (init_procs)
virtual void Init_impl(); // #IGNORE this actually has the init code
virtual void Init_flag(); // flag this process and all sub procs for re_init
virtual void Init_force(); // force re_init of all processes
virtual void Init_step_flags(); // initialize step flags
// inside the loop
virtual void Loop(); // called in the do loop (the main looping code)
virtual void UpdateCounters(); // update process counters (right after loop)
virtual void LoopProcs(); // call the loop_procs
virtual void LoopStats(); // stats computed inside the loop
virtual void UpdateLogs(); // update the logs
virtual void UpdateState(); // update misc state variables (after logs)
virtual bool Crit(); // returns true if stop criterion was met
virtual bool StopCheck(); // check for stop flag or stepping stopping: true if so, false if not
static bool HandleEvents(); // process gui events
// finalization: after the loop
virtual void FinalProcs(); // call the final_procs
virtual void FinalStats(); // compute the final statistics
virtual void Final() {}; // any misc things to do after loop
virtual void UpdateDisplays(); // update displays after end of loop
virtual void SetReInit(bool ri_val)
{ re_init = ri_val; } // set re-init flag to given value
virtual bool FinalStepCheck(); // if this process is step process, always set stop_flag in final so you always step at end
// log generation functions
LogData& GenLogData(LogData* ld=NULL); // generate log data
virtual void GetCntrDataItems(); // #IGNORE get data items for counters
virtual void GenCntrLog(LogData* ld, bool gen); // generate log data for the counters
// actions to coordinate with logs, processes, etc
virtual void InitMyLogs();
// #MENU #MENU_ON_Actions #MENU_SEP_BEFORE clear all logs associated with this process
virtual void InitAllLogs();
// #MENU #CONFIRM clear all logs that exist in the project
virtual void InitNetwork();
// #MENU #CONFIRM initialize network's weights
virtual void InitAll();
// #MENU #CONFIRM initialize process, network weights, and logs
virtual void RemoveFromLogs();
// #MENU #CONFIRM #MENU_SEP_BEFORE remove this from any logs
virtual void RemoveFromDisplays();
// #MENU #CONFIRM remove this from any displays
virtual bool CheckAllTypes();
// #MENU #USE_RVAL #MENU_SEP_BEFORE Check all minimum types for all processes and sub_procs
virtual bool CheckAllTypes_impl();
// #IGNORE implementation of check all types
virtual void UpdateLogUpdaters();
// make sure logs have us in their updater lists
virtual void UpdateDisplayUpdaters();
// make sure logs have us in their updater lists
// simple process manipulation subroutines to make life a little easier
virtual SchedProcess* FindSubProc(TypeDef* td); // find of a given type
virtual SchedProcess* FindSuperProc(TypeDef* td); // find of a given type
virtual SchedProcess* FindProcOfType(TypeDef* td);
// find of a given type, including this proc, super and sub procs
virtual SchedProcess* GetTopProc(); // #IGNORE get the highest-level process
////////////////////////////////////////////
// Structure manipulation functions:
virtual void UnLinkSubProc(); // #IGNORE disconnect from sub process
virtual void UnLinkFmSuperProc(); // #IGNORE disconnect me from super process
virtual void LinkSubProc(SchedProcess* proc); // #IGNORE link proc object as new sub process (not deleting old one)
virtual void LinkSuperProc(SchedProcess* proc); // #IGNORE link proc object as new super process (not deleting old one)
virtual void GetAggsFmSuperProc(); // #IGNORE fill in my aggregators from aggs on my super proc
virtual void SetAggsAfterRmvSubProc(); // #IGNORE set my aggs to point to my new sub proc stats after removing old one
virtual void CreateSubProcs(bool update=true);
// #NEW_FUN #ARGC_0 create sub-processes of this one
virtual void MoveToSubGp(const char* gp_name);
// #MENU #MENU_ON_Structure Move this process and all sub-procs to a new sub group (and name it gp_name)
virtual void ChangeNameSuffix(const char* new_name_sufx);
// #MENU change the suffix (after _ ) for each process name
virtual void AddSuperProc(TypeDef* proc_type);
// #MENU #TYPE_SchedProcess insert a new super process of given type above this one in hierarchy
virtual void AddSubProc(TypeDef* proc_type);
// #MENU #TYPE_SchedProcess insert a new sub process of given type below this one in hierarchy
virtual void RemoveSuperProc();
// #MENU #CONFIRM remove super process above this one in hierarchy
virtual void RemoveSubProc();
// #MENU #CONFIRM remove sub process below this one in hierarchy
virtual Stat* NewStat(TypeDef* type, StatLoc loc=DEFAULT, int num=1, bool create_aggs=true);
// #MENU #USE_RVAL_RMB #TYPE_Stat create num new statistic(s) of given type in this process at location loc, creating time-aggregates if checked
virtual Process* NewProcess(TypeDef* type, ProcLoc loc=INIT_PROCS, int num=1);
// #MENU #USE_RVAL_RMB #TYPE_Process create num new process(es) of given type in this process at location loc
virtual SchedProcess* NewSchedProc(TypeDef* type, SchedProcLoc loc=SUPER_PROC);
// #MENU #USE_RVAL_RMB #TYPE_SchedProcess create a new sub/super process of given type below/above the current one
static SchedProcess* Default_StatProc(TypeDef* stat_td, Process_MGroup* procs);
// returns the default process to create given type of stat in
static Stat_Group* Default_StatGroup(TypeDef* stat_td, SchedProcess* proc);
// returns the default stat group within sched proc to create stat in
virtual Stat_Group* GetStatGroup(TypeDef* stat_td, StatLoc loc);
// get stat group of specified location (if DEFAULT, use stat_td to determine location)
virtual Process_Group* GetProcGroup(ProcLoc loc);
// get process group of specified location
virtual Stat* MakeAggregator(Stat* of_stat, StatLoc in_loc, Aggregate::Operator agg_op = Aggregate::DEFAULT);
// make an aggregator of given stat in given location of this sched proc, using given agg operator
void ReplacePointersHook(TAPtr old); // #IGNORE for change my type -- redo all the linking!
virtual void DuplicateElHook(SchedProcess* cp); // #IGNORE duplicate all the structure from cp (this is duplicate of sp)
void SetDefaultName(); // #IGNORE
const ivColor* GetEditColor() { return pdpMisc::GetObjColor(GET_MY_OWNER(Project),&TA_SchedProcess); }
void UpdateAfterEdit();
void Initialize();
void Destroy();
void InitLinks();
void CutLinks();
void Copy_(const SchedProcess& cp);
COPY_FUNS(SchedProcess, Process);
TA_BASEFUNS(SchedProcess);
};
//////////////////////////
// CycleProcess //
//////////////////////////
class CycleProcess : public SchedProcess {
// ##AGGOP_SUM Runs one cycle of activation update
public:
void Initialize();
void Destroy() { };
TA_BASEFUNS(CycleProcess);
};
//////////////////////////
// SettleProcess //
//////////////////////////
class SettleProcess : public SchedProcess {
// ##AGGOP_SUM Settles over cycles of activation propagation
public:
Counter cycle; // Current cycle number
void Initialize();
void Destroy() { };
void InitLinks();
void Copy_(const SettleProcess& cp) { cycle = cp.cycle; }
COPY_FUNS(SettleProcess, SchedProcess);
TA_BASEFUNS(SettleProcess);
};
//////////////////////////
// TrialProcess //
//////////////////////////
class TrialProcess : public SchedProcess {
// ##AGGOP_SUM Runs a single trial (one event)
public:
Event* cur_event;
// #FROM_GROUP_enviro_group the current event (copied from the EpochProc)
EpochProcess* epoch_proc;
// #NO_SUBTYPE #READ_ONLY #NO_SAVE pointer to parent epoch_proc
Event_MGroup* enviro_group; // #READ_ONLY #NO_SAVE main event group on environment
void Init_impl();
bool Crit() { return true; } // prevent endless looping
bool CheckAllTypes_impl();
// do an extra pass of checking at the trial process level
void UpdateAfterEdit(); // modify to update the epoch_proc
void Initialize();
void Destroy() { CutLinks(); }
void CutLinks();
void Copy_(const TrialProcess& cp);
COPY_FUNS(TrialProcess, SchedProcess);
TA_BASEFUNS(TrialProcess);
};
//////////////////////////
// EpochProcess //
//////////////////////////
class EpochProcess : public SchedProcess {
// ##AGGOP_SUM Loops over entire set of trials (events) in the environment. If mulitple dmem processors are available (after network dmem_nprocs) events are distributed across processors and weights synchronized every batch_n for SMALL_BATCH (=ONLINE), at end for BATCH
public:
enum Order {
SEQUENTIAL, // present events in sequential order
PERMUTED, // permute the order of event presentation
RANDOM // pick an event at random (with replacement)
};
enum WtUpdate {
TEST, // don't update weights at all (for testing net)
ON_LINE, // update weights on-line (after every event) -- this is not viable for dmem processing and is automatically switched to small_batch
SMALL_BATCH, // update weights every batch_n events (in SequenceEpoch, see small_batch for how to apply to sequences)
BATCH // update weights in batch (after every epoch)
};
Counter trial; // Current trial number (and index into list)
Event* cur_event; // #FROM_GROUP_enviro_group the current event
Order order; // order to present events in
WtUpdate wt_update; // determines weight update mode
int batch_n; // #CONDEDIT_ON_wt_update:SMALL_BATCH number of events for small_batch learning mode (specifies how often weight changes are synchronized in dmem)
int batch_n_eff; // #READ_ONLY #NO_SAVE effective batch_n value = batch_n except for dmem when it = (batch_n / epc_nprocs) >= 1
int_Array event_list; // #HIDDEN list of events
Event_MGroup* enviro_group; // #READ_ONLY #NO_SAVE main event group on environment
int dmem_nprocs; // maximum number of processors to use for distributed memory computation of events within the epoch (actual = MIN(dmem_nprocs, nprocs / net dmem_nprocs_actual); may be less)
int dmem_nprocs_actual; // #READ_ONLY #NO_SAVE actual number of processors being used = MIN(dmem_nprocs, nprocs / net dmem_nprocs_actual)
int epc_gp; // #IGNORE dmem epoch-level group
int epc_comm; // #IGNORE dmem epoch-level communicator
void Init_impl();
void Loop();
void UpdateState();
bool Crit();
void Final();
virtual void GetEventList(); // get list of events from environment
virtual void GetCurEvent(); // get current event
virtual void Loop_UpdateWeights(); // update the weights within the loop (online or small batch)
virtual void Final_UpdateWeights(); // update the weights at end of epoch (batch mode or small batch)
Event* GetMyNextEvent();
void GetCntrDataItems();
void GenCntrLog(LogData* ld, bool gen);
void NewSeed();
void OldSeed();
#ifdef DMEM_COMPILE
virtual void AllocProcs(); // allocate processors to different tasks..
static void SyncLoopStats(SchedProcess* sp, MPI_Comm ec, int n_stats); // #IGNORE synchronize loop stats across dmem procs
virtual void DMem_UpdateWeights(); // synchronize across dmem procs and update the weights
#else
virtual void AllocProcs() { }; // allocate processors to different tasks..
#endif
void UpdateAfterEdit();
void Initialize();
void Destroy() { CutLinks(); }
void InitLinks();
void CutLinks();
void Copy_(const EpochProcess& cp);
COPY_FUNS(EpochProcess, SchedProcess);
TA_BASEFUNS(EpochProcess);
};
class SequenceProcess : public SchedProcess {
// ##AGGOP_SUM Processes a sequence of trials in one event group (must be under a SequenceEpoch, which loops over event groups)
public:
enum Order {
SEQUENTIAL, // present events in sequential order
PERMUTED, // permute the order of event presentation
RANDOM // pick an event at random (with replacement)
};
enum StateInit { // ways of initializing the state of the network
DO_NOTHING, // do nothing
INIT_STATE, // initialize the network state
MODIFY_STATE // modify state (algorithm specific)
};
Counter tick; // one unit of time in a sequence
Event* cur_event; // #FROM_GROUP_cur_event_gp current event
Event_MGroup* cur_event_gp; // #FROM_GROUP_enviro_group event group
Order order; // order to present events in
StateInit sequence_init; // how to initialize network stat at start of sequence
SequenceEpoch* sequence_epoch;
// #NO_SUBTYPE #READ_ONLY #NO_SAVE pointer to parent epoch process
int_Array event_list; // #HIDDEN list of events
Event_MGroup* enviro_group; // #READ_ONLY #NO_SAVE main event group on environment
void Init_impl();
void Loop();
void UpdateState();
bool Crit();
void Final();
virtual void GetEventList(); // get list of events from environment
virtual void GetCurEvent();
virtual void InitNetState();
virtual void Loop_UpdateWeights();
virtual void Final_UpdateWeights();
Event* GetMyNextEvent();
#ifdef DMEM_COMPILE
virtual void DMem_UpdateWeights(); // #IGNORE
#endif
void GetCntrDataItems();
void GenCntrLog(LogData* ld, bool gen);
void UpdateAfterEdit(); // update the sequence_epoch
void Initialize();
void Destroy();
void InitLinks();
void CutLinks();
void Copy_(const SequenceProcess& cp);
COPY_FUNS(SequenceProcess, SchedProcess);
TA_BASEFUNS(SequenceProcess);
};
class SequenceEpoch : public EpochProcess {
// Loops over sequences (groups of events) instead of individual events (enviro must have event groups!).
public:
enum SmallBatchType {
SEQUENCE, // at the sequence level (batch_n sequences)
EVENT // at the event level (within the sequence, weights updated every batch_n events, with an additional update at end of sequence if needed)
};
SmallBatchType small_batch; // #CONDEDIT_ON_wt_update:SMALL_BATCH how to apply SMALL_BATCH wt_update when using sequences
Event_MGroup* cur_event_gp; // #FROM_GROUP_enviro_group current event group
void Init_impl();
void Loop();
void UpdateState();
bool Crit();
void Final();
void Loop_UpdateWeights();
void Final_UpdateWeights();
void GetEventList();
void GetCurEvent();
Event* GetMyNextEvent();
void GetCntrDataItems();
void GenCntrLog(LogData* ld, bool gen);
void UpdateAfterEdit();
void Initialize();
void Destroy();
void CutLinks();
void Copy_(const SequenceEpoch& cp);
COPY_FUNS(SequenceEpoch, EpochProcess);
TA_BASEFUNS(SequenceEpoch);
};
class InteractiveEpoch : public EpochProcess {
// Loops over events in an environment using the interactive interface of GetNextEvent(), which can generate new events based on current state
public:
int last_trial_val; // #READ_ONLY #NO_SAVE last trial.val when GetCurEvent was called -- decide wether its time to get a new event or not
void GetEventList();
void Loop();
void GetCurEvent();
void UpdateAfterEdit();
void Initialize();
void Destroy() { };
TA_BASEFUNS(InteractiveEpoch);
};
//////////////////////////
// TrainProcess //
//////////////////////////
class NEpochProcess : public SchedProcess {
// ##AGGOP_LAST Runs epochs to train network
public:
Counter epc_ctr; // local epoch counter
int epoch; // epoch count on the network itself
EpochProcess* epoch_proc;
// #NO_SUBTYPE #READ_ONLY #NO_SAVE pointer to epoch process
void Init_impl(); // get epoch
void UpdateCounters(); // also update the network epoch
void GetCntrDataItems();
void GenCntrLog(LogData* ld, bool gen);
void NewSeed();
void OldSeed();
void UpdateAfterEdit(); // get the epoch_proc
void Initialize();
void Destroy() { CutLinks(); }
void InitLinks();
void CutLinks();
void Copy_(const NEpochProcess& cp) { epoch = cp.epoch; }
COPY_FUNS(NEpochProcess, SchedProcess);
TA_BASEFUNS(NEpochProcess);
};
class TrainProcess : public SchedProcess {
// ##AGGOP_LAST Runs epochs to train network
public:
Counter epoch; // Epoch Counter
EpochProcess* epoch_proc;
// #NO_SUBTYPE #READ_ONLY #NO_SAVE pointer to epoch process
void Init_impl(); // also initialize network
void SetReInit(bool ri_val);
void UpdateCounters(); // also update the network epoch
void GetCntrDataItems();
void GenCntrLog(LogData* ld, bool gen);
void NewSeed();
void OldSeed();
void InitAll();
void Run_gui();
void Step();
void UpdateAfterEdit(); // get the epoch_proc
void Initialize();
void Destroy() { CutLinks(); }
void InitLinks();
void CutLinks();
void Copy_(const TrainProcess& cp) { epoch = cp.epoch; }
COPY_FUNS(TrainProcess, SchedProcess);
TA_BASEFUNS(TrainProcess);
};
//////////////////////////
// BatchProcess //
//////////////////////////
class BatchProcess : public SchedProcess {
// ##AGGOP_LAST Runs multiple trainings
public:
Counter batch; // number of batches run
void NewSeed();
void OldSeed();
void Initialize();
void Destroy() { };
void InitLinks();
void Copy_(const BatchProcess& cp) { batch = cp.batch; }
COPY_FUNS(BatchProcess, SchedProcess);
TA_BASEFUNS(BatchProcess);
};
#endif // sched_proc_h
| 41.055738 | 272 | 0.702803 | [
"object"
] |
45f87257c982df47e767043072981f811abfe57a | 32,202 | h | C | include/zephyr/bluetooth/services/ots.h | ParticleBeamHQ/zephyr | aeb06640d343c53b106ce84b3a0d143509abd4a2 | [
"Apache-2.0"
] | 21 | 2019-02-13T02:11:04.000Z | 2020-04-23T19:09:17.000Z | include/zephyr/bluetooth/services/ots.h | ParticleBeamHQ/zephyr | aeb06640d343c53b106ce84b3a0d143509abd4a2 | [
"Apache-2.0"
] | 189 | 2018-12-14T11:44:08.000Z | 2020-05-20T15:14:35.000Z | include/zephyr/bluetooth/services/ots.h | ParticleBeamHQ/zephyr | aeb06640d343c53b106ce84b3a0d143509abd4a2 | [
"Apache-2.0"
] | 186 | 2018-12-14T11:56:22.000Z | 2020-05-15T12:51:11.000Z | /*
* Copyright (c) 2020-2022 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_SERVICES_OTS_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_SERVICES_OTS_H_
/**
* @brief Object Transfer Service (OTS)
* @defgroup bt_ots Object Transfer Service (OTS)
* @ingroup bluetooth
* @{
*
* [Experimental] Users should note that the APIs can change
* as a part of ongoing development.
*/
#ifdef __cplusplus
extern "C" {
#endif
#include <stdbool.h>
#include <zephyr/types.h>
#include <sys/byteorder.h>
#include <sys/types.h>
#include <sys/util.h>
#include <bluetooth/conn.h>
#include <bluetooth/uuid.h>
#include <bluetooth/gatt.h>
/** @brief Size of OTS object ID (in bytes). */
#define BT_OTS_OBJ_ID_SIZE 6
/** @brief Minimum allowed value for object ID (except ID for directory listing) */
#define BT_OTS_OBJ_ID_MIN 0x000000000100
/** @brief Maximum allowed value for object ID (except ID for directory listing) */
#define BT_OTS_OBJ_ID_MAX 0xFFFFFFFFFFFF
/** @brief ID of the Directory Listing Object */
#define OTS_OBJ_ID_DIR_LIST 0x000000000000
/** @brief Mask for OTS object IDs, preserving the 48 bits */
#define BT_OTS_OBJ_ID_MASK BIT64_MASK(48)
/** @brief Length of OTS object ID string (in bytes). */
#define BT_OTS_OBJ_ID_STR_LEN 15
/** @brief Type of an OTS object. */
struct bt_ots_obj_type {
union {
/* Used to indicate UUID type */
struct bt_uuid uuid;
/* 16-bit UUID value */
struct bt_uuid_16 uuid_16;
/* 128-bit UUID value */
struct bt_uuid_128 uuid_128;
};
};
/** @brief Properties of an OTS object. */
enum {
/** Bit 0 Deletion of this object is permitted */
BT_OTS_OBJ_PROP_DELETE = 0,
/** Bit 1 Execution of this object is permitted */
BT_OTS_OBJ_PROP_EXECUTE = 1,
/** Bit 2 Reading this object is permitted */
BT_OTS_OBJ_PROP_READ = 2,
/** Bit 3 Writing data to this object is permitted */
BT_OTS_OBJ_PROP_WRITE = 3,
/** @brief Bit 4 Appending data to this object is permitted.
*
* Appending data increases its Allocated Size.
*/
BT_OTS_OBJ_PROP_APPEND = 4,
/** Bit 5 Truncation of this object is permitted */
BT_OTS_OBJ_PROP_TRUNCATE = 5,
/** @brief Bit 6 Patching this object is permitted
*
* Patching this object overwrites some of
* the object's existing contents.
*/
BT_OTS_OBJ_PROP_PATCH = 6,
/** Bit 7 This object is a marked object */
BT_OTS_OBJ_PROP_MARKED = 7,
};
/** @brief Set @ref BT_OTS_OBJ_PROP_DELETE property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_SET_PROP_DELETE(prop) \
WRITE_BIT(prop, BT_OTS_OBJ_PROP_DELETE, 1)
/** @brief Set @ref BT_OTS_OBJ_PROP_EXECUTE property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_SET_PROP_EXECUTE(prop) \
WRITE_BIT(prop, BT_OTS_OBJ_PROP_EXECUTE, 1)
/** @brief Set @ref BT_OTS_OBJ_PROP_READ property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_SET_PROP_READ(prop) \
WRITE_BIT(prop, BT_OTS_OBJ_PROP_READ, 1)
/** @brief Set @ref BT_OTS_OBJ_PROP_WRITE property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_SET_PROP_WRITE(prop) \
WRITE_BIT(prop, BT_OTS_OBJ_PROP_WRITE, 1)
/** @brief Set @ref BT_OTS_OBJ_PROP_APPEND property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_SET_PROP_APPEND(prop) \
WRITE_BIT(prop, BT_OTS_OBJ_PROP_APPEND, 1)
/** @brief Set @ref BT_OTS_OBJ_PROP_TRUNCATE property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_SET_PROP_TRUNCATE(prop) \
WRITE_BIT(prop, BT_OTS_OBJ_PROP_TRUNCATE, 1)
/** @brief Set @ref BT_OTS_OBJ_PROP_PATCH property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_SET_PROP_PATCH(prop) \
WRITE_BIT(prop, BT_OTS_OBJ_PROP_PATCH, 1)
/** @brief Set @ref BT_OTS_OBJ_SET_PROP_MARKED property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_SET_PROP_MARKED(prop) \
WRITE_BIT(prop, BT_OTS_OBJ_PROP_MARKED, 1)
/** @brief Get @ref BT_OTS_OBJ_PROP_DELETE property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_GET_PROP_DELETE(prop) \
((prop) & BIT(BT_OTS_OBJ_PROP_DELETE))
/** @brief Get @ref BT_OTS_OBJ_PROP_EXECUTE property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_GET_PROP_EXECUTE(prop) \
((prop) & BIT(BT_OTS_OBJ_PROP_EXECUTE))
/** @brief Get @ref BT_OTS_OBJ_PROP_READ property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_GET_PROP_READ(prop) \
((prop) & BIT(BT_OTS_OBJ_PROP_READ))
/** @brief Get @ref BT_OTS_OBJ_PROP_WRITE property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_GET_PROP_WRITE(prop) \
((prop) & BIT(BT_OTS_OBJ_PROP_WRITE))
/** @brief Get @ref BT_OTS_OBJ_PROP_APPEND property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_GET_PROP_APPEND(prop) \
((prop) & BIT(BT_OTS_OBJ_PROP_APPEND))
/** @brief Get @ref BT_OTS_OBJ_PROP_TRUNCATE property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_GET_PROP_TRUNCATE(prop) \
((prop) & BIT(BT_OTS_OBJ_PROP_TRUNCATE))
/** @brief Get @ref BT_OTS_OBJ_PROP_PATCH property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_GET_PROP_PATCH(prop) \
((prop) & BIT(BT_OTS_OBJ_PROP_PATCH))
/** @brief Get @ref BT_OTS_OBJ_PROP_MARKED property.
*
* @param prop Object properties.
*/
#define BT_OTS_OBJ_GET_PROP_MARKED(prop) \
((prop) & BIT(BT_OTS_OBJ_PROP_MARKED))
/** @brief Descriptor for OTS Object Size parameter. */
struct bt_ots_obj_size {
/** @brief Current Size */
uint32_t cur;
/** @brief Allocated Size */
uint32_t alloc;
} __packed;
/** @brief Object Action Control Point Feature bits. */
enum {
/** Bit 0 OACP Create Op Code Supported */
BT_OTS_OACP_FEAT_CREATE = 0,
/** Bit 1 OACP Delete Op Code Supported */
BT_OTS_OACP_FEAT_DELETE = 1,
/** Bit 2 OACP Calculate Checksum Op Code Supported */
BT_OTS_OACP_FEAT_CHECKSUM = 2,
/** Bit 3 OACP Execute Op Code Supported */
BT_OTS_OACP_FEAT_EXECUTE = 3,
/** Bit 4 OACP Read Op Code Supported */
BT_OTS_OACP_FEAT_READ = 4,
/** Bit 5 OACP Write Op Code Supported */
BT_OTS_OACP_FEAT_WRITE = 5,
/** Bit 6 Appending Additional Data to Objects Supported */
BT_OTS_OACP_FEAT_APPEND = 6,
/** Bit 7 Truncation of Objects Supported */
BT_OTS_OACP_FEAT_TRUNCATE = 7,
/** Bit 8 Patching of Objects Supported */
BT_OTS_OACP_FEAT_PATCH = 8,
/** Bit 9 OACP Abort Op Code Supported */
BT_OTS_OACP_FEAT_ABORT = 9,
};
/** @brief Set @ref BT_OTS_OACP_SET_FEAT_CREATE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_CREATE(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_CREATE, 1)
/** @brief Set @ref BT_OTS_OACP_FEAT_DELETE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_DELETE(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_DELETE, 1)
/** @brief Set @ref BT_OTS_OACP_FEAT_CHECKSUM feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_CHECKSUM(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_CHECKSUM, 1)
/** @brief Set @ref BT_OTS_OACP_FEAT_EXECUTE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_EXECUTE(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_EXECUTE, 1)
/** @brief Set @ref BT_OTS_OACP_FEAT_READ feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_READ(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_READ, 1)
/** @brief Set @ref BT_OTS_OACP_FEAT_WRITE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_WRITE(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_WRITE, 1)
/** @brief Set @ref BT_OTS_OACP_FEAT_APPEND feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_APPEND(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_APPEND, 1)
/** @brief Set @ref BT_OTS_OACP_FEAT_TRUNCATE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_TRUNCATE(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_TRUNCATE, 1)
/** @brief Set @ref BT_OTS_OACP_FEAT_PATCH feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_PATCH(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_PATCH, 1)
/** @brief Set @ref BT_OTS_OACP_FEAT_ABORT feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_SET_FEAT_ABORT(feat) \
WRITE_BIT(feat, BT_OTS_OACP_FEAT_ABORT, 1)
/** @brief Get @ref BT_OTS_OACP_FEAT_CREATE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_CREATE(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_CREATE))
/** @brief Get @ref BT_OTS_OACP_FEAT_DELETE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_DELETE(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_DELETE))
/** @brief Get @ref BT_OTS_OACP_FEAT_CHECKSUM feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_CHECKSUM(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_CHECKSUM))
/** @brief Get @ref BT_OTS_OACP_FEAT_EXECUTE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_EXECUTE(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_EXECUTE))
/** @brief Get @ref BT_OTS_OACP_FEAT_READ feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_READ(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_READ))
/** @brief Get @ref BT_OTS_OACP_FEAT_WRITE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_WRITE(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_WRITE))
/** @brief Get @ref BT_OTS_OACP_FEAT_APPEND feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_APPEND(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_APPEND))
/** @brief Get @ref BT_OTS_OACP_FEAT_TRUNCATE feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_TRUNCATE(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_TRUNCATE))
/** @brief Get @ref BT_OTS_OACP_FEAT_PATCH feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_PATCH(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_PATCH))
/** @brief Get @ref BT_OTS_OACP_FEAT_ABORT feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OACP_GET_FEAT_ABORT(feat) \
((feat) & BIT(BT_OTS_OACP_FEAT_ABORT))
/** @brief Object List Control Point Feature bits. */
enum {
/** Bit 0 OLCP Go To Op Code Supported */
BT_OTS_OLCP_FEAT_GO_TO = 0,
/** Bit 1 OLCP Order Op Code Supported */
BT_OTS_OLCP_FEAT_ORDER = 1,
/** Bit 2 OLCP Request Number of Objects Op Code Supported */
BT_OTS_OLCP_FEAT_NUM_REQ = 2,
/** Bit 3 OLCP Clear Marking Op Code Supported*/
BT_OTS_OLCP_FEAT_CLEAR = 3,
};
/** @brief Set @ref BT_OTS_OLCP_FEAT_GO_TO feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OLCP_SET_FEAT_GO_TO(feat) \
WRITE_BIT(feat, BT_OTS_OLCP_FEAT_GO_TO, 1)
/** @brief Set @ref BT_OTS_OLCP_FEAT_ORDER feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OLCP_SET_FEAT_ORDER(feat) \
WRITE_BIT(feat, BT_OTS_OLCP_FEAT_ORDER, 1)
/** @brief Set @ref BT_OTS_OLCP_FEAT_NUM_REQ feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OLCP_SET_FEAT_NUM_REQ(feat) \
WRITE_BIT(feat, BT_OTS_OLCP_FEAT_NUM_REQ, 1)
/** @brief Set @ref BT_OTS_OLCP_FEAT_CLEAR feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OLCP_SET_FEAT_CLEAR(feat) \
WRITE_BIT(feat, BT_OTS_OLCP_FEAT_CLEAR, 1)
/** @brief Get @ref BT_OTS_OLCP_GET_FEAT_GO_TO feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OLCP_GET_FEAT_GO_TO(feat) \
((feat) & BIT(BT_OTS_OLCP_FEAT_GO_TO))
/** @brief Get @ref BT_OTS_OLCP_GET_FEAT_ORDER feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OLCP_GET_FEAT_ORDER(feat) \
((feat) & BIT(BT_OTS_OLCP_FEAT_ORDER))
/** @brief Get @ref BT_OTS_OLCP_GET_FEAT_NUM_REQ feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OLCP_GET_FEAT_NUM_REQ(feat) \
((feat) & BIT(BT_OTS_OLCP_FEAT_NUM_REQ))
/** @brief Get @ref BT_OTS_OLCP_GET_FEAT_CLEAR feature.
*
* @param feat OTS features.
*/
#define BT_OTS_OLCP_GET_FEAT_CLEAR(feat) \
((feat) & BIT(BT_OTS_OLCP_FEAT_CLEAR))
/**@brief Features of the OTS. */
struct bt_ots_feat {
/* OACP Features */
uint32_t oacp;
/* OLCP Features */
uint32_t olcp;
} __packed;
/** @brief Object metadata request bit field values */
enum {
/** @brief Request object name */
BT_OTS_METADATA_REQ_NAME = BIT(0),
/** @brief Request object type */
BT_OTS_METADATA_REQ_TYPE = BIT(1),
/** @brief Request object size */
BT_OTS_METADATA_REQ_SIZE = BIT(2),
/** @brief Request object first created time */
BT_OTS_METADATA_REQ_CREATED = BIT(3),
/** @brief Request object last modified time */
BT_OTS_METADATA_REQ_MODIFIED = BIT(4),
/** @brief Request object ID */
BT_OTS_METADATA_REQ_ID = BIT(5),
/** @brief Request object properties */
BT_OTS_METADATA_REQ_PROPS = BIT(6),
/** @brief Request all object metadata */
BT_OTS_METADATA_REQ_ALL = 0x7F,
};
/** @brief Date and Time structure */
struct bt_ots_date_time {
uint16_t year;
uint8_t month;
uint8_t day;
uint8_t hours;
uint8_t minutes;
uint8_t seconds;
};
#define BT_OTS_DATE_TIME_FIELD_SIZE 7
/** @brief Metadata of an OTS object
*
* Used by the server as a descriptor for OTS object initialization.
* Used by the client to present object metadata to the application.
*/
struct bt_ots_obj_metadata {
#if defined(CONFIG_BT_OTS)
/** @brief Object Name */
char *name;
#endif /* CONFIG_BT_OTS */
#if defined(CONFIG_BT_OTS_CLIENT)
/* TODO: Unify client/server name */
/** @brief Object name (client) */
char name_c[CONFIG_BT_OTS_OBJ_MAX_NAME_LEN + 1];
#endif /* CONFIG_BT_OTS_CLIENT */
/** @brief Object Type */
struct bt_ots_obj_type type;
/** @brief Object Size */
struct bt_ots_obj_size size;
#if defined(CONFIG_BT_OTS_CLIENT)
/** @brief Object first created time */
struct bt_ots_date_time first_created;
/** @brief Object last modified time */
struct bt_ots_date_time modified;
/** @brief Object ID */
uint64_t id;
#endif /* CONFIG_BT_OTS_CLIENT */
/** @brief Object Properties */
uint32_t props;
};
/** @brief Opaque OTS instance. */
struct bt_ots;
/** @brief Descriptor for OTS object addition */
struct bt_ots_obj_add_param {
/** @brief Object size to allocate */
uint32_t size;
/** @brief Object type */
struct bt_ots_obj_type type;
};
/** @brief Descriptor for OTS created object.
*
* Descriptor for OTS object created by the application. This descriptor is
* returned by @ref bt_ots_cb.obj_created callback which contains further
* documentation on distinguishing between server and client object creation.
*/
struct bt_ots_obj_created_desc {
/** @brief Object name
*
* The object name as a NULL terminated string.
*
* When the server creates a new object the name
* shall be > 0 and <= BT_OTS_OBJ_MAX_NAME_LEN
* When the client creates a new object the name
* shall be an empty string
*/
char *name;
/** @brief Object size
*
* @ref bt_ots_obj_size.alloc shall be >= @ref bt_ots_obj_add_param.size
*
* When the server creates a new object @ref bt_ots_obj_size.cur
* shall be <= @ref bt_ots_obj_add_param.size
* When the client creates a new object @ref bt_ots_obj_size.cur
* shall be 0
*/
struct bt_ots_obj_size size;
/** @brief Object properties */
uint32_t props;
};
/** @brief OTS callback structure. */
struct bt_ots_cb {
/** @brief Object created callback
*
* This callback is called whenever a new object is created.
* Application can reject this request by returning an error
* when it does not have necessary resources to hold this new
* object. This callback is also triggered when the server
* creates a new object with bt_ots_obj_add() API.
*
* @param ots OTS instance.
* @param conn The connection that is requesting object creation or
* NULL if object is created by bt_ots_obj_add().
* @param id Object ID.
* @param add_param Object creation requested parameters.
* @param created_desc Created object descriptor that shall be filled by the
* receiver of this callback.
*
* @return 0 in case of success or negative value in case of error.
* @return -ENOTSUP if object type is not supported
* @return -ENOMEM if no available space for new object.
* @return -EINVAL if an invalid parameter is provided
* @return other negative values are treated as a generic operation failure
*/
int (*obj_created)(struct bt_ots *ots, struct bt_conn *conn, uint64_t id,
const struct bt_ots_obj_add_param *add_param,
struct bt_ots_obj_created_desc *created_desc);
/** @brief Object deleted callback
*
* This callback is called whenever an object is deleted. It is
* also triggered when the server deletes an object with
* bt_ots_obj_delete() API.
*
* @param ots OTS instance.
* @param conn The connection that deleted the object or NULL if
* this request came from the server.
* @param id Object ID.
*
* @retval When an error is indicated by using a negative value, the
* object delete procedure is aborted and a corresponding failed
* status is returned to the client.
* @return 0 in case of success.
* @return -EBUSY if the object is locked. This is generally not expected
* to be returned by the application as the OTS layer tracks object
* accesses. An object locked status is returned to the client.
* @return Other negative values in case of error. A generic operation
* failed status is returned to the client.
*/
int (*obj_deleted)(struct bt_ots *ots, struct bt_conn *conn,
uint64_t id);
/** @brief Object selected callback
*
* This callback is called on successful object selection.
*
* @param ots OTS instance.
* @param conn The connection that selected new object.
* @param id Object ID.
*/
void (*obj_selected)(struct bt_ots *ots, struct bt_conn *conn,
uint64_t id);
/** @brief Object read callback
*
* This callback is called multiple times during the Object read
* operation. OTS module will keep requesting successive Object
* fragments from the application until the read operation is
* completed. The end of read operation is indicated by NULL data
* parameter.
*
* @param ots OTS instance.
* @param conn The connection that read object.
* @param id Object ID.
* @param data In: NULL once the read operations is completed.
* Out: Next chunk of data to be sent.
* @param len Remaining length requested by the client.
* @param offset Object data offset.
*
* @return Data length to be sent via data parameter. This value
* shall be smaller or equal to the len parameter.
* @return Negative value in case of an error.
*/
ssize_t (*obj_read)(struct bt_ots *ots, struct bt_conn *conn,
uint64_t id, void **data, size_t len,
off_t offset);
/** @brief Object write callback
*
* This callback is called multiple times during the Object write
* operation. OTS module will keep providing successive Object
* fragments to the application until the write operation is
* completed. The offset and length of each write fragment is
* validated by the OTS module to be within the allocated size
* of the object. The remaining length indicates data length
* remaining to be written and will decrease each write iteration
* until it reaches 0 in the last write fragment.
*
* @param ots OTS instance.
* @param conn The connection that wrote object.
* @param id Object ID.
* @param data Next chunk of data to be written.
* @param len Length of the current chunk of data in the buffer.
* @param offset Object data offset.
* @param rem Remaining length in the write operation.
*
* @return Number of bytes written in case of success, if the number
* of bytes written does not match len, -EIO is returned to
* the L2CAP layer.
* @return A negative value in case of an error.
* @return -EINPROGRESS has a special meaning and is unsupported at
* the moment. It should not be returned.
*/
ssize_t (*obj_write)(struct bt_ots *ots, struct bt_conn *conn, uint64_t id,
const void *data, size_t len, off_t offset,
size_t rem);
/** @brief Object name written callback
*
* This callback is called when the object name is written.
* This is a notification to the application that the object name
* will be updated by the OTS service implementation.
*
* @param ots OTS instance.
* @param conn The connection that wrote object name.
* @param id Object ID.
* @param cur_name Current object name.
* @param new_name New object name.
*/
void (*obj_name_written)(struct bt_ots *ots, struct bt_conn *conn,
uint64_t id, const char *cur_name, const char *new_name);
};
/** @brief Descriptor for OTS initialization. */
struct bt_ots_init {
/* OTS features */
struct bt_ots_feat features;
/* Callbacks */
struct bt_ots_cb *cb;
};
/** @brief Add an object to the OTS instance.
*
* This function adds an object to the OTS database. When the
* object is being added, a callback obj_created() is called
* to notify the user about a new object ID.
*
* @param ots OTS instance.
* @param param Object addition parameters.
*
* @return ID of created object in case of success.
* @return negative value in case of error.
*/
int bt_ots_obj_add(struct bt_ots *ots, const struct bt_ots_obj_add_param *param);
/** @brief Delete an object from the OTS instance.
*
* This function deletes an object from the OTS database. When the
* object is deleted a callback obj_deleted() is called
* to notify the user about this event. At this point, it is possible
* to free allocated buffer for object data.
*
* @param ots OTS instance.
* @param id ID of the object to be deleted (uint48).
*
* @return 0 in case of success or negative value in case of error.
*/
int bt_ots_obj_delete(struct bt_ots *ots, uint64_t id);
/** @brief Get the service declaration attribute.
*
* This function is enabled for CONFIG_BT_OTS_SECONDARY_SVC configuration.
* The first service attribute can be included in any other GATT service.
*
* @param ots OTS instance.
*
* @return The first OTS attribute instance.
*/
void *bt_ots_svc_decl_get(struct bt_ots *ots);
/** @brief Initialize the OTS instance.
*
* @param ots OTS instance.
* @param ots_init OTS initialization descriptor.
*
* @return 0 in case of success or negative value in case of error.
*/
int bt_ots_init(struct bt_ots *ots, struct bt_ots_init *ots_init);
/** @brief Get a free instance of OTS from the pool.
*
* @return OTS instance in case of success or NULL in case of error.
*/
struct bt_ots *bt_ots_free_instance_get(void);
#define BT_OTS_STOP 0
#define BT_OTS_CONTINUE 1
/* TODO: Merge server and client instance as opaque type */
/** @brief OTS client instance */
struct bt_ots_client {
uint16_t start_handle;
uint16_t end_handle;
uint16_t feature_handle;
uint16_t obj_name_handle;
uint16_t obj_type_handle;
uint16_t obj_size_handle;
uint16_t obj_properties_handle;
uint16_t obj_created_handle;
uint16_t obj_modified_handle;
uint16_t obj_id_handle;
uint16_t oacp_handle;
uint16_t olcp_handle;
struct bt_gatt_subscribe_params oacp_sub_params;
struct bt_gatt_discover_params oacp_sub_disc_params;
struct bt_gatt_subscribe_params olcp_sub_params;
struct bt_gatt_discover_params olcp_sub_disc_params;
struct bt_gatt_write_params write_params;
struct bt_gatt_read_params read_proc;
struct bt_ots_client_cb *cb;
struct bt_ots_feat features;
struct bt_ots_obj_metadata cur_object;
};
/** OTS client callback structure */
struct bt_ots_client_cb {
/** @brief Callback function when a new object is selected.
*
* Called when the a new object is selected and the current
* object has changed. The `cur_object` in `ots_inst` will
* have been reset, and metadata should be read again with
* bt_ots_client_read_object_metadata().
*
* @param ots_inst Pointer to the OTC instance.
* @param conn The connection to the peer device.
* @param err Error code (bt_ots_olcp_res_code).
*/
void (*obj_selected)(struct bt_ots_client *ots_inst,
struct bt_conn *conn, int err);
/** @brief Callback function for the data of the selected
* object.
*
* Called when the data of the selected object are read using
* bt_ots_client_read_object_data().
*
* @param ots_inst Pointer to the OTC instance.
* @param conn The connection to the peer device.
* @param offset Offset of the received data.
* @param len Length of the received data.
* @param data_p Pointer to the received data.
* @param is_complete Indicate if the whole object has been received.
*
* @return int BT_OTS_STOP or BT_OTS_CONTINUE. BT_OTS_STOP can
* be used to stop reading.
*/
int (*obj_data_read)(struct bt_ots_client *ots_inst,
struct bt_conn *conn, uint32_t offset,
uint32_t len, uint8_t *data_p, bool is_complete);
/** @brief Callback function for metadata of the selected object.
*
* Called when metadata of the selected object are read using
* bt_ots_client_read_object_metadata().
* Not all of the metadata may have been initialized.
*
* @param ots_inst Pointer to the OTC instance.
* @param conn The connection to the peer device.
* @param err Error value. 0 on success,
* GATT error or ERRNO on fail.
* @param metadata_read Bitfield of the metadata that was
* successfully read.
*/
void (*obj_metadata_read)(struct bt_ots_client *ots_inst,
struct bt_conn *conn, int err,
uint8_t metadata_read);
};
/** @brief Register an Object Transfer Service Instance.
*
* Register an Object Transfer Service instance discovered on the peer.
* Call this function when an OTS instance is discovered
* (discovery is to be handled by the higher layer).
*
* @param[in] ots_inst Discovered OTS instance.
*
* @return int 0 if success, ERRNO on failure.
*/
int bt_ots_client_register(struct bt_ots_client *ots_inst);
/** @brief OTS Indicate Handler function.
*
* Set this function as callback for indicate handler when discovering OTS.
*
* @param conn Connection object. May be NULL, indicating that the
* peer is being unpaired.
* @param params Subscription parameters.
* @param data Attribute value data. If NULL then subscription was
* removed.
* @param length Attribute value length.
*/
uint8_t bt_ots_client_indicate_handler(struct bt_conn *conn,
struct bt_gatt_subscribe_params *params,
const void *data, uint16_t length);
/** @brief Read the OTS feature characteristic.
*
* @param otc_inst Pointer to the OTC instance.
* @param conn Pointer to the connection object.
*
* @return int 0 if success, ERRNO on failure.
*/
int bt_ots_client_read_feature(struct bt_ots_client *otc_inst,
struct bt_conn *conn);
/** @brief Select an object by its Object ID.
*
* @param otc_inst Pointer to the OTC instance.
* @param conn Pointer to the connection object.
* @param obj_id Object's ID.
*
* @return int 0 if success, ERRNO on failure.
*/
int bt_ots_client_select_id(struct bt_ots_client *otc_inst,
struct bt_conn *conn,
uint64_t obj_id);
/** @brief Select the first object.
*
* @param otc_inst Pointer to the OTC instance.
* @param conn Pointer to the connection object.
*
* @return int 0 if success, ERRNO on failure.
*/
int bt_ots_client_select_first(struct bt_ots_client *otc_inst,
struct bt_conn *conn);
/** @brief Select the last object.
*
* @param otc_inst Pointer to the OTC instance.
* @param conn Pointer to the connection object.
*
* @return int 0 if success, ERRNO on failure.
*/
int bt_ots_client_select_last(struct bt_ots_client *otc_inst,
struct bt_conn *conn);
/** @brief Select the next object.
*
* @param otc_inst Pointer to the OTC instance.
* @param conn Pointer to the connection object.
*
* @return int 0 if success, ERRNO on failure.
*/
int bt_ots_client_select_next(struct bt_ots_client *otc_inst,
struct bt_conn *conn);
/** @brief Select the previous object.
*
* @param otc_inst Pointer to the OTC instance.
* @param conn Pointer to the connection object.
*
* @return int 0 if success, ERRNO on failure.
*/
int bt_ots_client_select_prev(struct bt_ots_client *otc_inst,
struct bt_conn *conn);
/** @brief Read the metadata of the current object.
*
* The metadata are returned in the obj_metadata_read() callback.
*
* @param otc_inst Pointer to the OTC instance.
* @param conn Pointer to the connection object.
* @param metadata Bitfield (`BT_OTS_METADATA_REQ_*`) of the metadata
* to read.
*
* @return int 0 if success, ERRNO on failure.
*/
int bt_ots_client_read_object_metadata(struct bt_ots_client *otc_inst,
struct bt_conn *conn,
uint8_t metadata);
/** @brief Read the data of the current selected object.
*
* This will trigger an OACP read operation for the current size of the object
* with a 0 offset and then expect receiving the content via the L2CAP CoC.
*
* The data of the object are returned in the obj_data_read() callback.
*
* @param otc_inst Pointer to the OTC instance.
* @param conn Pointer to the connection object.
*
* @return int 0 if success, ERRNO on failure.
*/
int bt_ots_client_read_object_data(struct bt_ots_client *otc_inst,
struct bt_conn *conn);
/** @brief Directory listing object metadata callback
*
* If a directory listing is decoded using bt_ots_client_decode_dirlisting(),
* this callback will be called for each object in the directory listing.
*
* @param meta The metadata of the decoded object
*
* @return int BT_OTS_STOP or BT_OTS_CONTINUE. BT_OTS_STOP can be used to
* stop the decoding.
*/
typedef int (*bt_ots_client_dirlisting_cb)(struct bt_ots_obj_metadata *meta);
/** @brief Decode Directory Listing object into object metadata.
*
* If the Directory Listing object contains multiple objects, then the
* callback will be called for each of them.
*
* @param data The data received for the directory listing object.
* @param length Length of the data.
* @param cb The callback that will be called for each object.
*/
int bt_ots_client_decode_dirlisting(uint8_t *data, uint16_t length,
bt_ots_client_dirlisting_cb cb);
/** @brief Converts binary OTS Object ID to string.
*
* @param obj_id Object ID.
* @param str Address of user buffer with enough room to store
* formatted string containing binary Object ID.
* @param len Length of data to be copied to user string buffer.
* Refer to BT_OTS_OBJ_ID_STR_LEN about
* recommended value.
*
* @return Number of successfully formatted bytes from binary ID.
*/
static inline int bt_ots_obj_id_to_str(uint64_t obj_id, char *str, size_t len)
{
uint8_t id[6];
sys_put_le48(obj_id, id);
return snprintk(str, len, "0x%02X%02X%02X%02X%02X%02X",
id[5], id[4], id[3], id[2], id[1], id[0]);
}
/** @brief Displays one or more object metadata as text with BT_INFO.
*
* @param metadata Pointer to the first (or only) metadata in an array.
* @param count Number of metadata objects to display information of.
*/
void bt_ots_metadata_display(struct bt_ots_obj_metadata *metadata,
uint16_t count);
#ifdef __cplusplus
}
#endif
/**
* @}
*/
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_SERVICES_OTS_H_ */
| 30.581197 | 83 | 0.697348 | [
"object"
] |
340c2109d32329767782c63478f6079def48c4a0 | 13,508 | c | C | +audstream/source/PsychSourceGL/Source/Common/Screen/PsychVideoCaptureSupport.c | peterzh/signals | 5ab72195ff532f07d23efeba040a320affb0d18d | [
"Apache-2.0"
] | 3 | 2018-06-25T23:13:45.000Z | 2019-11-22T15:03:17.000Z | PsychSourceGL/Source/Common/Screen/PsychVideoCaptureSupport.c | aleslab/Psychtoolbox-3-aleslab-fork | 2df66e5fb8c20d5d7bf0a91ce11562331afd4352 | [
"MIT"
] | 15 | 2018-05-01T18:04:54.000Z | 2020-02-15T19:58:30.000Z | PsychSourceGL/Source/Common/Screen/PsychVideoCaptureSupport.c | aleslab/Psychtoolbox-3-aleslab-fork | 2df66e5fb8c20d5d7bf0a91ce11562331afd4352 | [
"MIT"
] | 7 | 2018-05-01T17:46:30.000Z | 2020-05-14T00:00:30.000Z | /*
Common/Screen/PsychVideoCaptureSupport.c
PLATFORMS:
This is the OS independent version (for now: Should work on OS-X and Windows)
A GNU/Linux specific version is stored in the /Linux/ folder. It has the
same API - and therefore the same header file, but a pretty different
implementation.
AUTHORS:
Mario Kleiner mk mario.kleiner@tuebingen.mpg.de
HISTORY:
DESCRIPTION:
Psychtoolbox functions for dealing with video capture devices.
NOTES:
*/
#include "Screen.h"
#include <float.h>
// Forward declaration of internal helper function:
void PsychDeleteAllCaptureDevices(void);
// Record which defines capture engine independent state for a capture device:
typedef struct {
int engineId; // Type of capture engine: -1 == Free slot, 0 == Quicktime, 1 == LibDC, 2 == ARVideo, 3 == GStreamer
} PsychMasterVidcapRecordType;
static PsychMasterVidcapRecordType mastervidcapRecordBANK[PSYCH_MAX_CAPTUREDEVICES];
static int numCaptureRecords = 0;
static psych_bool firsttime = TRUE;
/*
* PsychVideoCaptureInit() -- Initialize video capture subsystem.
* This routine is called by Screen's RegisterProject.c PsychModuleInit()
* routine at Screen load-time. It clears out the vidcapRecordBANK to
* bring the subsystem into a clean initial state.
*/
void PsychVideoCaptureInit(void)
{
// Initialize mastervidcapRecordBANK with NULL-entries:
int i;
for (i=0; i < PSYCH_MAX_CAPTUREDEVICES; i++) {
mastervidcapRecordBANK[i].engineId = -1;
}
numCaptureRecords = 0;
// Initialize the different capture engines:
#ifdef PTBVIDEOCAPTURE_LIBDC
PsychDCVideoCaptureInit();
#endif
#ifdef PTB_USE_GSTREAMER
PsychGSVideoCaptureInit();
#endif
return;
}
void PsychEnumerateVideoSources(int engineId, int outPos)
{
psych_bool dispatched = FALSE;
#ifdef PTBVIDEOCAPTURE_LIBDC
if (engineId == 1) {
PsychDCEnumerateVideoSources(outPos);
dispatched = TRUE;
}
#endif
#ifdef PTB_USE_GSTREAMER
if (engineId == 3) {
// GStreamer device enumeration:
PsychGSEnumerateVideoSources(outPos, -1, NULL);
dispatched = TRUE;
}
#endif
// Unsupported engine requested?
if (!dispatched) PsychErrorExitMsg(PsychError_user, "The requested video capture engine is not supported on your system, either not at all, or has been disabled at compile time.");
return;
}
/*
* PsychOpenVideoCaptureDevice() -- Create a video capture object.
*
* This function tries to open a video capture device and return the associated captureHandle for it.
*
* engineId = Type of video capture engine to use: 0 == Quicktime sequence grabbers, 1 == LibDC1394-V2 IIDC Firewire.
* win = Pointer to window record of associated onscreen window.
* deviceIndex = Index of the grabber device. (Currently ignored)
* capturehandle = handle to the new capture object.
* capturerectangle = If non-NULL a ptr to a PsychRectangle which contains the ROI for capture.
* The following arguments are currently ignored on Windows and OS-X:
* reqdepth = Number of layers for captured output textures. (0=Don't care, 1=LUMINANCE8, 2=LUMINANCE8_ALPHA8, 3=RGB8, 4=RGBA8)
* num_dmabuffers = Number of buffers in the ringbuffer queue (e.g., DMA buffers) - This is OS specific. Zero = Don't care.
* allow_lowperf_fallback = If set to 1 then PTB can use a slower, low-performance fallback path to get nasty devices working.
* targetmoviefilename = NULL == Only live capture, non-NULL == Pointer to char-string with name of target QT file for video recording.
* recordingflags = Only used for recording: Request audio recording, ram recording vs. disk recording and such...
* // Query optional movie recording flags:
* // 0 = Record video, stream to disk immediately (slower, but unlimited recording duration).
* // 1 = Record video, stream to memory, then at end of recording to disk (limited duration by RAM size, but faster).
* // 2 = Record audio as well.
*
* bitdepth = Number of bits per color component / channel, aka bpc.
*
*/
psych_bool PsychOpenVideoCaptureDevice(int engineId, PsychWindowRecordType *win, int deviceIndex, int* capturehandle, double* capturerectangle,
int reqdepth, int num_dmabuffers, int allow_lowperf_fallback, char* targetmoviefilename, unsigned int recordingflags, int bitdepth)
{
int i, slotid;
psych_bool dispatched = FALSE;
*capturehandle = -1;
// Sanity checking:
if (!PsychIsOnscreenWindow(win)) {
PsychErrorExitMsg(PsychError_user, "Provided windowPtr is not an onscreen window.");
}
if (numCaptureRecords >= PSYCH_MAX_CAPTUREDEVICES) {
PsychErrorExitMsg(PsychError_user, "Allowed maximum number of simultaneously open capture devices exceeded!");
}
// Search first free slot in mastervidcapRecordBANK:
for (i=0; (i < PSYCH_MAX_CAPTUREDEVICES) && (mastervidcapRecordBANK[i].engineId != -1); i++) {};
if (i>=PSYCH_MAX_CAPTUREDEVICES) {
PsychErrorExitMsg(PsychError_user, "Allowed maximum number of simultaneously open capture devices exceeded!");
}
// Slot slotid will contain the record for our new capture object:
slotid=i;
// Decide which engine to use and dispatch into proper open function:
#ifdef PTBVIDEOCAPTURE_LIBDC
if (engineId == 1) {
// LibDC1394 video capture:
if (!PsychDCOpenVideoCaptureDevice(slotid, win, deviceIndex, capturehandle, capturerectangle, reqdepth,
num_dmabuffers, allow_lowperf_fallback, targetmoviefilename, recordingflags, bitdepth)) {
// Probably won't ever reach this point due to error handling triggered in subfunction... anyway...
return(FALSE);
}
dispatched = TRUE;
}
#endif
#ifdef PTB_USE_GSTREAMER
if (engineId == 3) {
// GStreamer video capture:
if (!PsychGSOpenVideoCaptureDevice(slotid, win, deviceIndex, capturehandle, capturerectangle, reqdepth,
num_dmabuffers, allow_lowperf_fallback, targetmoviefilename, recordingflags, bitdepth)) {
// Probably won't ever reach this point due to error handling triggered in subfunction... anyway...
return(FALSE);
}
dispatched = TRUE;
}
#endif
// Unsupported engine requested?
if (!dispatched) PsychErrorExitMsg(PsychError_user, "The requested video capture engine is not supported on your system, either not at all, or has been disabled at compile time.");
// Ok, new capture device for requested capture engine created...
// Assign new record:
mastervidcapRecordBANK[slotid].engineId = engineId;
// Assign final handle:
*capturehandle = slotid;
// Increase counter:
numCaptureRecords++;
// Ready.
return(TRUE);
}
/*
* PsychCloseVideoCaptureDevice() -- Close a capture device and release all associated ressources.
*/
void PsychCloseVideoCaptureDevice(int capturehandle)
{
if (capturehandle < 0 || capturehandle >= PSYCH_MAX_CAPTUREDEVICES) {
PsychErrorExitMsg(PsychError_user, "Invalid capturehandle provided!");
}
if (mastervidcapRecordBANK[capturehandle].engineId == -1) {
PsychErrorExitMsg(PsychError_user, "Invalid capturehandle provided. No capture device associated with this handle !!!");
}
// Call engine specific method:
#ifdef PTBVIDEOCAPTURE_LIBDC
if (mastervidcapRecordBANK[capturehandle].engineId == 1) PsychDCCloseVideoCaptureDevice(capturehandle);
#endif
#ifdef PTB_USE_GSTREAMER
if (mastervidcapRecordBANK[capturehandle].engineId == 3) PsychGSCloseVideoCaptureDevice(capturehandle);
#endif
// Release record:
mastervidcapRecordBANK[capturehandle].engineId = -1;
// Decrease counter:
if (numCaptureRecords>0) numCaptureRecords--;
return;
}
/*
* PsychDeleteAllCaptureDevices() -- Delete all capture objects and release all associated ressources.
*/
void PsychDeleteAllCaptureDevices(void)
{
int i;
for (i=0; i<PSYCH_MAX_CAPTUREDEVICES; i++) {
if (mastervidcapRecordBANK[i].engineId !=-1) PsychCloseVideoCaptureDevice(i);
}
return;
}
/*
* PsychGetTextureFromCapture() -- Create an OpenGL texturemap from a specific videoframe from given capture object.
*
* win = Window pointer of onscreen window for which a OpenGL texture should be created.
* capturehandle = Handle to the capture object.
* checkForImage = >0 == Just check if new image available, 0 == really retrieve the image, blocking if necessary.
* 2 == Check for new image, block inside this function (if possible) if no image available.
* timeindex = This parameter is currently ignored and reserved for future use.
* out_texture = Pointer to the Psychtoolbox texture-record where the new texture should be stored.
* presentation_timestamp = A ptr to a double variable, where the presentation timestamp of the returned frame should be stored.
* summed_intensity = An optional ptr to a double variable. If non-NULL, then sum of intensities over all channels is calculated and returned.
* outrawbuffer = An optional ptr to a memory buffer of sufficient size. If non-NULL, the buffer will be filled with the captured raw image data, e.g., for use inside Matlab or whatever...
* Returns Number of pending or dropped frames after fetch on success (>=0), -1 if no new image available yet, -2 if no new image available and there won't be any in future.
*/
int PsychGetTextureFromCapture(PsychWindowRecordType *win, int capturehandle, int checkForImage, double timeindex, PsychWindowRecordType *out_texture, double *presentation_timestamp, double* summed_intensity, rawcapimgdata* outrawbuffer)
{
// Sanity checks:
if (capturehandle < 0 || capturehandle >= PSYCH_MAX_CAPTUREDEVICES || mastervidcapRecordBANK[capturehandle].engineId == -1) {
PsychErrorExitMsg(PsychError_user, "Invalid capturehandle provided.");
}
// Call engine specific method:
#ifdef PTBVIDEOCAPTURE_LIBDC
if (mastervidcapRecordBANK[capturehandle].engineId == 1) return(PsychDCGetTextureFromCapture(win, capturehandle, checkForImage, timeindex, out_texture, presentation_timestamp, summed_intensity, outrawbuffer));
#endif
#ifdef PTB_USE_GSTREAMER
if (mastervidcapRecordBANK[capturehandle].engineId == 3) return(PsychGSGetTextureFromCapture(win, capturehandle, checkForImage, timeindex, out_texture, presentation_timestamp, summed_intensity, outrawbuffer));
#endif
return(-2);
}
/*
* PsychVideoCaptureRate() - Start- and stop video capture.
*
* capturehandle = Grabber to start-/stop.
* playbackrate = zero == Stop capture, non-zero == Capture
* dropframes = At 'start': Decide if low latency capture shall be used. At 'stop' If zero, don't
* discard pending buffers in internal capture queue.
* startattime = Deadline (in system time) to wait for before real start of capture.
* Returns Number of dropped frames during capture.
*/
int PsychVideoCaptureRate(int capturehandle, double capturerate, int dropframes, double* startattime)
{
if (capturehandle < 0 || capturehandle >= PSYCH_MAX_CAPTUREDEVICES || mastervidcapRecordBANK[capturehandle].engineId == -1) {
PsychErrorExitMsg(PsychError_user, "Invalid capturehandle provided!");
}
// Call engine specific method:
#ifdef PTBVIDEOCAPTURE_LIBDC
if (mastervidcapRecordBANK[capturehandle].engineId == 1) return(PsychDCVideoCaptureRate(capturehandle, capturerate, dropframes, startattime));
#endif
#ifdef PTB_USE_GSTREAMER
if (mastervidcapRecordBANK[capturehandle].engineId == 3) return(PsychGSVideoCaptureRate(capturehandle, capturerate, dropframes, startattime));
#endif
return(0);
}
/* Set capture device specific parameters:
* On OS-X and Windows (and therefore in this implementation) this is currently a no-op, until
* we find out how to do this with the Sequence-Grabber API.
*/
double PsychVideoCaptureSetParameter(int capturehandle, const char* pname, double value)
{
// Valid handle provided? -1 is a special "carte blanche" handle.
if (capturehandle < -1 || capturehandle >= PSYCH_MAX_CAPTUREDEVICES) {
PsychErrorExitMsg(PsychError_user, "Invalid capturehandle provided!");
}
if ((capturehandle != -1) && (mastervidcapRecordBANK[capturehandle].engineId == -1)) {
PsychErrorExitMsg(PsychError_user, "Invalid capturehandle provided! No such capture device open.");
}
// Call engine specific method: capturehandle == -1 calls *all* engines:
#ifdef PTBVIDEOCAPTURE_LIBDC
if ((capturehandle == -1) || (mastervidcapRecordBANK[capturehandle].engineId == 1)) {
if (capturehandle != -1) {
return(PsychDCVideoCaptureSetParameter(capturehandle, pname, value));
}
else PsychDCVideoCaptureSetParameter(capturehandle, pname, value);
}
#endif
#ifdef PTB_USE_GSTREAMER
if ((capturehandle == -1) || (mastervidcapRecordBANK[capturehandle].engineId == 3)) {
if (capturehandle != -1) {
return(PsychGSVideoCaptureSetParameter(capturehandle, pname, value));
}
else PsychGSVideoCaptureSetParameter(capturehandle, pname, value);
}
#endif
return(0);
}
/*
* void PsychExitVideoCapture() - Shutdown handler.
*
* This routine is called by Screen('CloseAll') and on clear Screen time to
* do final cleanup. It deletes all capture objects
*
*/
void PsychExitVideoCapture(void)
{
// Release all capture devices:
PsychDeleteAllCaptureDevices();
// Call engine specific method:
#ifdef PTBVIDEOCAPTURE_LIBDC
PsychDCExitVideoCapture();
#endif
#ifdef PTB_USE_GSTREAMER
PsychGSExitVideoCapture();
#endif
firsttime = TRUE;
return;
}
| 38.48433 | 237 | 0.737045 | [
"object"
] |
341760397c98fbd2f62b0d01787643e3eaa4f6a8 | 22,089 | c | C | deps/cl342/cryptusr.c | k5jat/wwiv | b390e476c75f68e0f4f28c66d4a2eecd74753b7c | [
"Apache-2.0"
] | 34 | 2015-02-04T18:03:14.000Z | 2020-11-10T06:45:28.000Z | deps/cl342/cryptusr.c | k5jat/wwiv | b390e476c75f68e0f4f28c66d4a2eecd74753b7c | [
"Apache-2.0"
] | 5 | 2015-06-30T21:17:00.000Z | 2016-06-14T22:31:51.000Z | deps/cl342/cryptusr.c | k5jat/wwiv | b390e476c75f68e0f4f28c66d4a2eecd74753b7c | [
"Apache-2.0"
] | 15 | 2015-10-29T14:21:58.000Z | 2022-01-19T07:33:14.000Z | /****************************************************************************
* *
* cryptlib User Routines *
* Copyright Peter Gutmann 1999-2007 *
* *
****************************************************************************/
/* cryptlib's role-based access control mechanisms are present only for
forwards-compatibility with future cryptlib versions that will include
role-based access control if there's user demand for it. The following
code implements basic user management routines, but the full role-based
access control functionality isn't present. Some of the code related to
this is therefore present only in template form */
#include <stdio.h> /* For sprintf_s() */
#include "crypt.h"
#ifdef INC_ALL
#include "trustmgr.h"
#include "user.h"
#else
#include "cert/trustmgr.h"
#include "misc/user.h"
#endif /* Compiler-specific includes */
/* Default user info. The default user is a special type that has both
normal user and SO privileges. This is because in its usual usage mode
where cryptlib is functioning as a single-user system the user doesn't
know about the existence of user objects and just wants everything to
work the way that they expect. Because of this the default user has to
be able to perform the full range of available operations, requiring that
they appear as both a normal user and an SO.
For now the default user is marked as an SO user because the kernel checks
don't allow dual-type objects and some operations require that the user be
at least an SO user, once a distinction is made between SOs and users this
will need to be fixed */
static const USER_FILE_INFO FAR_BSS defaultUserInfo = {
#if 0 /* 18/05/02 Disabled since ACL checks are messed up by the existence
of dual-user roles */
CRYPT_USER_NONE, /* Special-case SO+normal user */
#else
CRYPT_USER_SO, /* Special-case SO user */
#endif /* 0 */
USER_STATE_USERINITED, /* Initialised, ready for use */
"Default cryptlib user", 21, /* Pre-set user name */
"<<<<DEFAULT_USER>>>>", "<<<<DEFAULT_USER>>>>",
CRYPT_UNUSED /* No corresponding user file */
};
/****************************************************************************
* *
* Utility Functions *
* *
****************************************************************************/
/* Process user-object-specific messages */
CHECK_RETVAL STDC_NONNULL_ARG( ( 1 ) ) \
static int processUserManagement( INOUT USER_INFO *userInfoPtr,
STDC_UNUSED void *userMgtInfo,
IN_ENUM( MESSAGE_USERMGMT ) \
const MESSAGE_USERMGMT_TYPE userMgtType )
{
assert( isWritePtr( userInfoPtr, sizeof( USER_INFO ) ) );
REQUIRES( userMgtType > MESSAGE_USERMGMT_NONE && \
userMgtType < MESSAGE_USERMGMT_LAST );
switch( userMgtType )
{
case MESSAGE_USERMGMT_ZEROISE:
userInfoPtr->flags |= USER_FLAG_ZEROISE;
return( CRYPT_OK );
}
retIntError();
}
CHECK_RETVAL STDC_NONNULL_ARG( ( 1, 2 ) ) \
static int processTrustManagement( INOUT USER_INFO *userInfoPtr,
INOUT_HANDLE CRYPT_HANDLE *iCertificate,
IN_ENUM( MESSAGE_TRUSTMGMT ) \
const MESSAGE_TRUSTMGMT_TYPE trustMgtType )
{
int status;
assert( isWritePtr( userInfoPtr, sizeof( USER_INFO ) ) );
assert( isWritePtr( iCertificate, sizeof( CRYPT_HANDLE ) ) );
REQUIRES( trustMgtType > MESSAGE_TRUSTMGMT_NONE && \
trustMgtType < MESSAGE_TRUSTMGMT_LAST );
switch( trustMgtType )
{
case MESSAGE_TRUSTMGMT_ADD:
/* Add the cert to the trust info */
status = addTrustEntry( userInfoPtr->trustInfoPtr,
*iCertificate, NULL, 0, TRUE );
if( cryptStatusError( status ) )
return( status );
userInfoPtr->trustInfoChanged = TRUE;
return( setOption( userInfoPtr->configOptions,
userInfoPtr->configOptionsCount,
CRYPT_OPTION_CONFIGCHANGED, TRUE ) );
case MESSAGE_TRUSTMGMT_DELETE:
{
void *entryToDelete;
/* Find the entry to delete and remove it (fides, ut anima, unde
abiit eo nunquam redit - Publius Syrus) */
if( ( entryToDelete = findTrustEntry( userInfoPtr->trustInfoPtr,
*iCertificate, FALSE ) ) == NULL )
return( CRYPT_ERROR_NOTFOUND );
deleteTrustEntry( userInfoPtr->trustInfoPtr, entryToDelete );
userInfoPtr->trustInfoChanged = TRUE;
return( setOption( userInfoPtr->configOptions,
userInfoPtr->configOptionsCount,
CRYPT_OPTION_CONFIGCHANGED, TRUE ) );
}
case MESSAGE_TRUSTMGMT_CHECK:
/* Check whether the cert is present in the trusted certs
collection */
return( ( findTrustEntry( userInfoPtr->trustInfoPtr,
*iCertificate, FALSE ) != NULL ) ? \
CRYPT_OK : CRYPT_ERROR_INVALID );
case MESSAGE_TRUSTMGMT_GETISSUER:
{
void *trustedIssuerInfo;
int trustedCert;
/* Get the trusted issuer of this certificate */
trustedIssuerInfo = findTrustEntry( userInfoPtr->trustInfoPtr,
*iCertificate, TRUE );
if( trustedIssuerInfo == NULL )
return( CRYPT_ERROR_NOTFOUND );
/* Get the issuer cert and return it to the caller */
trustedCert = getTrustedCert( trustedIssuerInfo );
if( cryptStatusError( trustedCert ) )
return( trustedCert );
ENSURES( trustedCert != *iCertificate );
*iCertificate = trustedCert;
return( CRYPT_OK );
}
}
retIntError();
}
/****************************************************************************
* *
* General User Object Functions *
* *
****************************************************************************/
/* Handle a message sent to a user object */
CHECK_RETVAL STDC_NONNULL_ARG( ( 1 ) ) \
static int userMessageFunction( INOUT TYPECAST( USER_INFO * ) \
void *objectInfoPtr,
IN_MESSAGE const MESSAGE_TYPE message,
void *messageDataPtr,
IN_INT_Z const int messageValue )
{
USER_INFO *userInfoPtr = ( USER_INFO * ) objectInfoPtr;
assert( isWritePtr( objectInfoPtr, sizeof( USER_INFO ) ) );
REQUIRES( message > MESSAGE_NONE && message < MESSAGE_LAST );
REQUIRES( messageValue >= 0 && messageValue < MAX_INTLENGTH );
/* Process destroy object messages */
if( message == MESSAGE_DESTROY )
{
/* Clean up any user-related crypto objects if necessary */
if( userInfoPtr->iCryptContext != CRYPT_ERROR )
krnlSendNotifier( userInfoPtr->iCryptContext,
IMESSAGE_DECREFCOUNT );
if( userInfoPtr->iKeyset != CRYPT_ERROR )
krnlSendNotifier( userInfoPtr->iKeyset, IMESSAGE_DECREFCOUNT );
/* If we're doing a zeroise, clear any persistent user data. It's a
bit unclear what to do in case of an error at this point since
we're in the middle of a shutdown anyway. We can't really cancel
the shutdown because the zeroise fails (what do you do if there's
an exception in the exception handler?) so we just have to
continue and ignore the failure */
if( userInfoPtr->flags & USER_FLAG_ZEROISE )
( void ) zeroiseUsers( userInfoPtr );
/* Clean up the trust info and config options */
if( userInfoPtr->trustInfoPtr != NULL )
endTrustInfo( userInfoPtr->trustInfoPtr );
if( userInfoPtr->configOptions != NULL )
endOptions( userInfoPtr->configOptions,
userInfoPtr->configOptionsCount );
if( userInfoPtr->userIndexPtr != NULL )
endUserIndex( userInfoPtr->userIndexPtr );
return( CRYPT_OK );
}
/* If we're doing a zeroise, don't process any further messages except a
destroy */
if( userInfoPtr->flags & USER_FLAG_ZEROISE )
return( CRYPT_ERROR_PERMISSION );
/* Process attribute get/set/delete messages */
if( isAttributeMessage( message ) )
{
REQUIRES( message == MESSAGE_GETATTRIBUTE || \
message == MESSAGE_GETATTRIBUTE_S || \
message == MESSAGE_SETATTRIBUTE || \
message == MESSAGE_SETATTRIBUTE_S || \
message == MESSAGE_DELETEATTRIBUTE );
REQUIRES( isAttribute( messageValue ) || \
isInternalAttribute( messageValue ) );
if( message == MESSAGE_GETATTRIBUTE )
return( getUserAttribute( userInfoPtr,
( int * ) messageDataPtr,
messageValue ) );
if( message == MESSAGE_GETATTRIBUTE_S )
return( getUserAttributeS( userInfoPtr,
( MESSAGE_DATA * ) messageDataPtr,
messageValue ) );
if( message == MESSAGE_SETATTRIBUTE )
{
/* CRYPT_IATTRIBUTE_INITIALISED is purely a notification message
with no parameters so we don't pass it down to the attribute-
handling code */
if( messageValue == CRYPT_IATTRIBUTE_INITIALISED )
{
REQUIRES( userInfoPtr->objectHandle == \
DEFAULTUSER_OBJECT_HANDLE );
return( CRYPT_OK );
}
return( setUserAttribute( userInfoPtr,
*( ( int * ) messageDataPtr ),
messageValue ) );
}
if( message == MESSAGE_SETATTRIBUTE_S )
{
const MESSAGE_DATA *msgData = ( MESSAGE_DATA * ) messageDataPtr;
return( setUserAttributeS( userInfoPtr, msgData->data,
msgData->length, messageValue ) );
}
if( message == MESSAGE_DELETEATTRIBUTE )
return( deleteUserAttribute( userInfoPtr, messageValue ) );
retIntError();
}
/* Process object-specific messages */
if( message == MESSAGE_USER_USERMGMT )
return( processUserManagement( userInfoPtr, messageDataPtr,
messageValue ) );
if( message == MESSAGE_USER_TRUSTMGMT )
return( processTrustManagement( userInfoPtr, messageDataPtr,
messageValue ) );
retIntError();
}
/* Open a user object. This is a low-level function encapsulated by
createUser() and used to manage error exits */
CHECK_RETVAL STDC_NONNULL_ARG( ( 1, 3, 4 ) ) \
static int openUser( OUT_HANDLE_OPT CRYPT_USER *iCryptUser,
IN_HANDLE const CRYPT_USER iCryptOwner,
const USER_FILE_INFO *userInfoTemplate,
OUT_OPT_PTR USER_INFO **userInfoPtrPtr )
{
USER_INFO *userInfoPtr;
USER_FILE_INFO *userFileInfo;
static const MAP_TABLE subtypeMapTbl[] = {
{ CRYPT_USER_SO, SUBTYPE_USER_SO },
{ CRYPT_USER_CA, SUBTYPE_USER_CA },
{ CRYPT_USER_NORMAL, SUBTYPE_USER_NORMAL },
{ CRYPT_ERROR, CRYPT_ERROR }, { CRYPT_ERROR, CRYPT_ERROR }
};
OBJECT_SUBTYPE subType;
int value, status;
assert( isWritePtr( iCryptUser, sizeof( CRYPT_USER * ) ) );
assert( isReadPtr( userInfoTemplate, sizeof( USER_FILE_INFO ) ) );
assert( isWritePtr( userInfoPtrPtr, sizeof( USER_INFO * ) ) );
REQUIRES( ( iCryptOwner == SYSTEM_OBJECT_HANDLE ) || \
( iCryptOwner == DEFAULTUSER_OBJECT_HANDLE ) || \
isHandleRangeValid( iCryptOwner ) );
/* The default user is a special type that has both normal user and SO
privileges. This is because in its usual usage mode where cryptlib
is functioning as a single-user system the user doesn't know about
the existence of user objects and just wants everything to work the
way that they expect. Because of this the default user has to be
able to perform the full range of available operations, requiring
that they appear as both a normal user and an SO */
#if 0 /* 18/05/02 Disabled since ACL checks are messed up by the existence
of dual-user roles */
assert( userInfoTemplate->type == CRYPT_USER_NORMAL || \
userInfoTemplate->type == CRYPT_USER_SO || \
userInfoTemplate->type == CRYPT_USER_CA || \
( userInfoTemplate->type == CRYPT_USER_NONE && \
userInfoTemplate->userNameLength == \
defaultUserInfo.userNameLength && \
!memcmp( userInfoTemplate->userName, defaultUserInfo.userName,
defaultUserInfo.userNameLength ) ) );
#endif /* 0 */
/* Clear return values */
*iCryptUser = CRYPT_ERROR;
*userInfoPtrPtr = NULL;
/* Create the user object */
status = mapValue( userInfoTemplate->type, &value, subtypeMapTbl,
FAILSAFE_ARRAYSIZE( subtypeMapTbl, MAP_TABLE ) );
ENSURES( cryptStatusOK( status ) );
subType = value;
status = krnlCreateObject( iCryptUser, ( void ** ) &userInfoPtr,
sizeof( USER_INFO ), OBJECT_TYPE_USER,
subType, CREATEOBJECT_FLAG_NONE, iCryptOwner,
ACTION_PERM_NONE_ALL, userMessageFunction );
if( cryptStatusError( status ) )
return( status );
ANALYSER_HINT( userInfoPtr != NULL );
*userInfoPtrPtr = userInfoPtr;
userInfoPtr->objectHandle = *iCryptUser;
userFileInfo = &userInfoPtr->userFileInfo;
userFileInfo->type = userInfoTemplate->type;
userFileInfo->state = userInfoTemplate->state;
userFileInfo->fileRef = userInfoTemplate->fileRef;
memcpy( userFileInfo->userName, userInfoTemplate->userName,
userInfoTemplate->userNameLength );
userFileInfo->userNameLength = userInfoTemplate->userNameLength;
memcpy( userFileInfo->userID, userInfoTemplate->userID, KEYID_SIZE );
memcpy( userFileInfo->creatorID, userInfoTemplate->creatorID, KEYID_SIZE );
/* Set up any internal objects to contain invalid handles */
userInfoPtr->iKeyset = userInfoPtr->iCryptContext = CRYPT_ERROR;
/* Initialise the config options and trust info */
status = initTrustInfo( &userInfoPtr->trustInfoPtr );
if( cryptStatusOK( status ) )
status = initOptions( &userInfoPtr->configOptions,
&userInfoPtr->configOptionsCount );
return( status );
}
CHECK_RETVAL STDC_NONNULL_ARG( ( 1 ) ) \
int createUser( INOUT MESSAGE_CREATEOBJECT_INFO *createInfo,
STDC_UNUSED const void *auxDataPtr,
STDC_UNUSED const int auxValue )
{
CRYPT_USER iCryptUser;
USER_INFO *userInfoPtr;
char userFileName[ 16 + 8 ];
int fileRef, initStatus, status;
assert( isWritePtr( createInfo, sizeof( MESSAGE_CREATEOBJECT_INFO ) ) );
REQUIRES( auxDataPtr == NULL && auxValue == 0 );
REQUIRES( createInfo->strArgLen1 >= MIN_NAME_LENGTH && \
createInfo->strArgLen1 <= CRYPT_MAX_TEXTSIZE );
REQUIRES( createInfo->strArgLen2 >= MIN_NAME_LENGTH && \
createInfo->strArgLen2 <= CRYPT_MAX_TEXTSIZE );
/* We can't create another user object with the same name as the
cryptlib default user (actually we could and nothing bad would happen,
but we reserve the use of this name just in case) */
if( createInfo->strArgLen1 == defaultUserInfo.userNameLength && \
!strCompare( createInfo->strArg1, defaultUserInfo.userName,
defaultUserInfo.userNameLength ) )
return( CRYPT_ERROR_INITED );
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
/* Problem: Access to any user info is via the root user object, however */
/* we don't have access to it at this point. Pass it in as auxDataPtr? */
/* Need to differentiate cryptCreateUser() vs. cryptLogin(), login uses */
/* the default user object as its target? This is complex, we really */
/* need to target the message at the default user to get access to the user */
/* info index, but then it won't go through cryptdev's create-object- */
/* handling any more */
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
#if 0
/* Find the user information for the given user */
status = fileRef = findUserIndexEntry( USERID_NAME, createInfo->strArg1,
createInfo->strArgLen1 );
if( cryptStatusError( status ) )
{
/* If we get a special-case OK status, we're in the zeroised state
with no user info present, make sure that the user is logging in
with the default SO password */
if( status == OK_SPECIAL )
status = ( isZeroisePassword( createInfo->strArg2, \
createInfo->strArgLen2 ) ) ? \
CRYPT_OK : CRYPT_ERROR_WRONGKEY;
if( cryptStatusError( status ) )
return( status );
fileRef = -1; /* No user file present yet for primary SO */
/* We're logging in as the primary SO with the SO default password,
create the primary SO user object */
assert( isZeroisePassword( createInfo->strArg2, \
createInfo->strArgLen2 ) );
initStatus = openUser( &iCryptUser, createInfo->cryptOwner,
getPrimarySoUserInfo(), &userInfoPtr );
}
else
{
USER_FILE_INFO userFileInfo;
/* We're in the non-zeroised state, no user can use the default SO
password */
if( isZeroisePassword( createInfo->strArg2, createInfo->strArgLen2 ) )
return( CRYPT_ERROR_WRONGKEY );
/* Read the user info from the user file and perform access
verification */
status = getCheckUserInfo( &userFileInfo, fileRef );
if( cryptStatusError( status ) )
return( status );
/* Pass the call on to the lower-level open function */
assert( createInfo->strArgLen1 == userFileInfo.userNameLength && \
!memcmp( createInfo->strArg1, userFileInfo.userName,
userFileInfo.userNameLength ) );
initStatus = openUser( &iCryptUser, createInfo->cryptOwner,
&userFileInfo, &userInfoPtr );
zeroise( &userFileInfo, sizeof( USER_FILE_INFO ) );
}
#endif
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
{ /* Get rid of compiler warnings */
userInfoPtr = NULL;
initStatus = CRYPT_ERROR_FAILED;
iCryptUser = CRYPT_UNUSED;
fileRef = 0;
}
if( cryptStatusError( initStatus ) )
{
/* If the create object failed, return immediately */
if( userInfoPtr == NULL )
return( initStatus );
/* The init failed, make sure that the object gets destroyed when we
notify the kernel that the setup process is complete */
krnlSendNotifier( iCryptUser, IMESSAGE_DESTROY );
}
/* We've finished setting up the object-type-specific info, tell the
kernel that the object is ready for use */
status = krnlSendMessage( iCryptUser, IMESSAGE_SETATTRIBUTE,
MESSAGE_VALUE_OK, CRYPT_IATTRIBUTE_STATUS );
if( cryptStatusError( initStatus ) || cryptStatusError( status ) )
return( cryptStatusError( initStatus ) ? initStatus : status );
/* If the user object has a corresponding user info file, read any
stored config options into the object. We have to do this after
it's initialised because the config data, coming from an external
(and therefore untrusted) source has to go through the kernel's
ACL checking */
if( fileRef >= 0 )
{
sprintf_s( userFileName, 16, "u%06x", fileRef );
status = readConfig( iCryptUser, userFileName,
userInfoPtr->trustInfoPtr );
if( cryptStatusError( status ) )
{
/* The config data read failed, we can't create the user
object that uses it */
krnlSendNotifier( iCryptUser, IMESSAGE_DESTROY );
return( status );
}
}
createInfo->cryptHandle = iCryptUser;
return( CRYPT_OK );
}
/* Create the default user object */
CHECK_RETVAL \
static int createDefaultUserObject( void )
{
CRYPT_USER iUserObject;
USER_INFO *userInfoPtr;
int initStatus, status;
/* Pass the call on to the lower-level open function. This user is
unique and has no owner or type.
Normally if an object init fails we tell the kernel to destroy it by
sending it a destroy message, which is processed after the object's
status has been set to normal. However we don't have the privileges
to do this for the default user object (or the system object) so we
just pass the error code back to the caller, which causes the
cryptlib init to fail.
In addition the init can fail in one of two ways, either the object
isn't even created (deviceInfoPtr == NULL, nothing to clean up), in
which case we bail out immediately, or the object is created but wasn't
set up properly (deviceInfoPtr is allocated, but the object can't be
used) in which case we bail out after we update its status */
initStatus = openUser( &iUserObject, SYSTEM_OBJECT_HANDLE, &defaultUserInfo,
&userInfoPtr );
if( cryptStatusError( initStatus ) )
{
/* If the create object failed, return immediately */
if( userInfoPtr == NULL )
return( initStatus );
}
ENSURES( iUserObject == DEFAULTUSER_OBJECT_HANDLE );
if( cryptStatusOK( initStatus ) )
{
/* Read the user index. We make this part of the object init because
it's used for access control, unlike the config option read where
we can fall back to defaults if there's a problem this one is
critical enough that we abort the cryptlib init if it fails */
initStatus = initUserIndex( &userInfoPtr->userIndexPtr );
}
/* We've finished setting up the object-type-specific info, tell the
kernel that the object is ready for use */
status = krnlSendMessage( iUserObject, IMESSAGE_SETATTRIBUTE,
MESSAGE_VALUE_OK, CRYPT_IATTRIBUTE_STATUS );
if( cryptStatusError( initStatus ) || cryptStatusError( status ) )
return( cryptStatusError( initStatus ) ? initStatus : status );
/* Read any stored config options into the object. We have to do this
after it's initialised because the config data, coming from an
external (and therefore untrusted) source has to go through the
kernel's ACL checking.
What to do in case of an error reading the config file is a bit
problematic, we don't want to cause whatever application is using
cryptlib to abort mysteriously just because a bit in some config file
that most people don't even know exists got flipped, so we treat the
read as an opportunistic read and fall back to built-in safe defaults
if there's a problem, warning the user in debug mode */
status = readConfig( iUserObject, "cryptlib", userInfoPtr->trustInfoPtr );
if( cryptStatusError( status ) )
{
DEBUG_DIAG(( "Couldn't read config data, using default config" ));
assert( DEBUG_WARN );
DEBUG_PRINT(( "Configuration file read failed with status %d.\n",
status ));
}
/* The object has been initialised, move it into the initialised state */
return( krnlSendMessage( iUserObject, IMESSAGE_SETATTRIBUTE,
MESSAGE_VALUE_UNUSED,
CRYPT_IATTRIBUTE_INITIALISED ) );
}
/* Generic management function for this class of object */
CHECK_RETVAL \
int userManagementFunction( IN_ENUM( MANAGEMENT_ACTION ) \
const MANAGEMENT_ACTION_TYPE action )
{
int status;
REQUIRES( action == MANAGEMENT_ACTION_INIT );
switch( action )
{
case MANAGEMENT_ACTION_INIT:
status = createDefaultUserObject();
if( cryptStatusError( status ) )
{
DEBUG_DIAG(( "User object creation failed" ));
}
return( status );
}
retIntError();
}
| 37.694539 | 78 | 0.681018 | [
"object"
] |
341f4e9782b603f48216a403a784d43950f4b350 | 1,020 | h | C | Userland/Libraries/LibJS/Runtime/GeneratorObject.h | temidosu/serenity | 2ae218302d61b76e82d8083157329342e7afa8c4 | [
"BSD-2-Clause"
] | 650 | 2019-03-01T13:33:03.000Z | 2022-03-15T09:26:44.000Z | Userland/Libraries/LibJS/Runtime/GeneratorObject.h | sw1tchbl4d3r/serenity | 3c5e07fa1c0c068decc35c5d95795f8392204c93 | [
"BSD-2-Clause"
] | 51 | 2019-04-03T08:32:38.000Z | 2019-05-19T13:44:28.000Z | Userland/Libraries/LibJS/Runtime/GeneratorObject.h | sw1tchbl4d3r/serenity | 3c5e07fa1c0c068decc35c5d95795f8392204c93 | [
"BSD-2-Clause"
] | 33 | 2019-03-26T05:47:59.000Z | 2021-11-22T18:18:45.000Z | /*
* Copyright (c) 2021, Ali Mohammad Pur <mpfard@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <LibJS/Bytecode/Interpreter.h>
#include <LibJS/Runtime/ECMAScriptFunctionObject.h>
#include <LibJS/Runtime/Object.h>
namespace JS {
class GeneratorObject final : public Object {
JS_OBJECT(GeneratorObject, Object);
public:
static GeneratorObject* create(GlobalObject&, Value, ECMAScriptFunctionObject*, Environment*, Bytecode::RegisterWindow);
GeneratorObject(GlobalObject&, Object& prototype);
virtual void initialize(GlobalObject&) override;
virtual ~GeneratorObject() override;
void visit_edges(Cell::Visitor&) override;
Value next_impl(VM&, GlobalObject&, Optional<Value> value_to_throw);
void set_done() { m_done = true; }
private:
Environment* m_environment { nullptr };
ECMAScriptFunctionObject* m_generating_function { nullptr };
Value m_previous_value;
Bytecode::RegisterWindow m_frame;
bool m_done { false };
};
}
| 27.567568 | 124 | 0.739216 | [
"object"
] |
3420772363374eaded268947381cfa9d50dc06e0 | 4,556 | h | C | third_party/skia_m63/third_party/externals/angle2/src/libANGLE/RefCountObject.h | kniefliu/WindowsSamples | c841268ef4a0f1c6f89b8e95bf68058ea2548394 | [
"MIT"
] | 2 | 2021-11-18T20:12:08.000Z | 2022-03-13T06:56:10.000Z | third_party/skia_m63/third_party/externals/angle2/src/libANGLE/RefCountObject.h | kniefliu/WindowsSamples | c841268ef4a0f1c6f89b8e95bf68058ea2548394 | [
"MIT"
] | null | null | null | third_party/skia_m63/third_party/externals/angle2/src/libANGLE/RefCountObject.h | kniefliu/WindowsSamples | c841268ef4a0f1c6f89b8e95bf68058ea2548394 | [
"MIT"
] | 2 | 2019-12-11T04:13:15.000Z | 2020-02-15T14:42:13.000Z | //
// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// RefCountObject.h: Defines the gl::RefCountObject base class that provides
// lifecycle support for GL objects using the traditional BindObject scheme, but
// that need to be reference counted for correct cross-context deletion.
// (Concretely, textures, buffers and renderbuffers.)
#ifndef LIBANGLE_REFCOUNTOBJECT_H_
#define LIBANGLE_REFCOUNTOBJECT_H_
#include "angle_gl.h"
#include "common/debug.h"
#include "libANGLE/Error.h"
#include <cstddef>
namespace gl
{
class Context;
class RefCountObjectNoID : angle::NonCopyable
{
public:
RefCountObjectNoID() : mRefCount(0) {}
virtual Error onDestroy(const Context *context) { return NoError(); }
void addRef() const { ++mRefCount; }
void release() const
{
ASSERT(mRefCount > 0);
if (--mRefCount == 0)
{
delete this;
}
}
size_t getRefCount() const { return mRefCount; }
protected:
virtual ~RefCountObjectNoID() { ASSERT(mRefCount == 0); }
// A specialized release method for objects which need a destroy context.
void release(const gl::Context *context)
{
ASSERT(mRefCount > 0);
if (--mRefCount == 0)
{
ANGLE_SWALLOW_ERR(onDestroy(context));
delete this;
}
}
template <class ObjectType>
friend class BindingPointer;
mutable std::size_t mRefCount;
};
template <class ObjectType>
class BindingPointer;
class RefCountObject : RefCountObjectNoID
{
public:
explicit RefCountObject(GLuint id) : mId(id) {}
GLuint id() const { return mId; }
using RefCountObjectNoID::release;
using RefCountObjectNoID::addRef;
using RefCountObjectNoID::getRefCount;
protected:
~RefCountObject() override {}
private:
GLuint mId;
};
template <class ObjectType>
class BindingPointer
{
public:
BindingPointer()
: mObject(nullptr)
{
}
BindingPointer(ObjectType *object) : mObject(object) { mObject->addRef(); }
BindingPointer(const BindingPointer<ObjectType> &other) : mObject(other.mObject)
{
mObject->addRef();
}
BindingPointer &operator=(BindingPointer<ObjectType> &&other)
{
std::swap(mObject, other.mObject);
return *this;
}
virtual ~BindingPointer()
{
// Objects have to be released before the resource manager is destroyed, so they must be explicitly cleaned up.
ASSERT(mObject == nullptr);
}
virtual void set(const Context *context, ObjectType *newObject)
{
// addRef first in case newObject == mObject and this is the last reference to it.
if (newObject != nullptr) reinterpret_cast<const RefCountObjectNoID*>(newObject)->addRef();
if (mObject != nullptr)
reinterpret_cast<RefCountObjectNoID *>(mObject)->release(context);
mObject = newObject;
}
ObjectType *get() const { return mObject; }
ObjectType *operator->() const { return mObject; }
GLuint id() const { return (mObject != nullptr) ? mObject->id() : 0; }
bool operator==(const BindingPointer<ObjectType> &other) const
{
return mObject == other.mObject;
}
bool operator!=(const BindingPointer<ObjectType> &other) const { return !(*this == other); }
private:
ObjectType *mObject;
};
template <class ObjectType>
class OffsetBindingPointer : public BindingPointer<ObjectType>
{
public:
OffsetBindingPointer() : mOffset(0), mSize(0) { }
void set(const Context *context, ObjectType *newObject) override
{
BindingPointer<ObjectType>::set(context, newObject);
mOffset = 0;
mSize = 0;
}
void set(const Context *context, ObjectType *newObject, GLintptr offset, GLsizeiptr size)
{
BindingPointer<ObjectType>::set(context, newObject);
mOffset = offset;
mSize = size;
}
GLintptr getOffset() const { return mOffset; }
GLsizeiptr getSize() const { return mSize; }
bool operator==(const OffsetBindingPointer<ObjectType> &other) const
{
return this->get() == other.get() && mOffset == other.mOffset && mSize == other.mSize;
}
bool operator!=(const OffsetBindingPointer<ObjectType> &other) const
{
return !(*this == other);
}
private:
GLintptr mOffset;
GLsizeiptr mSize;
};
} // namespace gl
#endif // LIBANGLE_REFCOUNTOBJECT_H_
| 25.595506 | 119 | 0.658692 | [
"object"
] |
3426fe06ac7ffa5b6f3cc7b83abcea4d186951fb | 1,595 | h | C | MUON/MUONgraphics/AliMUONManuContourMaker.h | AllaMaevskaya/AliRoot | c53712645bf1c7d5f565b0d3228e3a6b9b09011a | [
"BSD-3-Clause"
] | 52 | 2016-12-11T13:04:01.000Z | 2022-03-11T11:49:35.000Z | MUON/MUONgraphics/AliMUONManuContourMaker.h | AllaMaevskaya/AliRoot | c53712645bf1c7d5f565b0d3228e3a6b9b09011a | [
"BSD-3-Clause"
] | 1,388 | 2016-11-01T10:27:36.000Z | 2022-03-30T15:26:09.000Z | MUON/MUONgraphics/AliMUONManuContourMaker.h | AllaMaevskaya/AliRoot | c53712645bf1c7d5f565b0d3228e3a6b9b09011a | [
"BSD-3-Clause"
] | 275 | 2016-06-21T20:24:05.000Z | 2022-03-31T13:06:19.000Z | #ifndef ALIMUONMANUCONTOURMAKER_H
#define ALIMUONMANUCONTOURMAKER_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
// $Id$
/// \ingroup geometry
/// \class AliMUONManuContourMaker
/// \brief Maker of AliMUONContour objects for all the tracker manus
///
// Author Laurent Aphecetche, Subatech
#ifndef ROOT_TObject
# include "TObject.h"
#endif
#ifndef ROOT_TMap
# include "TMap.h"
#endif
class AliMpExMap;
class AliMpMotifPosition;
class AliMUONContour;
class AliMUONManuContourMaker : public TObject
{
public:
AliMUONManuContourMaker(AliMpExMap* deTransformations);
virtual ~AliMUONManuContourMaker();
AliMUONContour* CreateManuContour(Int_t detElemId, Int_t manuId, const char* name="") const;
AliMUONContour* CreateMotifContour(const AliMpMotifPosition& motifPosition) const;
TObjArray* GenerateManuContours(Bool_t stopAtError=kFALSE);
static TString ManuPathName(Int_t detElemId, Int_t manu, Bool_t withCathodeName=kTRUE);
private:
/// not implemented
AliMUONManuContourMaker(const AliMUONManuContourMaker& rhs);
/// not implemented
AliMUONManuContourMaker& operator=(const AliMUONManuContourMaker& rhs);
TString NameIt(const AliMpMotifPosition& motifPosition) const;
private:
AliMpExMap* fDETransformations; ///< map<int,TGeoHMatrix> of detElemId to matrix
mutable TMap fLocalManuContours; ///< map of local manu contours
ClassDef(AliMUONManuContourMaker,1) // Maker of AliMUONContour objects for all the tracker manus
};
#endif
| 27.982456 | 98 | 0.766144 | [
"geometry"
] |
3427ad2c2097592206a02da9ca591ee9db1c4989 | 4,897 | h | C | include/cetty/channel/ChannelOption.h | frankee/cetty2 | 62ac0cd1438275097e47a9ba471e72efd2746ded | [
"BSL-1.0",
"Apache-2.0",
"BSD-3-Clause"
] | 26 | 2015-11-08T10:58:21.000Z | 2021-02-25T08:27:26.000Z | include/cetty/channel/ChannelOption.h | frankee/cetty2 | 62ac0cd1438275097e47a9ba471e72efd2746ded | [
"BSL-1.0",
"Apache-2.0",
"BSD-3-Clause"
] | 1 | 2019-02-18T08:46:17.000Z | 2019-02-18T08:46:17.000Z | include/cetty/channel/ChannelOption.h | frankee/cetty2 | 62ac0cd1438275097e47a9ba471e72efd2746ded | [
"BSL-1.0",
"Apache-2.0",
"BSD-3-Clause"
] | 8 | 2016-02-27T02:37:10.000Z | 2021-09-29T05:25:00.000Z | #if !defined(CETTY_CHANNEL_CHANNELOPTION_H)
#define CETTY_CHANNEL_CHANNELOPTION_H
/*
* Copyright 2012 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
/*
* Copyright (c) 2010-2012 frankee zhou (frankee.zhou at gmail dot com)
*
* Distributed under under the Apache License, version 2.0 (the "License").
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
#include <map>
#include <string>
#include <vector>
#include <boost/variant.hpp>
#include <cetty/util/Enum.h>
namespace cetty {
namespace channel {
template<typename T>
class ValueChecker : public boost::static_visitor<bool> {
public:
bool operator()(const T& value) const {
return true;
}
template<typename U>
bool operator()(const U& value) const {
return false;
}
};
class ChannelOption : public cetty::util::Enum<ChannelOption> {
public:
class Null {
public:
Null() {}
};
typedef boost::variant<Null, int, bool, std::string, std::vector<int> > Variant;
typedef std::map<ChannelOption, Variant> Options;
public:
/**
*
*/
static const Variant EMPTY_VALUE;
public:
static const ChannelOption CO_CONNECT_TIMEOUT_MILLIS;
static const ChannelOption CO_REUSE_CHILD;
static const ChannelOption CO_RESERVED_CHILD_COUNT;
static const ChannelOption CO_AUTO_READ;
static const ChannelOption CO_SO_BROADCAST;
static const ChannelOption CO_SO_KEEPALIVE;
static const ChannelOption CO_SO_SNDBUF;
static const ChannelOption CO_SO_RCVBUF;
static const ChannelOption CO_SO_REUSEADDR;
static const ChannelOption CO_SO_LINGER;
static const ChannelOption CO_SO_BACKLOG;
static const ChannelOption CO_SO_SNDLOWAT;
static const ChannelOption CO_SO_RCVLOWAT;
static const ChannelOption CO_SNDHIGHWAT;
static const ChannelOption CO_RCVHIGHWAT;
static const ChannelOption CO_IP_TOS;
static const ChannelOption CO_IP_MULTICAST_ADDR;
static const ChannelOption CO_IP_MULTICAST_IF;
static const ChannelOption CO_IP_MULTICAST_TTL;
static const ChannelOption CO_IP_MULTICAST_LOOP_DISABLED;
static const ChannelOption CO_UDP_RECEIVE_PACKET_SIZE;
static const ChannelOption CO_TCP_NODELAY;
static const ChannelOption CO_SCTP_DISABLE_FRAGMENTS;
static const ChannelOption CO_SCTP_EXPLICIT_COMPLETE;
static const ChannelOption CO_SCTP_FRAGMENT_INTERLEAVE;
static const ChannelOption CO_SCTP_INIT_MAXSTREAMS;
static const ChannelOption CO_SCTP_NODELAY;
static const ChannelOption CO_SCTP_PRIMARY_ADDR;
static const ChannelOption CO_SCTP_SET_PEER_PRIMARY_ADDR;
static const ValueChecker<int> INT_VALUE_CHECKER;
static const ValueChecker<bool> BOOL_VALUE_CHECKER;
static const ValueChecker<std::string> STRING_VALUE_CHECKER;
static const ValueChecker<std::vector<int> > INT_VECTOR_VALUE_CHECKER;
public:
ChannelOption(const ChannelOption& option);
ChannelOption& operator=(const ChannelOption& option);
bool validate(const Variant& value) const;
/**
* test the {@link ChannelOption::Variant} is empty.
*/
static bool empty(const ChannelOption::Variant& option);
private:
ChannelOption(int id,
const char* name,
const boost::static_visitor<bool>* checker);
private:
const boost::static_visitor<bool>* checker_;
};
inline
ChannelOption& ChannelOption::operator=(const ChannelOption& option) {
cetty::util::Enum<ChannelOption>::operator=(option);
checker_ = option.checker_;
return *this;
}
inline
ChannelOption::ChannelOption(const ChannelOption& option)
: cetty::util::Enum<ChannelOption>(option),
checker_(option.checker_) {
}
inline
bool ChannelOption::empty(const ChannelOption::Variant& option) {
return option.which() == 0;
}
}
}
#endif //#if !defined(CETTY_CHANNEL_CHANNELOPTION_H)
// Local Variables:
// mode: c++
// End:
| 30.60625 | 84 | 0.742087 | [
"vector"
] |
342ae59e2a0ef3a70151e0fd59747e12bafd906e | 7,276 | h | C | perception_oru-port-kinetic/ndt_generic/include/ndt_generic/io.h | lllray/ndt-loam | 331867941e0764b40e1a980dd85d2174f861e9c8 | [
"BSD-3-Clause"
] | 1 | 2020-11-14T08:21:13.000Z | 2020-11-14T08:21:13.000Z | perception_oru-port-kinetic/ndt_generic/include/ndt_generic/io.h | lllray/ndt-loam | 331867941e0764b40e1a980dd85d2174f861e9c8 | [
"BSD-3-Clause"
] | 1 | 2021-07-28T04:47:56.000Z | 2021-07-28T04:47:56.000Z | perception_oru-port-kinetic/ndt_generic/include/ndt_generic/io.h | lllray/ndt-loam | 331867941e0764b40e1a980dd85d2174f861e9c8 | [
"BSD-3-Clause"
] | 2 | 2020-12-18T11:25:53.000Z | 2022-02-19T12:59:59.000Z | #pragma once
#include <vector>
#include <Eigen/Core>
#include <Eigen/Geometry>
#include <Eigen/Eigenvalues>
#include <angles/angles.h>
#include <iomanip>
#include <iostream>
#include <ndt_generic/utils.h>
#include <pcl/io/pcd_io.h>
#include "ros/time.h"
#include "ros/ros.h"
#include "string.h"
#include <boost/filesystem.hpp>
namespace ndt_generic {
// Provides a vector of files (or if the provided path string is a file then add it into the vector).
// ext - extension, should contain the dot (.), e.g. ".doc".
void extract_file_names(const std::string& path, const std::string &ext, std::vector<std::string> &files)
{
// If we have a file instead, just add it.
if (boost::filesystem::is_regular_file(path)) {
files.push_back(path);
return;
}
boost::filesystem::path _path(path);
boost::filesystem::recursive_directory_iterator end;
for (boost::filesystem::recursive_directory_iterator i(_path); i != end; ++i)
{
const boost::filesystem::path cp = (*i);
if (!ext.empty() && cp.extension() != ext)
continue;
std::string file_name = cp.string();
if (!file_name.empty()) {
files.push_back(file_name);
}
}
std::sort(files.begin(), files.end());
}
// Load the evaluation files that are generated by the fuser, <timestamp> x y x qx qy qz qw.
std::vector<Eigen::Affine3d> loadAffineFromEvalFile(const std::string &fileName) {
std::vector<Eigen::Affine3d> ret;
std::string line;
std::ifstream myfile (fileName.c_str());
if (myfile.is_open())
{
while ( getline (myfile,line) )
{
double time, x, y, z, qx, qy, qz, qw;
std::istringstream ss(line);
ss >> time >> x >> y >> z >> qx >> qy >> qz >> qw;
ret.push_back(Eigen::Translation3d(x,y,z)*Eigen::Quaterniond(qw, qx, qy, qz));
}
myfile.close();
}
else {
std::cout << "Unable to open file : " << fileName << std::endl;
}
return ret;
}
// Load timestamps from the evaluation files that are generated by the fuser...
std::vector<double> loadTimeStampFromEvalFile(const std::string &fileName) {
std::vector<double> ret;
std::string line;
std::ifstream myfile (fileName.c_str());
if (myfile.is_open())
{
while ( getline (myfile,line) )
{
double time, x, y, z, qx, qy, qz, qw;
std::istringstream ss(line);
ss >> time >> x >> y >> z >> qx >> qy >> qz >> qw;
ret.push_back(time);
}
myfile.close();
}
else std::cout << "Unable to open file : " << fileName << std::endl;;
return ret;
}
// Useful to load a set of files
void loadCloud(const std::string &base_name_pcd, int counter, pcl::PointCloud<pcl::PointXYZ> &cloud) {
std::string pcd_file = base_name_pcd + std::string("cloud") + ndt_generic::toString(counter) + std::string(".pcd");
std::cout << "loading : " << pcd_file << std::endl;
pcl::io::loadPCDFile<pcl::PointXYZ>(pcd_file, cloud);
}
void saveAffine3dRPY(const std::string &filename, const Eigen::Affine3d &T) {
std::ofstream ofs;
ofs.open(filename.c_str());
if (!ofs.is_open())
return;
ofs << ndt_generic::affine3dToStringRPY(T) << std::endl;
ofs.close();
}
// Save the evaluation files that are generated by the fuser, <timestamp> x y x qx qy qz qw.
// Timesamps are set to the index.
void saveAffineToEvalFile(const std::string &filename, const std::vector<Eigen::Affine3d> &Ts) {
std::ofstream ofs;
ofs.open(filename.c_str());
if (!ofs.is_open())
return;
for (int i = 0; i < Ts.size(); i++) {
ofs << i << " " << ndt_generic::transformToEvalString(Ts[i]);
}
ofs.close();
}
std::vector<double> loadDoubleVecTextFile(const std::string &fileName) {
std::vector<double> vec;
std::ifstream ifs;
ifs.open(fileName.c_str());
if (!ifs.is_open()) {
std::cerr << __FILE__ << ":" << __LINE__ << " cannot open file : " << fileName << std::endl;
}
while (!ifs.eof())
{
std::string line;
getline(ifs, line);
double val;
if (sscanf(line.c_str(), "%lf",
&val) == 1)
{
vec.push_back(val);
}
}
return vec;
}
void saveDoubleVecTextFile(const std::vector<double> &vec, const std::string &fileName)
{
std::stringstream st;
st << fileName;
std::string file_name = st.str();
std::ofstream ofs(file_name.c_str());
for (unsigned int i = 0; i < vec.size(); i++)
{
ofs << vec[i] << std::endl;
}
ofs.close();
}
std::string removeExtension(const std::string& filename) {
size_t lastdot = filename.find_last_of(".");
if (lastdot == std::string::npos) return filename;
return filename.substr(0, lastdot);
}
class CreateEvalFiles{
public:
CreateEvalFiles(const std::string &output_dir_name, const std::string &base_name, bool enable=true){
output_dir_name_=output_dir_name;
if(output_dir_name_.length()>0 &&output_dir_name_[output_dir_name_.length()-1]!='/')//if doesnt end with '/' add '/'
output_dir_name_+='/';
base_name_=base_name;
enable_=enable;
if(enable_){
std::cout<<"output directory:"<<output_dir_name_<<std::endl;
std::cout<<"base_name:"<<base_name<<std::endl;
CreateOutputFiles();
}
else
std::cout<<"Evaluation output disabled"<<std::endl;
}
void Write(const ros::Time frame_time ,const Eigen::Affine3d &Tgtbase,const Eigen::Affine3d &Todombase,const Eigen::Affine3d &Tfuserpose,const Eigen::Affine3d &sensoroffset){
if(!enable_)
return;
gt_file << frame_time << " " << transformToEvalString(Tgtbase);
odom_file << frame_time << " " << transformToEvalString(Todombase);
est_file << frame_time << " " << transformToEvalString(Tfuserpose);
sensorpose_est_file << frame_time << " " << transformToEvalString(Tfuserpose * sensoroffset);
gt_file.flush();
odom_file.flush();
est_file.flush();
sensorpose_est_file.flush();
}
void Close(){
if(!enable_)
return;
gt_file.close();
odom_file.close();
est_file.close();
sensorpose_est_file.close();
}
private:
void CreateOutputFiles(){
if(!enable_)
return;
std::cout<<"create output files"<<std:: endl;
std::string filename;
{
filename =output_dir_name_ + base_name_ + std::string("_gt.txt");
gt_file.open(filename.c_str());
}
{
filename =output_dir_name_ + base_name_ + std::string("_est.txt");
est_file.open(filename.c_str());
}
{
filename = output_dir_name_ + base_name_ + std::string("_sensorpose_est.txt");
sensorpose_est_file.open(filename.c_str());
}
{
filename = output_dir_name_ + base_name_ + std::string("_odom.txt");
odom_file.open(filename.c_str());
}
if (!gt_file.is_open() || !est_file.is_open() || !odom_file.is_open())
{
std::cout<<"Error creating evaluation output files at path:"<<std::endl;
std::cout<<filename<<std::endl;
exit(0);
}
else{
std::cout<<"Created output evaluation files at path: "<<output_dir_name_+base_name_<<std::endl;
return;
}
}
bool enable_;
std::string output_dir_name_,base_name_;
std::ofstream gt_file, odom_file, est_file, sensorpose_est_file; //output files
};
} // namespace
| 29.104 | 177 | 0.629879 | [
"geometry",
"vector"
] |
342e6d932f89ced12b55c0ce34b9dd01d98e06c2 | 4,610 | h | C | chrome/common/file_descriptor_set_posix.h | zachlatta/chromium | c4625eefca763df86471d798ee5a4a054b4716ae | [
"BSD-3-Clause"
] | 1 | 2021-09-24T22:49:10.000Z | 2021-09-24T22:49:10.000Z | chrome/common/file_descriptor_set_posix.h | changbai1980/chromium | c4625eefca763df86471d798ee5a4a054b4716ae | [
"BSD-3-Clause"
] | null | null | null | chrome/common/file_descriptor_set_posix.h | changbai1980/chromium | c4625eefca763df86471d798ee5a4a054b4716ae | [
"BSD-3-Clause"
] | null | null | null | // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_COMMON_FILE_DESCRIPTOR_SET_POSIX_H_
#define CHROME_COMMON_FILE_DESCRIPTOR_SET_POSIX_H_
#include <vector>
#include "base/basictypes.h"
#include "base/file_descriptor_posix.h"
#include "base/ref_counted.h"
// -----------------------------------------------------------------------------
// A FileDescriptorSet is an ordered set of POSIX file descriptors. These are
// associated with IPC messages so that descriptors can be transmitted over a
// UNIX domain socket.
// -----------------------------------------------------------------------------
class FileDescriptorSet : public base::RefCountedThreadSafe<FileDescriptorSet> {
public:
FileDescriptorSet();
~FileDescriptorSet();
// This is the maximum number of descriptors per message. We need to know this
// because the control message kernel interface has to be given a buffer which
// is large enough to store all the descriptor numbers. Otherwise the kernel
// tells us that it truncated the control data and the extra descriptors are
// lost.
//
// In debugging mode, it's a fatal error to try and add more than this number
// of descriptors to a FileDescriptorSet.
enum {
MAX_DESCRIPTORS_PER_MESSAGE = 4,
};
// ---------------------------------------------------------------------------
// Interfaces for building during message serialisation...
// Add a descriptor to the end of the set. Returns false iff the set is full.
bool Add(int fd);
// Add a descriptor to the end of the set and automatically close it after
// transmission. Returns false iff the set is full.
bool AddAndAutoClose(int fd);
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// Interfaces for accessing during message deserialisation...
// Return the number of descriptors
unsigned size() const { return descriptors_.size(); }
// Return true if no unconsumed descriptors remain
bool empty() const { return descriptors_.empty(); }
// Fetch the nth descriptor from the beginning of the set. Code using this
// /must/ access the descriptors in order, except that it may wrap from the
// end to index 0 again.
//
// This interface is designed for the deserialising code as it doesn't
// support close flags.
// returns: file descriptor, or -1 on error
int GetDescriptorAt(unsigned n) const;
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// Interfaces for transmission...
// Fill an array with file descriptors without 'consuming' them. CommitAll
// must be called after these descriptors have been transmitted.
// buffer: (output) a buffer of, at least, size() integers.
void GetDescriptors(int* buffer) const;
// This must be called after transmitting the descriptors returned by
// GetDescriptors. It marks all the descriptors as consumed and closes those
// which are auto-close.
void CommitAll();
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// Interfaces for receiving...
// Set the contents of the set from the given buffer. This set must be empty
// before calling. The auto-close flag is set on all the descriptors so that
// unconsumed descriptors are closed on destruction.
void SetDescriptors(const int* buffer, unsigned count);
// ---------------------------------------------------------------------------
private:
// A vector of descriptors and close flags. If this message is sent, then
// these descriptors are sent as control data. After sending, any descriptors
// with a true flag are closed. If this message has been received, then these
// are the descriptors which were received and all close flags are true.
std::vector<base::FileDescriptor> descriptors_;
// This contains the index of the next descriptor which should be consumed.
// It's used in a couple of ways. Firstly, at destruction we can check that
// all the descriptors have been read (with GetNthDescriptor). Secondly, we
// can check that they are read in order.
mutable unsigned consumed_descriptor_highwater_;
DISALLOW_COPY_AND_ASSIGN(FileDescriptorSet);
};
#endif // CHROME_COMMON_FILE_DESCRIPTOR_SET_POSIX_H_
| 42.293578 | 80 | 0.616269 | [
"vector"
] |
3434c9cd7abdfeb934a3b4e7309863acd331b884 | 6,304 | h | C | Classes/NSArray+ObjectiveSugar.h | carmelosui/ObjectiveSugarWithPrefix | 733f9f62882f36c47367287422bf8fcfdce4551e | [
"MIT"
] | null | null | null | Classes/NSArray+ObjectiveSugar.h | carmelosui/ObjectiveSugarWithPrefix | 733f9f62882f36c47367287422bf8fcfdce4551e | [
"MIT"
] | null | null | null | Classes/NSArray+ObjectiveSugar.h | carmelosui/ObjectiveSugarWithPrefix | 733f9f62882f36c47367287422bf8fcfdce4551e | [
"MIT"
] | null | null | null | //
// NSArray+ObjectiveSugar.h
// Objective Sugar
//
// Created by Marin Usalj on 5/7/12.
// Copyright (c) 2012 __MyCompanyName__. All rights reserved.
//
// For an overview see http://cocoadocs.org/docsets/ObjectiveSugar/
#import <Foundation/Foundation.h>
@interface NSArray (ObjectiveSugar)
/**
A random element in the array, or nil.
@return A random element in the array, or nil.
*/
- (id)ojs_sample;
/// Alias for -sample
- (id)ojs_anyObject;
/**
Allow subscripting to fetch elements within the specified range
@param An NSString or NSValue wrapping an NSRange. It's intended to behave like Ruby's array range accessors.
Given array of 10 elements, e.g. [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], you can perform these operations:
array[@"1..3"] will give you [2, 3, 4]
array[@"1...3"] will give you [2, 3] (last value excluded)
array[@"1,3"] implies NSRange(location: 1, length: 3), and gives you [2, 3, 4]
@return An array with elements within the specified range
*/
- (id)objectForKeyedSubscript:(id <NSCopying>)key;
/**
A simpler alias for `enumerateObjectsUsingBlock`
@param A block with the object in its arguments.
*/
- (void)ojs_each:(void (^)(id object))block;
/**
A simpler alias for `enumerateObjectsUsingBlock` which also passes in an index
@param A block with the object in its arguments.
*/
- (void)ojs_eachWithIndex:(void (^)(id object, NSUInteger index))block;
/**
A simpler alias for `enumerateObjectsWithOptions:usingBlock:`
@param A block with the object in its arguments.
@param Enumerating options.
*/
- (void)ojs_each:(void (^)(id object))block options:(NSEnumerationOptions)options;
/**
A simpler alias for `enumerateObjectsWithOptions:usingBlock:` which also passes in an index
@param A block with the object in its arguments.
@param Enumerating options.
*/
- (void)ojs_eachWithIndex:(void (^)(id object, NSUInteger index))block options:(NSEnumerationOptions)options;
/**
An alias for `containsObject`
@param An object that the array may or may not contain.
*/
- (BOOL)ojs_includes:(id)object;
/**
Take the first `numberOfElements` out of the array, or the maximum amount of
elements if it is less.
@param Number of elements to take from array
@return An array of elements
*/
- (NSArray *)ojs_take:(NSUInteger)numberOfElements;
/**
Passes elements to the `block` until the block returns NO,
then stops iterating and returns an array of all prior elements.
@param A block that returns YES/NO
@return An array of elements
*/
- (NSArray *)ojs_takeWhile:(BOOL (^)(id object))block;
/**
Iterate through the current array running the block on each object and
returning an array of the changed objects.
@param A block that passes in each object and returns a modified object
@return An array of modified elements
*/
- (NSArray *)ojs_map:(id (^)(id object))block;
/**
Iterate through current array asking whether to keep each element.
@param A block that returns YES/NO for whether the object should stay
@return An array of elements selected
*/
- (NSArray *)ojs_select:(BOOL (^)(id object))block;
/**
Iterate through current array returning the first element meeting a criteria.
@param A block that returns YES/NO
@return The first matching element
*/
- (id)ojs_detect:(BOOL (^)(id object))block;
/**
Alias for `detect`. Iterate through current array returning the first element
meeting a criteria.
@param A block that returns YES/NO
@return The first matching element
*/
- (id)ojs_find:(BOOL (^)(id object))block;
/**
Iterate through current array asking whether to remove each element.
@param A block that returns YES/NO for whether the object should be removed
@return An array of elements not rejected
*/
- (NSArray *)ojs_reject:(BOOL (^)(id object))block;
/**
Recurse through self checking for NSArrays and extract all elements into one single array
@return An array of all held arrays merged
*/
- (NSArray *)ojs_flatten;
/**
Remove all the nulls from array
@return A copy of the given array without NSNulls
*/
- (NSArray *)ojs_compact;
/**
Alias for `componentsJoinedByString` with a default of no seperator
@return A string of all objects joined with an empty string
*/
- (NSString *)ojs_join;
/**
Alias for `componentsJoinedByString`
@return A string of all objects joined with the `seperator` string
*/
- (NSString *)ojs_join:(NSString *)separator;
/**
Run the default comparator on each object in the array
@return A sorted copy of the array
*/
- (NSArray *)ojs_sort;
/**
Sorts the array using the the default comparator on the given key
@return A sorted copy of the array
*/
- (NSArray *)ojs_sortBy:(NSString *)key;
/**
Alias for reverseObjectEnumerator.allObjects
Returns a reversed array
*/
- (NSArray *)ojs_reverse;
/**
Return all the objects that are in both self and `array`.
Alias for Ruby's & operator
@return An array of objects common to both arrays
*/
- (NSArray *)ojs_intersectionWithArray:(NSArray *)array;
/**
Return all the objects that in both self and `array` combined.
Alias for Ruby's | operator
@return An array of the two arrays combined
*/
- (NSArray *)ojs_unionWithArray:(NSArray *)array;
/**
Return all the objects in self that are not in `array`.
Alias for Ruby's - operator
@return An array of the self without objects in `array`
*/
- (NSArray *)ojs_relativeComplement:(NSArray *)array;
/**
Return all the objects that are unique to each array individually
Alias for Ruby's ^ operator. Equivalent of a - b | b - a
@return An array of elements which are in either of the arrays and not in their intersection.
*/
- (NSArray *)ojs_symmetricDifference:(NSArray *)array;
/**
Return a single value from an array by iterating through the elements and transforming a running total.
@return A single value that is the end result of apply the block function to each element successively.
**/
- (id)ojs_reduce:(id (^)(id accumulator, id object))block;
/**
Same as -reduce, with initial value provided by yourself
**/
- (id)ojs_reduce:(id)initial withBlock:(id (^)(id accumulator, id object))block;
/**
Produces a duplicate-free version of the array
@return a new array with all unique elements
**/
- (NSArray *)ojs_unique;
@end
| 25.522267 | 110 | 0.717481 | [
"object"
] |
3436bbc848c6551edcf04fc5d12d49cfeb2dad70 | 70,165 | c | C | cextern/wcslib/C/wcshdr.c | vdye/astropy | 2865905fa520c540a025e34fd52ee5a3b28d75d9 | [
"BSD-3-Clause"
] | null | null | null | cextern/wcslib/C/wcshdr.c | vdye/astropy | 2865905fa520c540a025e34fd52ee5a3b28d75d9 | [
"BSD-3-Clause"
] | null | null | null | cextern/wcslib/C/wcshdr.c | vdye/astropy | 2865905fa520c540a025e34fd52ee5a3b28d75d9 | [
"BSD-3-Clause"
] | null | null | null | /*============================================================================
WCSLIB 7.6 - an implementation of the FITS WCS standard.
Copyright (C) 1995-2021, Mark Calabretta
This file is part of WCSLIB.
WCSLIB is free software: you can redistribute it and/or modify it under the
terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
WCSLIB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
more details.
You should have received a copy of the GNU Lesser General Public License
along with WCSLIB. If not, see http://www.gnu.org/licenses.
Author: Mark Calabretta, Australia Telescope National Facility, CSIRO.
http://www.atnf.csiro.au/people/Mark.Calabretta
$Id: wcshdr.c,v 7.6 2021/04/13 12:57:01 mcalabre Exp $
*===========================================================================*/
#include <ctype.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "wcserr.h"
#include "wcsmath.h"
#include "wcsutil.h"
#include "wcshdr.h"
#include "wtbarr.h"
#include "tab.h"
#include "dis.h"
#include "wcs.h"
extern const int WCSSET;
extern const int DIS_DOTPD;
// Map status return value to message.
const char *wcshdr_errmsg[] = {
"Success",
"Null wcsprm pointer passed",
"Memory allocation failed",
"Invalid column selection",
"Fatal error returned by Flex parser",
"Invalid tabular parameters"};
// Map error returns for lower-level routines.
const int wcshdr_taberr[] = {
WCSHDRERR_SUCCESS, // 0: TABERR_SUCCESS
WCSHDRERR_NULL_POINTER, // 1: TABERR_NULL_POINTER
WCSHDRERR_MEMORY, // 2: TABERR_MEMORY
WCSHDRERR_BAD_TABULAR_PARAMS // 3: TABERR_BAD_PARAMS
// 4: TABERR_BAD_X
// 5: TABERR_BAD_WORLD
};
// Convenience macro for invoking wcserr_set().
#define WCSHDR_ERRMSG(status) WCSERR_SET(status), wcshdr_errmsg[status]
// Internal helper functions, not for general use.
static void wcshdo_format(int, int, const double [], char *);
static void wcshdo_tpdterm(int, int, char *);
static void wcshdo_util(int, const char [], const char [], int, const char [],
int, int, int, char, int, int [], char [], const char [], int *, char **,
int *);
//----------------------------------------------------------------------------
int wcstab(struct wcsprm *wcs)
{
static const char *function = "wcstab";
char (*PSi_0a)[72] = 0x0, (*PSi_1a)[72] = 0x0, (*PSi_2a)[72] = 0x0;
int *PVi_1a = 0x0, *PVi_2a = 0x0, *PVi_3a = 0x0, *tabax, *tabidx = 0x0;
int getcrd, i, ip, itab, itabax, j, jtabax, m, naxis, ntabax, status;
struct wtbarr *wtbp;
struct tabprm *tabp;
struct wcserr **err;
if (wcs == 0x0) return WCSHDRERR_NULL_POINTER;
err = &(wcs->err);
// Free memory previously allocated by wcstab().
if (wcs->flag != -1 && wcs->m_flag == WCSSET) {
if (wcs->wtb == wcs->m_wtb) wcs->wtb = 0x0;
if (wcs->tab == wcs->m_tab) wcs->tab = 0x0;
if (wcs->m_wtb) free(wcs->m_wtb);
if (wcs->m_tab) {
for (j = 0; j < wcs->ntab; j++) {
tabfree(wcs->m_tab + j);
}
free(wcs->m_tab);
}
}
wcs->ntab = 0;
wcs->nwtb = 0;
wcs->wtb = 0x0;
wcs->tab = 0x0;
// Determine the number of -TAB axes.
naxis = wcs->naxis;
if (!(tabax = calloc(naxis, sizeof(int)))) {
return wcserr_set(WCSHDR_ERRMSG(WCSHDRERR_MEMORY));
}
ntabax = 0;
for (i = 0; i < naxis; i++) {
// Null fill.
wcsutil_null_fill(72, wcs->ctype[i]);
if (!strcmp(wcs->ctype[i]+4, "-TAB")) {
tabax[i] = ntabax++;
} else {
tabax[i] = -1;
}
}
if (ntabax == 0) {
// No lookup tables.
status = 0;
goto cleanup;
}
// Collect information from the PSi_ma and PVi_ma keyvalues.
if (!((PSi_0a = calloc(ntabax, sizeof(char[72]))) &&
(PVi_1a = calloc(ntabax, sizeof(int))) &&
(PVi_2a = calloc(ntabax, sizeof(int))) &&
(PSi_1a = calloc(ntabax, sizeof(char[72]))) &&
(PSi_2a = calloc(ntabax, sizeof(char[72]))) &&
(PVi_3a = calloc(ntabax, sizeof(int))) &&
(tabidx = calloc(ntabax, sizeof(int))))) {
status = wcserr_set(WCSHDR_ERRMSG(WCSHDRERR_MEMORY));
goto cleanup;
}
for (itabax = 0; itabax < ntabax; itabax++) {
// Remember that calloc() zeroes allocated memory.
PVi_1a[itabax] = 1;
PVi_2a[itabax] = 1;
PVi_3a[itabax] = 1;
}
for (ip = 0; ip < wcs->nps; ip++) {
itabax = tabax[wcs->ps[ip].i - 1];
if (itabax >= 0) {
switch (wcs->ps[ip].m) {
case 0:
// EXTNAME.
strcpy(PSi_0a[itabax], wcs->ps[ip].value);
wcsutil_null_fill(72, PSi_0a[itabax]);
break;
case 1:
// TTYPEn for coordinate array.
strcpy(PSi_1a[itabax], wcs->ps[ip].value);
wcsutil_null_fill(72, PSi_1a[itabax]);
break;
case 2:
// TTYPEn for index vector.
strcpy(PSi_2a[itabax], wcs->ps[ip].value);
wcsutil_null_fill(72, PSi_2a[itabax]);
break;
}
}
}
for (ip = 0; ip < wcs->npv; ip++) {
itabax = tabax[wcs->pv[ip].i - 1];
if (itabax >= 0) {
switch (wcs->pv[ip].m) {
case 1:
// EXTVER.
PVi_1a[itabax] = (int)(wcs->pv[ip].value + 0.5);
break;
case 2:
// EXTLEVEL.
PVi_2a[itabax] = (int)(wcs->pv[ip].value + 0.5);
break;
case 3:
// Table axis number.
PVi_3a[itabax] = (int)(wcs->pv[ip].value + 0.5);
break;
}
}
}
// Determine the number of independent tables.
for (itabax = 0; itabax < ntabax; itabax++) {
// These have no defaults.
if (!PSi_0a[itabax][0] || !PSi_1a[itabax][0]) {
status = wcserr_set(WCSERR_SET(WCSHDRERR_BAD_TABULAR_PARAMS),
"Invalid tabular parameters: PSi_0a and PSi_1a must be specified");
goto cleanup;
}
tabidx[itabax] = -1;
for (jtabax = 0; jtabax < i; jtabax++) {
// EXTNAME, EXTVER, EXTLEVEL, and TTYPEn for the coordinate array
// must match for each axis of a multi-dimensional lookup table.
if (strcmp(PSi_0a[itabax], PSi_0a[jtabax]) == 0 &&
strcmp(PSi_1a[itabax], PSi_1a[jtabax]) == 0 &&
PVi_1a[itabax] == PVi_1a[jtabax] &&
PVi_2a[itabax] == PVi_2a[jtabax]) {
tabidx[itabax] = tabidx[jtabax];
break;
}
}
if (jtabax == itabax) {
tabidx[itabax] = wcs->ntab;
wcs->ntab++;
}
}
if (!(wcs->tab = calloc(wcs->ntab, sizeof(struct tabprm)))) {
status = wcserr_set(WCSHDR_ERRMSG(WCSHDRERR_MEMORY));
goto cleanup;
}
wcs->m_tab = wcs->tab;
// Table dimensionality; find the largest axis number.
for (itabax = 0; itabax < ntabax; itabax++) {
tabp = wcs->tab + tabidx[itabax];
// PVi_3a records the 1-relative table axis number.
if (PVi_3a[itabax] > tabp->M) {
tabp->M = PVi_3a[itabax];
}
}
for (itab = 0; itab < wcs->ntab; itab++) {
if ((status = tabini(1, wcs->tab[itab].M, 0, wcs->tab + itab))) {
status = wcserr_set(WCSHDR_ERRMSG(wcshdr_taberr[status]));
goto cleanup;
}
}
// Copy parameters into the tabprm structs.
for (i = 0; i < naxis; i++) {
if ((itabax = tabax[i]) < 0) {
// Not a -TAB axis.
continue;
}
// PVi_3a records the 1-relative table axis number.
m = PVi_3a[itabax] - 1;
tabp = wcs->tab + tabidx[itabax];
tabp->map[m] = i;
tabp->crval[m] = wcs->crval[i];
}
// Check for completeness.
for (itab = 0; itab < wcs->ntab; itab++) {
for (m = 0; m < wcs->tab[itab].M; m++) {
if (wcs->tab[itab].map[m] < 0) {
status = wcserr_set(WCSERR_SET(WCSHDRERR_BAD_TABULAR_PARAMS),
"Invalid tabular parameters: the axis mapping is undefined");
goto cleanup;
}
}
}
// Set up for reading the arrays; how many arrays are there?
for (itabax = 0; itabax < ntabax; itabax++) {
// Does this -TAB axis have a non-degenerate index array?
if (PSi_2a[itabax][0]) {
wcs->nwtb++;
}
}
// Add one coordinate array for each table.
wcs->nwtb += wcs->ntab;
// Allocate memory for structs to be returned.
if (!(wcs->wtb = calloc(wcs->nwtb, sizeof(struct wtbarr)))) {
wcs->nwtb = 0;
status = wcserr_set(WCSHDR_ERRMSG(WCSHDRERR_MEMORY));
goto cleanup;
}
wcs->m_wtb = wcs->wtb;
// Set pointers for the index and coordinate arrays.
wtbp = wcs->wtb;
for (itab = 0; itab < wcs->ntab; itab++) {
getcrd = 1;
for (itabax = 0; itabax < ntabax; itabax++) {
if (tabidx[itabax] != itab) continue;
if (getcrd) {
// Coordinate array.
wtbp->i = itabax + 1;
wtbp->m = PVi_3a[itabax];
wtbp->kind = 'c';
strcpy(wtbp->extnam, PSi_0a[itabax]);
wtbp->extver = PVi_1a[itabax];
wtbp->extlev = PVi_2a[itabax];
strcpy(wtbp->ttype, PSi_1a[itabax]);
wtbp->row = 1L;
wtbp->ndim = wcs->tab[itab].M + 1;
wtbp->dimlen = wcs->tab[itab].K;
wtbp->arrayp = &(wcs->tab[itab].coord);
// Signal for tabset() to take this memory.
wcs->tab[itab].m_coord = (double *)0x1;
wtbp++;
getcrd = 0;
}
if (PSi_2a[itabax][0]) {
// Index array.
wtbp->i = itabax + 1;
wtbp->m = PVi_3a[itabax];
wtbp->kind = 'i';
m = wtbp->m - 1;
strcpy(wtbp->extnam, PSi_0a[itabax]);
wtbp->extver = PVi_1a[itabax];
wtbp->extlev = PVi_2a[itabax];
strcpy(wtbp->ttype, PSi_2a[itabax]);
wtbp->row = 1L;
wtbp->ndim = 1;
wtbp->dimlen = wcs->tab[itab].K + m;
wtbp->arrayp = wcs->tab[itab].index + m;
// Signal for tabset() to take this memory.
wcs->tab[itab].m_indxs[m] = (double *)0x1;
wtbp++;
}
}
}
status = 0;
cleanup:
if (tabax) free(tabax);
if (tabidx) free(tabidx);
if (PSi_0a) free(PSi_0a);
if (PVi_1a) free(PVi_1a);
if (PVi_2a) free(PVi_2a);
if (PSi_1a) free(PSi_1a);
if (PSi_2a) free(PSi_2a);
if (PVi_3a) free(PVi_3a);
if (status) {
if (wcs->tab) free(wcs->tab);
if (wcs->wtb) free(wcs->wtb);
}
return status;
}
//----------------------------------------------------------------------------
int wcsidx(int nwcs, struct wcsprm **wcs, int alts[27])
{
int a, iwcs;
struct wcsprm *wcsp;
for (a = 0; a < 27; a++) {
alts[a] = -1;
}
if (wcs == 0x0) {
return WCSHDRERR_NULL_POINTER;
}
wcsp = *wcs;
for (iwcs = 0; iwcs < nwcs; iwcs++, wcsp++) {
if (wcsp->colnum || wcsp->colax[0]) continue;
if (wcsp->alt[0] == ' ') {
a = 0;
} else {
a = wcsp->alt[0] - 'A' + 1;
}
alts[a] = iwcs;
}
return 0;
}
//----------------------------------------------------------------------------
int wcsbdx(int nwcs, struct wcsprm **wcs, int type, short alts[1000][28])
{
short *ip;
int a, i, icol, iwcs;
struct wcsprm *wcsp;
for (ip = alts[0]; ip < alts[0] + 28*1000; ip++) {
*ip = -1;
}
for (icol = 0; icol < 1000; icol++) {
alts[icol][27] = 0;
}
if (wcs == 0x0) {
return WCSHDRERR_NULL_POINTER;
}
wcsp = *wcs;
for (iwcs = 0; iwcs < nwcs; iwcs++, wcsp++) {
if (wcsp->alt[0] == ' ') {
a = 0;
} else {
a = wcsp->alt[0] - 'A' + 1;
}
if (type) {
// Pixel list.
if (wcsp->colax[0]) {
for (i = 0; i < wcsp->naxis; i++) {
alts[wcsp->colax[i]][a] = iwcs;
alts[wcsp->colax[i]][27]++;
}
} else if (!wcsp->colnum) {
alts[0][a] = iwcs;
alts[0][27]++;
}
} else {
// Binary table image array.
if (wcsp->colnum) {
alts[wcsp->colnum][a] = iwcs;
alts[wcsp->colnum][27]++;
} else if (!wcsp->colax[0]) {
alts[0][a] = iwcs;
alts[0][27]++;
}
}
}
return 0;
}
//----------------------------------------------------------------------------
int wcsvfree(int *nwcs, struct wcsprm **wcs)
{
int a, status = 0;
struct wcsprm *wcsp;
if (wcs == 0x0) {
return WCSHDRERR_NULL_POINTER;
}
wcsp = *wcs;
for (a = 0; a < *nwcs; a++, wcsp++) {
status |= wcsfree(wcsp);
}
free(*wcs);
*nwcs = 0;
*wcs = 0x0;
return status;
}
//----------------------------------------------------------------------------
// Matching the definitions in dis.c.
#define I_DTYPE 0 // Distortion type code.
#define I_NIPARM 1 // Full (allocated) length of iparm[].
#define I_NDPARM 2 // No. of parameters in dparm[], excl. work space.
#define I_TPDNCO 3 // No. of TPD coefficients, forward...
#define I_TPDINV 4 // ...and inverse.
#define I_TPDAUX 5 // True if auxiliary variables are used.
#define I_TPDRAD 6 // True if the radial variable is used.
int wcshdo(int ctrl, struct wcsprm *wcs, int *nkeyrec, char **header)
// ::: CUBEFACE and STOKES handling?
{
static const char *function = "wcshdo";
const char axid[] = "xyxuvu", *cp;
const int nTPD[] = {1, 4, 7, 12, 17, 24, 31, 40, 49, 60};
char alt, comment[72], ctemp[32], *ctypei, format[16], fmt01[8],
keyvalue[96], keyword[16], *kp, obsg[8] = "OBSG?",
obsgeo[8] = "OBSGEO-?", pq, ptype, xtype, term[16], timeunit[16],
tpdsrc[24], xyz[] = "XYZ";
int *axmap, bintab, *colax, colnum, degree, direct = 0, doaux = 0, dofmt,
dosip, dotpd, dotpv, i, idis, idp, *iparm, j, jhat, k, kp0, kpi, m,
naxis, ncoeff, Nhat, p, pixlist, precision, primage, q, status = 0;
double *dparm, keyval;
struct auxprm *aux;
struct disprm *dis;
struct dpkey *keyp;
struct wcserr **err;
*nkeyrec = 0;
*header = 0x0;
if (wcs == 0x0) return WCSHDRERR_NULL_POINTER;
err = &(wcs->err);
if (wcs->flag != WCSSET) {
if ((status = wcsset(wcs))) return status;
}
if ((naxis = wcs->naxis) == 0) {
return 0;
}
// These are mainly for convenience.
alt = wcs->alt[0];
if (alt == ' ') alt = '\0';
colnum = wcs->colnum;
colax = wcs->colax;
primage = 0;
bintab = 0;
pixlist = 0;
if (colnum) {
bintab = 1;
} else if (colax[0]) {
pixlist = 1;
} else {
primage = 1;
}
// Initialize floating point format control.
*format = '\0';
if (ctrl & WCSHDO_P17) {
strcpy(format, "% 20.17G");
} else if (ctrl & WCSHDO_P16) {
strcpy(format, "% 20.16G");
} else if (ctrl & WCSHDO_P15) {
strcpy(format, "% 20.15G");
} else if (ctrl & WCSHDO_P14) {
strcpy(format, "% 20.14G");
} else if (ctrl & WCSHDO_P13) {
strcpy(format, "% 20.13G");
} else if (ctrl & WCSHDO_P12) {
strcpy(format, "%20.12G");
}
if (*format && (ctrl & WCSHDO_EFMT)) {
if (format[6] == 'G') {
format[6] = 'E';
} else {
format[7] = 'E';
}
}
dofmt = (*format == '\0');
// WCS dimension.
if (!pixlist) {
sprintf(keyvalue, "%20d", naxis);
wcshdo_util(ctrl, "WCSAXES", "WCAX", 0, 0x0, 0, 0, 0, alt, colnum, colax,
keyvalue, "Number of coordinate axes", nkeyrec, header, &status);
}
// Reference pixel coordinates.
if (dofmt) wcshdo_format('G', naxis, wcs->crpix, format);
for (j = 0; j < naxis; j++) {
wcsutil_double2str(keyvalue, format, wcs->crpix[j]);
wcshdo_util(ctrl, "CRPIX", "CRP", WCSHDO_CRPXna, "CRPX", 0, j+1, 0, alt,
colnum, colax, keyvalue, "Pixel coordinate of reference point", nkeyrec,
header, &status);
}
// Linear transformation matrix.
if (dofmt) wcshdo_format('G', naxis*naxis, wcs->pc, format);
k = 0;
for (i = 0; i < naxis; i++) {
for (j = 0; j < naxis; j++, k++) {
if (i == j) {
if (wcs->pc[k] == 1.0) continue;
} else {
if (wcs->pc[k] == 0.0) continue;
}
wcsutil_double2str(keyvalue, format, wcs->pc[k]);
wcshdo_util(ctrl, "PC", bintab ? "PC" : "P", WCSHDO_TPCn_ka,
bintab ? 0x0 : "PC", i+1, j+1, 0, alt, colnum, colax,
keyvalue, "Coordinate transformation matrix element",
nkeyrec, header, &status);
}
}
// Coordinate increment at reference point.
if (dofmt) wcshdo_format('G', naxis, wcs->cdelt, format);
for (i = 0; i < naxis; i++) {
wcsutil_double2str(keyvalue, format, wcs->cdelt[i]);
comment[0] = '\0';
if (wcs->cunit[i][0]) sprintf(comment, "[%s] ", wcs->cunit[i]);
strcat(comment, "Coordinate increment at reference point");
wcshdo_util(ctrl, "CDELT", "CDE", WCSHDO_CRPXna, "CDLT", i+1, 0, 0, alt,
colnum, colax, keyvalue, comment, nkeyrec, header, &status);
}
// Units of coordinate increment and reference value.
for (i = 0; i < naxis; i++) {
if (wcs->cunit[i][0] == '\0') continue;
sprintf(keyvalue, "'%s'", wcs->cunit[i]);
wcshdo_util(ctrl, "CUNIT", "CUN", WCSHDO_CRPXna, "CUNI", i+1, 0, 0, alt,
colnum, colax, keyvalue, "Units of coordinate increment and value",
nkeyrec, header, &status);
}
// May need to alter ctype for particular distortions so do basic checks
// now. Note that SIP, TPV, DSS, TNX, and ZPX are restricted to exactly
// two axes and cannot coexist with other distortion types.
dosip = 0;
dotpv = 0;
dotpd = 0;
if ((dis = wcs->lin.dispre)) {
for (i = 0; i < naxis; i++) {
if (strcmp(dis->dtype[i], "SIP") == 0) {
// Simple Imaging Polynomial (SIP). Write it in its native form
// if possible, unless specifically requested to write it as TPD.
dotpd = (dis->iparm[i][I_DTYPE] & DIS_DOTPD);
if (!dotpd) {;
if (alt ||
dis->Nhat[0] != 2 ||
dis->Nhat[1] != 2 ||
dis->axmap[0][0] != 0 ||
dis->axmap[0][1] != 1 ||
dis->axmap[1][0] != 0 ||
dis->axmap[1][1] != 1 ||
dis->offset[0][0] != wcs->crpix[0] ||
dis->offset[0][1] != wcs->crpix[1] ||
dis->offset[1][0] != wcs->crpix[0] ||
dis->offset[1][1] != wcs->crpix[1] ||
dis->scale[0][0] != 1.0 ||
dis->scale[0][1] != 1.0 ||
dis->scale[1][0] != 1.0 ||
dis->scale[1][1] != 1.0) {
// Must have been read as a 'SIP' distortion, CPDISja = 'SIP'.
// Cannot be written as native SIP so write it as TPD.
dotpd = DIS_DOTPD;
} else if (strncmp(wcs->ctype[0], "RA---TAN", 8) ||
strncmp(wcs->ctype[1], "DEC--TAN", 8)) {
// Must have been permuted by wcssub().
// Native SIP doesn't have axis mapping so write it as TPD.
dotpd = DIS_DOTPD;
}
if (dotpd) {
strcpy(tpdsrc, "SIP coordinates");
} else {
dosip = 1;
}
}
break;
}
}
}
if ((dis = wcs->lin.disseq)) {
for (i = 0; i < naxis; i++) {
if (strcmp(dis->dtype[i], "TPV") == 0) {
// TPV "projection". Write it in its native form if possible,
// unless specifically requested to write it as TPD.
dotpd = (dis->iparm[i][I_DTYPE] & DIS_DOTPD);
if (!dotpd) {;
if (dis->axmap[wcs->lng][0] != wcs->lng ||
dis->axmap[wcs->lng][1] != wcs->lat ||
dis->axmap[wcs->lat][0] != wcs->lat ||
dis->axmap[wcs->lat][1] != wcs->lng ||
dis->offset[wcs->lng][wcs->lng] != 0.0 ||
dis->offset[wcs->lng][wcs->lat] != 0.0 ||
dis->offset[wcs->lat][wcs->lng] != 0.0 ||
dis->offset[wcs->lat][wcs->lat] != 0.0 ||
dis->scale[wcs->lng][wcs->lng] != 1.0 ||
dis->scale[wcs->lng][wcs->lat] != 1.0 ||
dis->scale[wcs->lat][wcs->lng] != 1.0 ||
dis->scale[wcs->lat][wcs->lat] != 1.0) {
// Must have been read as a 'TPV' distortion, CPDISja = 'TPV'.
// Cannot be written as native TPV so write it as TPD.
dotpd = DIS_DOTPD;
}
if (dotpd) {
strcpy(tpdsrc, "TPV \"projection\"");
} else {
dotpv = 1;
}
}
break;
} else if (strcmp(dis->dtype[i], "DSS") == 0) {
// Always written as TPD.
dotpd = DIS_DOTPD;
strcpy(tpdsrc, dis->dtype[i]);
} else if (strncmp(dis->dtype[i], "WAT", 3) == 0) {
// Always written as TPD.
dotpd = DIS_DOTPD;
strcpy(tpdsrc, dis->dtype[i]+4);
if (strcmp(dis->dtype[i], "DSS") == 0) {
strcpy(tpdsrc, wcs->wcsname);
} else {
strcat(tpdsrc, " \"projection\"");
}
break;
}
}
}
// Coordinate type.
for (i = 0; i < naxis; i++) {
if (wcs->ctype[i][0] == '\0') continue;
sprintf(keyvalue, "'%s'", wcs->ctype[i]);
strcpy(comment, "Coordinate type code");
ctypei = keyvalue + 1;
if (i == wcs->lng || i == wcs->lat) {
// Alter ctype for particular distortions.
if (dosip) {
// It could have come in as CPDISja = 'SIP'.
strcpy(ctypei+8, "-SIP'");
} else if (dotpv) {
// Reinstate projection code edited by wcsset().
strcpy(ctypei+4, "-TPV'");
}
if (strncmp(ctypei+8, "-SIP", 4) == 0) {
strcpy(comment, "TAN (gnomonic) projection + SIP distortions");
} else if (strncmp(ctypei+4, "-TPV", 4) == 0) {
strcpy(comment, "TAN (gnomonic) projection + distortions");
} else {
if (strncmp(ctypei, "RA--", 4) == 0) {
strcpy(comment, "Right ascension, ");
} else if (strncmp(ctypei, "DEC-", 4) == 0) {
strcpy(comment, "Declination, ");
} else if (strncmp(ctypei+1, "LON", 3) == 0 ||
strncmp(ctypei+1, "LAT", 3) == 0) {
ctypei[0] = toupper(ctypei[0]);
switch (ctypei[0]) {
case 'G':
strcpy(comment, "galactic ");
break;
case 'E':
strcpy(comment, "ecliptic ");
break;
case 'H':
strcpy(comment, "helioecliptic ");
break;
case 'S':
strcpy(comment, "supergalactic ");
break;
}
if (i == wcs->lng) {
strcat(comment, "longitude, ");
} else {
strcat(comment, "latitude, ");
}
}
strcat(comment, wcs->cel.prj.name);
strcat(comment, " projection");
}
} else if (i == wcs->spec) {
spctyp(wcs->ctype[i], 0x0, 0x0, comment, 0x0, &ptype, &xtype, 0x0);
if (ptype == xtype) {
strcat(comment, " (linear)");
} else {
switch (xtype) {
case 'F':
strcat(comment, " (linear in frequency)");
break;
case 'V':
strcat(comment, " (linear in velocity)");
break;
case 'W':
strcat(comment, " (linear in wavelength)");
break;
}
}
}
wcshdo_util(ctrl, "CTYPE", "CTY", WCSHDO_CRPXna, "CTYP", i+1, 0, 0, alt,
colnum, colax, keyvalue, comment, nkeyrec, header, &status);
}
// Coordinate value at reference point.
for (i = 0; i < naxis; i++) {
if (dofmt) wcshdo_format('G', 1, wcs->crval+i, format);
wcsutil_double2str(keyvalue, format, wcs->crval[i]);
comment[0] = '\0';
if (wcs->cunit[i][0]) sprintf(comment, "[%s] ", wcs->cunit[i]);
strcat(comment, "Coordinate value at reference point");
wcshdo_util(ctrl, "CRVAL", "CRV", WCSHDO_CRPXna, "CRVL", i+1, 0, 0, alt,
colnum, colax, keyvalue, comment, nkeyrec, header, &status);
}
// Parameter values.
if (dofmt) strcpy(format, "%20.12G");
for (k = 0; k < wcs->npv; k++) {
wcsutil_double2str(keyvalue, format, (wcs->pv[k]).value);
if ((wcs->pv[k]).i == (wcs->lng + 1)) {
switch ((wcs->pv[k]).m) {
case 1:
strcpy(comment, "[deg] Native longitude of the reference point");
break;
case 2:
strcpy(comment, "[deg] Native latitude of the reference point");
break;
case 3:
if (primage) {
sprintf(keyword, "LONPOLE%c", alt);
} else if (bintab) {
sprintf(keyword, "LONP%d%c", colnum, alt);
} else {
sprintf(keyword, "LONP%d%c", colax[(wcs->pv[k]).i - 1], alt);
}
sprintf(comment, "[deg] alias for %s (has precedence)", keyword);
break;
case 4:
if (primage) {
sprintf(keyword, "LATPOLE%c", alt);
} else if (bintab) {
sprintf(keyword, "LATP%d%c", colnum, alt);
} else {
sprintf(keyword, "LATP%d%c", colax[(wcs->pv[k]).i - 1], alt);
}
sprintf(comment, "[deg] alias for %s (has precedence)", keyword);
break;
}
} else if ((wcs->pv[k]).i == (wcs->lat + 1)) {
sprintf(comment, "%s projection parameter", wcs->cel.prj.code);
} else {
strcpy(comment, "Coordinate transformation parameter");
}
wcshdo_util(ctrl, "PV", "V", WCSHDO_PVn_ma, "PV", wcs->pv[k].i, -1,
wcs->pv[k].m, alt, colnum, colax, keyvalue, comment,
nkeyrec, header, &status);
}
for (k = 0; k < wcs->nps; k++) {
sprintf(keyvalue, "'%s'", (wcs->ps[k]).value);
wcshdo_util(ctrl, "PS", "S", WCSHDO_PVn_ma, "PS", wcs->ps[k].i, -1,
wcs->ps[k].m, alt, colnum, colax, keyvalue,
"Coordinate transformation parameter",
nkeyrec, header, &status);
}
// Celestial and spectral transformation parameters.
if (!undefined(wcs->lonpole)) {
wcsutil_double2str(keyvalue, format, wcs->lonpole);
wcshdo_util(ctrl, "LONPOLE", "LONP", 0, 0x0, 0, 0, 0, alt,
colnum, colax, keyvalue, "[deg] Native longitude of celestial pole",
nkeyrec, header, &status);
}
if (!undefined(wcs->latpole)) {
wcsutil_double2str(keyvalue, format, wcs->latpole);
wcshdo_util(ctrl, "LATPOLE", "LATP", 0, 0x0, 0, 0, 0, alt,
colnum, colax, keyvalue, "[deg] Native latitude of celestial pole",
nkeyrec, header, &status);
}
if (wcs->restfrq != 0.0) {
wcsutil_double2str(keyvalue, format, wcs->restfrq);
wcshdo_util(ctrl, "RESTFRQ", "RFRQ", 0, 0x0, 0, 0, 0, alt,
colnum, colax, keyvalue, "[Hz] Line rest frequency",
nkeyrec, header, &status);
}
if (wcs->restwav != 0.0) {
wcsutil_double2str(keyvalue, format, wcs->restwav);
wcshdo_util(ctrl, "RESTWAV", "RWAV", 0, 0x0, 0, 0, 0, alt,
colnum, colax, keyvalue, "[Hz] Line rest wavelength",
nkeyrec, header, &status);
}
// - - - - - - - - - - - - - - - - - Auxiliary coordinate axis information.
sprintf(timeunit, "%.15s", wcs->timeunit[0] ? wcs->timeunit : "s");
// Coordinate axis title.
if (wcs->cname) {
for (i = 0; i < naxis; i++) {
if (wcs->cname[i][0] == '\0') continue;
sprintf(keyvalue, "'%s'", wcs->cname[i]);
wcshdo_util(ctrl, "CNAME", "CNA", WCSHDO_CNAMna, "CNAM", i+1, 0, 0,
alt, colnum, colax, keyvalue, "Axis name for labelling purposes",
nkeyrec, header, &status);
}
}
// Random error in coordinate.
if (wcs->crder) {
for (i = 0; i < naxis; i++) {
if (undefined(wcs->crder[i])) continue;
wcsutil_double2str(keyvalue, format, wcs->crder[i]);
comment[0] = '\0';
if (wcs->cunit[i][0]) sprintf(comment, "[%s] ", wcs->cunit[i]);
strcat(comment, "Random error in coordinate");
wcshdo_util(ctrl, "CRDER", "CRD", WCSHDO_CNAMna, "CRDE", i+1, 0, 0,
alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status);
}
}
// Systematic error in coordinate.
if (wcs->csyer) {
for (i = 0; i < naxis; i++) {
if (undefined(wcs->csyer[i])) continue;
wcsutil_double2str(keyvalue, format, wcs->csyer[i]);
comment[0] = '\0';
if (wcs->cunit[i][0]) sprintf(comment, "[%s] ", wcs->cunit[i]);
strcat(comment, "Systematic error in coordinate");
wcshdo_util(ctrl, "CSYER", "CSY", WCSHDO_CNAMna, "CSYE", i+1, 0, 0,
alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status);
}
}
// Time at zero point of phase axis.
if (wcs->czphs) {
for (i = 0; i < naxis; i++) {
if (undefined(wcs->czphs[i])) continue;
wcsutil_double2str(keyvalue, format, wcs->czphs[i]);
sprintf(comment, "[%s] Time at zero point of phase axis", timeunit);
wcshdo_util(ctrl, "CZPHS", "CZP", WCSHDO_CNAMna, "CZPH", i+1, 0, 0,
alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status);
}
}
// Period of phase axis.
if (wcs->cperi) {
for (i = 0; i < naxis; i++) {
if (undefined(wcs->cperi[i])) continue;
wcsutil_double2str(keyvalue, format, wcs->cperi[i]);
sprintf(comment, "[%s] Period of phase axis", timeunit);
wcshdo_util(ctrl, "CPERI", "CPR", WCSHDO_CNAMna, "CPER", i+1, 0, 0,
alt, colnum, colax, keyvalue, comment, nkeyrec, header, &status);
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - Coordinate system title.
// Coordinate system title.
if (wcs->wcsname[0]) {
sprintf(keyvalue, "'%s'", wcs->wcsname);
if (bintab) {
wcshdo_util(ctrl, "WCSNAME", "WCSN", 0, 0x0, 0, 0, 0, alt,
colnum, colax, keyvalue, "Coordinate system title",
nkeyrec, header, &status);
} else {
// TWCS was a mistake.
wcshdo_util(ctrl, "WCSNAME", "TWCS", WCSHDO_WCSNna, "WCSN", 0, 0, 0,
alt, colnum, colax, keyvalue, "Coordinate system title",
nkeyrec, header, &status);
}
}
// - - - - - - - - - - - - - - - - - Time reference system and measurement.
// Time scale.
if (wcs->timesys[0]) {
sprintf(keyvalue, "'%s'", wcs->timesys);
wcshdo_util(ctrl, "TIMESYS", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"Time scale", nkeyrec, header, &status);
}
// Time reference position.
if (wcs->trefpos[0]) {
sprintf(keyvalue, "'%s'", wcs->trefpos);
wcshdo_util(ctrl, "TREFPOS", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"Time reference position", nkeyrec, header, &status);
}
// Time reference direction.
if (wcs->trefdir[0]) {
sprintf(keyvalue, "'%s'", wcs->trefdir);
wcshdo_util(ctrl, "TREFDIR", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"Time reference direction", nkeyrec, header, &status);
}
// Ephemerides used for pathlength delay calculation.
if (wcs->plephem[0]) {
sprintf(keyvalue, "'%s'", wcs->plephem);
wcshdo_util(ctrl, "PLEPHEM", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"Ephemerides used for pathlength delays", nkeyrec, header, &status);
}
// Time units.
if (wcs->timeunit[0]) {
sprintf(keyvalue, "'%s'", wcs->timeunit);
wcshdo_util(ctrl, "TIMEUNIT", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"Time units", nkeyrec, header, &status);
}
// Fiducial (reference) time.
if (wcs->mjdref[0] == 0.0 && wcs->mjdref[1] == 0.0) {
// MJD of fiducial time (simplified if it takes its default value).
wcsutil_double2str(keyvalue, format, 0.0);
wcshdo_util(ctrl, "MJDREF", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"[d] MJD of fiducial time", nkeyrec, header, &status);
} else {
// ISO-8601 fiducial time.
if (wcs->dateref[0]) {
sprintf(keyvalue, "'%s'", wcs->dateref);
wcshdo_util(ctrl, "DATEREF", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "ISO-8601 fiducial time", nkeyrec, header, &status);
}
if (wcs->mjdref[1] == 0.0) {
// MJD of fiducial time (no fractional part).
if (!undefined(wcs->mjdref[0])) {
wcsutil_double2str(keyvalue, format, wcs->mjdref[0]);
wcshdo_util(ctrl, "MJDREF", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "[d] MJD of fiducial time", nkeyrec, header, &status);
}
} else {
// MJD of fiducial time, integer part.
if (!undefined(wcs->mjdref[0])) {
wcsutil_double2str(keyvalue, format, wcs->mjdref[0]);
wcshdo_util(ctrl, "MJDREFI", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "[d] MJD of fiducial time, integer part", nkeyrec,
header, &status);
}
// MJD of fiducial time, fractional part.
if (!undefined(wcs->mjdref[1])) {
wcsutil_double2str(keyvalue, format, wcs->mjdref[1]);
wcshdo_util(ctrl, "MJDREFF", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "[d] MJD of fiducial time, fractional part", nkeyrec,
header, &status);
}
}
}
// Clock correction.
if (!undefined(wcs->timeoffs)) {
wcsutil_double2str(keyvalue, format, wcs->timeoffs);
sprintf(comment, "[%s] Clock correction", timeunit);
wcshdo_util(ctrl, "TIMEOFFS", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
comment, nkeyrec, header, &status);
}
// - - - - - - - - - - - - - - - - - - - - - Data timestamps and durations.
// ISO-8601 time of observation.
if (wcs->dateobs[0]) {
sprintf(keyvalue, "'%s'", wcs->dateobs);
strcpy(comment, "ISO-8601 time of observation");
if (ctrl & 1) {
// Allow DOBSn.
wcshdo_util(ctrl, "DATE-OBS", "DOBS", WCSHDO_DOBSn, 0x0, 0, 0, 0, ' ',
colnum, colax, keyvalue, comment, nkeyrec, header, &status);
} else {
// Force DATE-OBS.
wcshdo_util(ctrl, "DATE-OBS", 0x0, 0, 0x0, 0, 0, 0, ' ',
0, 0x0, keyvalue, comment, nkeyrec, header, &status);
}
}
// MJD of observation.
if (!undefined(wcs->mjdobs)) {
wcsutil_double2str(keyvalue, format, wcs->mjdobs);
wcshdo_util(ctrl, "MJD-OBS", "MJDOB", 0, 0x0, 0, 0, 0, ' ',
colnum, colax, keyvalue, "[d] MJD of observation",
nkeyrec, header, &status);
}
// Julian epoch of observation.
if (!undefined(wcs->jepoch)) {
wcsutil_double2str(keyvalue, format, wcs->jepoch);
wcshdo_util(ctrl, "JEPOCH", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"[a] Julian epoch of observation", nkeyrec, header, &status);
}
// Besselian epoch of observation.
if (!undefined(wcs->bepoch)) {
wcsutil_double2str(keyvalue, format, wcs->bepoch);
wcshdo_util(ctrl, "BEPOCH", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"[a] Besselian epoch of observation", nkeyrec, header, &status);
}
// ISO-8601 time at start of observation.
if (wcs->datebeg[0]) {
sprintf(keyvalue, "'%s'", wcs->datebeg);
wcshdo_util(ctrl, "DATE-BEG", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"ISO-8601 time at start of observation", nkeyrec, header, &status);
}
// MJD at start of observation.
if (!undefined(wcs->mjdbeg)) {
wcsutil_double2str(keyvalue, format, wcs->mjdbeg);
wcshdo_util(ctrl, "MJD-BEG", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"[d] MJD at start of observation", nkeyrec, header, &status);
}
// Time elapsed at start since fiducial time.
if (!undefined(wcs->tstart)) {
wcsutil_double2str(keyvalue, format, wcs->tstart);
sprintf(comment, "[%s] Time elapsed since fiducial time at start",
timeunit);
wcshdo_util(ctrl, "TSTART", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
comment, nkeyrec, header, &status);
}
// ISO-8601 time at midpoint of observation.
if (wcs->dateavg[0]) {
sprintf(keyvalue, "'%s'", wcs->dateavg);
wcshdo_util(ctrl, "DATE-AVG", "DAVG", 0, 0x0, 0, 0, 0, ' ',
colnum, colax, keyvalue, "ISO-8601 time at midpoint of observation",
nkeyrec, header, &status);
}
// MJD at midpoint of observation.
if (!undefined(wcs->mjdavg)) {
wcsutil_double2str(keyvalue, format, wcs->mjdavg);
wcshdo_util(ctrl, "MJD-AVG", "MJDA", 0, 0x0, 0, 0, 0, ' ',
colnum, colax, keyvalue, "[d] MJD at midpoint of observation",
nkeyrec, header, &status);
}
// ISO-8601 time at end of observation.
if (wcs->dateend[0]) {
sprintf(keyvalue, "'%s'", wcs->dateend);
wcshdo_util(ctrl, "DATE-END", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"ISO-8601 time at end of observation", nkeyrec, header, &status);
}
// MJD at end of observation.
if (!undefined(wcs->mjdend)) {
wcsutil_double2str(keyvalue, format, wcs->mjdend);
wcshdo_util(ctrl, "MJD-END", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"[d] MJD at end of observation", nkeyrec, header, &status);
}
// Time elapsed at end since fiducial time.
if (!undefined(wcs->tstop)) {
wcsutil_double2str(keyvalue, format, wcs->tstop);
sprintf(comment, "[%s] Time elapsed since fiducial time at end",
timeunit);
wcshdo_util(ctrl, "TSTOP", "", 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
comment, nkeyrec, header, &status);
}
// Exposure (integration) time.
if (!undefined(wcs->xposure)) {
wcsutil_double2str(keyvalue, format, wcs->xposure);
sprintf(comment, "[%s] Exposure (integration) time", timeunit);
wcshdo_util(ctrl, "XPOSURE", "", 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
comment, nkeyrec, header, &status);
}
// Elapsed time (start to stop).
if (!undefined(wcs->telapse)) {
wcsutil_double2str(keyvalue, format, wcs->telapse);
sprintf(comment, "[%s] Elapsed time (start to stop)", timeunit);
wcshdo_util(ctrl, "TELAPSE", "", 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
comment, nkeyrec, header, &status);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - Timing accuracy.
// Systematic error in time measurements.
if (!undefined(wcs->timsyer)) {
wcsutil_double2str(keyvalue, format, wcs->timsyer);
sprintf(comment, "[%s] Systematic error in time measurements", timeunit);
wcshdo_util(ctrl, "TIMSYER", "", 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
comment, nkeyrec, header, &status);
}
// Relative error in time measurements.
if (!undefined(wcs->timrder)) {
wcsutil_double2str(keyvalue, format, wcs->timrder);
sprintf(comment, "[%s] Relative error in time measurements", timeunit);
wcshdo_util(ctrl, "TIMRDER", "", 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
comment, nkeyrec, header, &status);
}
// Time resolution.
if (!undefined(wcs->timedel)) {
wcsutil_double2str(keyvalue, format, wcs->timedel);
sprintf(comment, "[%s] Time resolution", timeunit);
wcshdo_util(ctrl, "TIMEDEL", "", 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
comment, nkeyrec, header, &status);
}
// Reference position of timestamp in binned data.
if (!undefined(wcs->timepixr)) {
wcsutil_double2str(keyvalue, format, wcs->timepixr);
wcshdo_util(ctrl, "TIMEPIXR", "", 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"Reference position of timestamp in binned data", nkeyrec, header,
&status);
}
// - - - - - - - - - - - - - - - - - - Spatial & celestial reference frame.
// Observatory coordinates.
if (!undefined(wcs->obsgeo[0]) &&
!undefined(wcs->obsgeo[1]) &&
!undefined(wcs->obsgeo[2])) {
for (k = 0; k < 3; k++) {
wcsutil_double2str(keyvalue, format, wcs->obsgeo[k]);
sprintf(comment, "[m] observatory %c-coordinate", xyz[k]);
obsgeo[7] = xyz[k];
obsg[4] = xyz[k];
wcshdo_util(ctrl, obsgeo, obsg, 0, 0x0, 0, 0, 0, ' ',
colnum, colax, keyvalue, comment, nkeyrec, header, &status);
}
} else if (
!undefined(wcs->obsgeo[3]) &&
!undefined(wcs->obsgeo[4]) &&
!undefined(wcs->obsgeo[5])) {
wcsutil_double2str(keyvalue, format, wcs->obsgeo[3]);
wcshdo_util(ctrl, "OBSGEO-L", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"[deg] IAU(1976) observatory longitude", nkeyrec, header, &status);
wcsutil_double2str(keyvalue, format, wcs->obsgeo[4]);
wcshdo_util(ctrl, "OBSGEO-B", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"[deg] IAU(1976) observatory latitude", nkeyrec, header, &status);
wcsutil_double2str(keyvalue, format, wcs->obsgeo[5]);
wcshdo_util(ctrl, "OBSGEO-L", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"[m] IAU(1976) observatory height", nkeyrec, header, &status);
}
// Spacecraft orbit ephemeris file.
if (wcs->obsorbit[0]) {
sprintf(keyvalue, "'%s'", wcs->obsorbit);
wcshdo_util(ctrl, "OBSORBIT", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0, keyvalue,
"Spacecraft orbit ephemeris file", nkeyrec, header, &status);
}
// Equatorial coordinate system type.
if (wcs->radesys[0]) {
sprintf(keyvalue, "'%s'", wcs->radesys);
wcshdo_util(ctrl, "RADESYS", "RADE", 0, 0x0, 0, 0, 0, alt, colnum, colax,
keyvalue, "Equatorial coordinate system", nkeyrec, header, &status);
}
// Equinox of equatorial coordinate system.
if (!undefined(wcs->equinox)) {
wcsutil_double2str(keyvalue, format, wcs->equinox);
wcshdo_util(ctrl, "EQUINOX", "EQUI", 0, 0x0, 0, 0, 0, alt, colnum, colax,
keyvalue, "[yr] Equinox of equatorial coordinates", nkeyrec, header,
&status);
}
// Reference frame of spectral coordinates.
if (wcs->specsys[0]) {
sprintf(keyvalue, "'%s'", wcs->specsys);
wcshdo_util(ctrl, "SPECSYS", "SPEC", 0, 0x0, 0, 0, 0, alt, colnum, colax,
keyvalue, "Reference frame of spectral coordinates", nkeyrec, header,
&status);
}
// Reference frame of spectral observation.
if (wcs->ssysobs[0]) {
sprintf(keyvalue, "'%s'", wcs->ssysobs);
wcshdo_util(ctrl, "SSYSOBS", "SOBS", 0, 0x0, 0, 0, 0, alt, colnum, colax,
keyvalue, "Reference frame of spectral observation", nkeyrec, header,
&status);
}
// Observer's velocity towards source.
if (!undefined(wcs->velosys)) {
wcsutil_double2str(keyvalue, format, wcs->velosys);
wcshdo_util(ctrl, "VELOSYS", "VSYS", 0, 0x0, 0, 0, 0, alt, colnum, colax,
keyvalue, "[m/s] Velocity towards source", nkeyrec, header, &status);
}
// Redshift of the source.
if (!undefined(wcs->zsource)) {
wcsutil_double2str(keyvalue, format, wcs->zsource);
wcshdo_util(ctrl, "ZSOURCE", "ZSOU", 0, 0x0, 0, 0, 0, alt, colnum, colax,
keyvalue, "Redshift of the source", nkeyrec, header, &status);
}
// Reference frame of source redshift.
if (wcs->ssyssrc[0]) {
sprintf(keyvalue, "'%s'", wcs->ssyssrc);
wcshdo_util(ctrl, "SSYSSRC", "SSRC", 0, 0x0, 0, 0, 0, alt, colnum, colax,
keyvalue, "Reference frame of source redshift", nkeyrec, header,
&status);
}
// Velocity orientation angle.
if (!undefined(wcs->velangl)) {
wcsutil_double2str(keyvalue, format, wcs->velangl);
wcshdo_util(ctrl, "VELANGL", "VANG", 0, 0x0, 0, 0, 0, alt, colnum, colax,
keyvalue, "[deg] Velocity orientation angle", nkeyrec, header, &status);
}
// - - - - - - - - - - - - - - - - - - - - Additional auxiliary parameters.
if ((aux = wcs->aux)) {
if (!undefined(aux->rsun_ref)) {
wcsutil_double2str(keyvalue, format, aux->rsun_ref);
wcshdo_util(ctrl, "RSUN_REF", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "[m] Solar radius", nkeyrec, header, &status);
}
if (!undefined(aux->dsun_obs)) {
wcsutil_double2str(keyvalue, format, aux->dsun_obs);
wcshdo_util(ctrl, "DSUN_OBS", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "[m] Distance from centre of Sun to observer", nkeyrec,
header, &status);
}
if (!undefined(aux->crln_obs)) {
wcsutil_double2str(keyvalue, format, aux->crln_obs);
wcshdo_util(ctrl, "CRLN_OBS", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "[deg] Carrington heliographic lng of observer", nkeyrec,
header, &status);
if (!undefined(aux->hglt_obs)) {
wcsutil_double2str(keyvalue, format, aux->hglt_obs);
wcshdo_util(ctrl, "CRLT_OBS", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "[deg] Heliographic latitude of observer", nkeyrec,
header, &status);
}
}
if (!undefined(aux->hgln_obs)) {
wcsutil_double2str(keyvalue, format, aux->hgln_obs);
wcshdo_util(ctrl, "HGLN_OBS", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "[deg] Stonyhurst heliographic lng of observer", nkeyrec,
header, &status);
if (!undefined(aux->hglt_obs)) {
wcsutil_double2str(keyvalue, format, aux->hglt_obs);
wcshdo_util(ctrl, "HGLT_OBS", 0x0, 0, 0x0, 0, 0, 0, ' ', 0, 0x0,
keyvalue, "[deg] Heliographic latitude of observer", nkeyrec,
header, &status);
}
}
}
// - - - - - - - - - - - - - - - - - - - - - Distortion function parameters.
if (dosip) {
// Simple Imaging Polynomial (SIP) is handled by translating its dpkey
// records. Determine a suitable numerical precision for the
// polynomial coefficients to avoid trailing zeroes common to all of
// them.
dis = wcs->lin.dispre;
if (dofmt) {
keyp = dis->dp;
kp0 = 2;
for (idp = 0; idp < dis->ndp; idp++, keyp++) {
cp = strchr(keyp->field, '.') + 1;
if (strncmp(cp, "SIP.", 4) != 0) continue;
wcsutil_double2str(keyvalue, "%20.13E", dpkeyd(keyp));
kpi = 15;
while (kp0 < kpi && keyvalue[kpi] == '0') kpi--;
kp0 = kpi;
}
precision = kp0 - 2;
if (precision < 1) precision = 1;
if (13 < precision) precision = 13;
sprintf(format, "%%20.%dE", precision);
}
// Ensure the coefficients are written in a human-readable sequence.
for (j = 0; j <= 1; j++) {
// Distortion function polynomial coefficients.
wcshdo_util(ctrl, "", "", 0, 0x0, 0, 0, 0, ' ', 0, 0, "", "",
nkeyrec, header, &status);
if (j == 0) {
strcpy(keyword, "A_");
} else {
strcpy(keyword, "B_");
}
ncoeff = dis->iparm[j][I_TPDNCO];
for (degree = 0; degree <= 9; degree++) {
if (ncoeff <= nTPD[degree]) break;
}
strcpy(keyword+2, "ORDER");
sprintf(keyvalue, "%20d", degree);
sprintf(comment, "SIP polynomial degree, axis %d, pixel-to-sky", j+1);
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, ' ', 0, 0,
keyvalue, comment, nkeyrec, header, &status);
keyp = dis->dp;
for (idp = 0; idp < dis->ndp; idp++, keyp++) {
if (keyp->j != j+1) continue;
if ((keyval = dpkeyd(keyp)) == 0.0) continue;
cp = strchr(keyp->field, '.') + 1;
if (strncmp(cp, "SIP.FWD.", 8) != 0) continue;
cp += 8;
strcpy(keyword+2, cp);
sscanf(cp, "%d_%d", &p, &q);
strncpy(term, "xxxxxxxxx", p);
strncpy(term+p, "yyyyyyyyy", q);
term[p+q] = '\0';
wcsutil_double2str(keyvalue, format, keyval);
sprintf(comment, "SIP distortion coefficient: %s", term);
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, ' ', 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
if (dis->maxdis[j] != 0.0) {
strcpy(keyword+2, "DMAX");
wcsutil_double2str(keyvalue, "%20.3f", dis->maxdis[j]);
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, ' ', 0, 0,
keyvalue, "Maximum value of distortion function", nkeyrec,
header, &status);
}
// Inverse distortion function polynomial coefficients.
if (dis->disx2p == 0x0) continue;
wcshdo_util(ctrl, "", "", 0, 0x0, 0, 0, 0, ' ', 0, 0, "", "",
nkeyrec, header, &status);
if (j == 0) {
strcpy(keyword, "AP_");
} else {
strcpy(keyword, "BP_");
}
ncoeff = dis->iparm[j][I_NDPARM] - dis->iparm[j][I_TPDNCO];
for (degree = 0; degree <= 9; degree++) {
if (ncoeff <= nTPD[degree]) break;
}
strcpy(keyword+3, "ORDER");
sprintf(keyvalue, "%20d", degree);
sprintf(comment, "SIP polynomial degree, axis %d, sky-to-pixel", j+1);
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, ' ', 0, 0,
keyvalue, comment, nkeyrec, header, &status);
keyp = dis->dp;
for (idp = 0; idp < dis->ndp; idp++, keyp++) {
if (keyp->j != j+1) continue;
if ((keyval = dpkeyd(keyp)) == 0.0) continue;
cp = strchr(keyp->field, '.') + 1;
if (strncmp(cp, "SIP.REV.", 8) != 0) continue;
cp += 8;
strcpy(keyword+3, cp);
sscanf(cp, "%d_%d", &p, &q);
strncpy(term, "xxxxxxxxx", p);
strncpy(term+p, "yyyyyyyyy", q);
term[p+q] = '\0';
wcsutil_double2str(keyvalue, format, keyval);
sprintf(comment, "SIP inverse coefficient: %s", term);
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, ' ', 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
}
}
for (idis = 0; idis < 2; idis++) {
if (idis == 0 && (dis = wcs->lin.dispre) == 0x0) continue;
if (idis == 1 && (dis = wcs->lin.disseq) == 0x0) continue;
for (j = 0; j < naxis; j++) {
if (dis->disp2x[j] == 0x0) continue;
iparm = dis->iparm[j];
dparm = dis->dparm[j];
// Identify the distortion type.
if (dotpv) {
// TPV "projection" is handled by translating its dpkey records,
// which were originally translated from PVi_ma by wcsset(), or
// possibly input directly as a CQDISia = 'TPV' distortion type.
// Determine a suitable numerical precision for the polynomial
// coefficients to avoid trailing zeroes common to all of them.
if (dofmt) wcshdo_format('E', iparm[I_NDPARM], dparm, format);
sprintf(fmt01, "%.3ss", format);
wcshdo_util(ctrl, "", "", 0, 0x0, 0, 0, 0, ' ', 0, 0, "", "",
nkeyrec, header, &status);
// Distortion function polynomial coefficients.
sprintf(keyword, "PV%d_", j+1);
kp = keyword + strlen(keyword);
keyp = dis->dp;
for (idp = 0; idp < dis->ndp; idp++, keyp++) {
if (keyp->j != j+1) continue;
if ((keyval = dpkeyd(keyp)) == 0.0) continue;
cp = strchr(keyp->field, '.') + 1;
if (strncmp(cp, "TPV.", 4) != 0) continue;
strcpy(kp, cp+4);
// Identify the term of the TPV polynomial for human readers.
sscanf(cp+4, "%d", &m);
wcshdo_tpdterm(m, j == wcs->lng, term);
sprintf(comment, "TPV coefficient: %s", term);
if (keyval == 1.0) {
sprintf(keyvalue, fmt01, "1.0");
} else {
wcsutil_double2str(keyvalue, format, keyval);
}
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
} else if (strcmp(dis->dtype[j], "TPD") == 0 || dotpd ||
strcmp(dis->dtype[j], "Polynomial") == 0 ||
strcmp(dis->dtype[j], "Polynomial*") == 0) {
// One of the Paper IV type polynomial distortions.
wcshdo_util(ctrl, "", "", 0, 0x0, 0, 0, 0, ' ', 0, 0, "", "",
nkeyrec, header, &status);
if (strcmp(dis->dtype[j], "TPD") == 0) {
// Pure TPD.
dotpd = 1;
} else if (strncmp(dis->dtype[j], "Polynomial", 10) == 0) {
// Polynomial distortion. Write it as TPD by request?
dotpd = (iparm[I_DTYPE] & DIS_DOTPD);
strcpy(tpdsrc, "Polynomial distortion");
}
pq = idis ? 'Q' : 'P';
Nhat = dis->Nhat[j];
// CPDISja/CQDISia
sprintf(keyword, "C%cDIS%d", pq, j+1);
if (idis == 0) {
strcpy(comment, "P = prior, ");
} else {
strcpy(comment, "Q = sequent, ");
}
if (dotpd) {
strcpy(keyvalue, "'TPD'");
strcat(comment, "Template Polynomial Distortion");
// For identifying terms of the TPD polynomial.
axmap = dis->axmap[j];
direct = 1;
doaux = iparm[I_TPDAUX];
if (Nhat == 2) {
// Associate x with longitude, y with latitude.
if (axmap[0] == wcs->lng && axmap[1] == wcs->lat) {
direct = 1;
} else if (axmap[0] == wcs->lat && axmap[1] == wcs->lng) {
direct = 0;
} else {
// Non-celestial.
direct = (axmap[0] < axmap[1]);
}
}
} else {
strcpy(keyvalue, "'Polynomial'");
strcat(comment, "general Polynomial distortion");
}
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
// NAXES.
sprintf(keyword, "D%c%d", pq, j+1);
sprintf(keyvalue, "'NAXES: %d'", Nhat);
if (Nhat == 1) {
strcpy(comment, "One independent variable");
} else if (Nhat == 2) {
strcpy(comment, "Two independent variables");
} else {
strcpy(comment, "Number of independent variables");
}
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
// AXIS.jhat
for (jhat = 0; jhat < Nhat; jhat++) {
axmap = dis->axmap[j];
sprintf(keyvalue, "'AXIS.%d: %d'", jhat+1, axmap[jhat]+1);
if (jhat == 0) {
strcpy(comment, "1st");
} else if (jhat == 1) {
strcpy(comment, "2nd");
} else if (jhat == 2) {
strcpy(comment, "3rd");
} else {
sprintf(comment, "%dth", jhat+1);
}
sprintf(comment+strlen(comment), " independent variable: axis %d",
axmap[jhat]+1);
if (dotpd) {
// axid is "xyxuvu".
cp = axid;
if (!direct) cp++;
if (doaux) cp += 3;
sprintf(comment+strlen(comment), " (= %c)", cp[jhat]);
}
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
// OFFSET.jhat
if (dofmt) wcshdo_format('f', Nhat, dis->offset[j], format);
for (jhat = 0; jhat < Nhat; jhat++) {
if (dis->offset[j][jhat] == 0.0) continue;
wcsutil_double2str(ctemp, format, dis->offset[j][jhat]);
sprintf(keyvalue, "'OFFSET.%d: %s'", jhat+1, ctemp);
sprintf(comment, "Variable %d renormalization offset", jhat+1);
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
// SCALE.jhat
if (dofmt) wcshdo_format('f', Nhat, dis->scale[j], format);
for (jhat = 0; jhat < Nhat; jhat++) {
if (dis->scale[j][jhat] == 1.0) continue;
wcsutil_double2str(ctemp, format, dis->scale[j][jhat]);
sprintf(keyvalue, "'SCALE.%d: %s'", jhat+1, ctemp);
sprintf(comment, "Variable %d renormalization scale", jhat+1);
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
// Does the distortion function compute a correction?
if (dis->docorr[j]) {
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
"'DOCORR: 1'", "Distortion function computes a correction",
nkeyrec, header, &status);
} else {
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
"'DOCORR: 0'", "Distortion function computes coordinates",
nkeyrec, header, &status);
}
if (dotpd) {
// Template Polynomial Distortion (TPD). As it may have been
// translated from SIP, TPV, DSS, TNX, ZPX, or perhaps
// Polynomial, the dpkey records may not relate to TPD.
// Output is therefore handled via dparm.
if (dofmt) wcshdo_format('E', iparm[I_NDPARM], dparm, format);
sprintf(fmt01, "%.3ss", format);
// AUX.jhat.COEFF.m
if (doaux) {
for (idp = 0; idp < 6; idp++) {
if (dparm[idp] == 0.0) {
sprintf(ctemp, fmt01, "0.0");
} else if (dparm[idp] == 1.0) {
sprintf(ctemp, fmt01, "1.0");
} else {
wcsutil_double2str(ctemp, format, dparm[idp]);
}
if (idp < 3) {
sprintf(keyvalue, "'AUX.1.COEFF.%d: %s'", idp%3, ctemp);
sprintf(comment, "TPD: x = c0 + c1*u + c2*v");
} else {
sprintf(keyvalue, "'AUX.2.COEFF.%d: %s'", idp%3, ctemp);
sprintf(comment, "TPD: y = d0 + d1*u + d2*v");
}
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
dparm += 6;
}
// TPD.FWD.m
for (idp = 0; idp < iparm[I_TPDNCO]; idp++) {
if (dparm[idp] == 0.0) continue;
if (dparm[idp] == 1.0) {
sprintf(ctemp, fmt01, "1.0");
} else {
wcsutil_double2str(ctemp, format, dparm[idp]);
}
m = idp;
sprintf(keyvalue, "'TPD.FWD.%d:%s %s'", m, (m<10)?" ":"", ctemp);
wcshdo_tpdterm(m, direct, term);
sprintf(comment, "TPD coefficient: %s", term);
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
// CPERRja/CQERRia
if (dis->maxdis[j] != 0.0) {
sprintf(keyword, "C%cERR%d", pq, j+1);
sprintf(keyvalue, "%20.2f", dis->maxdis[j]);
sprintf(comment, "%sMaximum absolute value of distortion",
idis?"":"[pix] ");
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
// Inverse distortion function polynomial coefficients.
if (dis->disx2p[j] == 0x0) continue;
wcshdo_util(ctrl, "", "", 0, 0x0, 0, 0, 0, ' ', 0, 0, "", "",
nkeyrec, header, &status);
// TPD.REV.m
sprintf(keyword, "D%c%d", pq, j+1);
for (idp = iparm[I_TPDNCO]; idp < iparm[I_NDPARM]; idp++) {
if (dparm[idp] == 0.0) continue;
wcsutil_double2str(ctemp, format, dparm[idp]);
m = idp - iparm[I_TPDNCO];
sprintf(keyvalue, "'TPD.REV.%d:%s %s'", m, (m<10)?" ":"", ctemp);
wcshdo_tpdterm(m, direct, term);
sprintf(comment, "TPD coefficient: %s", term);
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
} else {
// General polynomial distortion, handled via its dpkey records
// since iparm and dparm may hold a translation to TPD.
// Do auxiliary variables first.
keyp = dis->dp;
for (idp = 0; idp < dis->ndp; idp++, keyp++) {
if (keyp->j != j+1) continue;
cp = strchr(keyp->field, '.') + 1;
if (strncmp(cp, "NAUX", 4) != 0) continue;
sprintf(keyvalue, "'%s: %d'", cp, dpkeyi(keyp));
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, "Number of auxiliary variables", nkeyrec, header,
&status);
keyp = dis->dp;
for (idp = 0; idp < dis->ndp; idp++, keyp++) {
if (keyp->j != j+1) continue;
keyval = dpkeyd(keyp);
cp = strchr(keyp->field, '.') + 1;
if (strncmp(cp, "AUX.", 4) != 0) continue;
sscanf(cp+4, "%d", &m);
sprintf(keyvalue, "'%s:", cp);
cp = strchr(cp+4, '.') + 1;
kp = keyvalue + strlen(keyvalue);
if ((double)((int)keyval) == keyval) {
sprintf(kp, "%4d'", (int)keyval);
} else if (keyval == 0.5) {
strcat(kp, " 0.5'");
} else {
wcsutil_double2str(kp, "%21.13E", keyval);
strcat(keyvalue, "'");
}
sscanf(cp+6, "%d", &p);
if (strncmp(cp, "POWER.", 4) == 0) {
if (p) {
sprintf(comment, "Aux %d: var %d power", m, p);
} else {
sprintf(comment, "Aux %d: power of sum of terms", m);
}
} else {
if (p) {
sprintf(comment, "Aux %d: var %d coefficient", m, p);
} else {
sprintf(comment, "Aux %d: offset term", m);
}
}
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
break;
}
// Do polynomial terms.
keyp = dis->dp;
for (idp = 0; idp < dis->ndp; idp++, keyp++) {
if (keyp->j != j+1) continue;
cp = strchr(keyp->field, '.') + 1;
if (strncmp(cp, "NTERMS", 6) != 0) continue;
sprintf(keyvalue, "'%s: %d'", cp, dpkeyi(keyp));
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, "Number of terms in the polynomial", nkeyrec, header,
&status);
}
keyp = dis->dp;
for (idp = 0; idp < dis->ndp; idp++, keyp++) {
if (keyp->j != j+1) continue;
if ((keyval = dpkeyd(keyp)) == 0.0) continue;
cp = strchr(keyp->field, '.') + 1;
if (strncmp(cp, "TERM.", 5) != 0) continue;
sscanf(cp+5, "%d", &m);
sprintf(keyvalue, "'%s:%s ", cp, (m<10)?" ":"");
cp = strchr(cp+5, '.') + 1;
kp = keyvalue + strlen(keyvalue);
if (strncmp(cp, "VAR.", 4) == 0) {
if ((double)((int)keyval) == keyval) {
sprintf(kp, "%20d", (int)keyval);
} else {
wcsutil_double2str(kp, "%20.13f", keyval);
}
sscanf(cp+4, "%d", &p);
if (p <= Nhat) {
sprintf(comment, "Poly term %d: var %d power", m, p);
} else {
sprintf(comment, "Poly term %d: aux %d power", m, p-Nhat);
}
} else {
wcsutil_double2str(kp, "%20.13E", keyval);
sprintf(comment, "Poly term %d: coefficient", m);
}
strcat(keyvalue, "'");
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
// CPERRja/CQERRia
if (dis->maxdis[j] != 0.0) {
sprintf(keyword, "C%cERR%d", pq, j+1);
sprintf(keyvalue, "%20.2f", dis->maxdis[j]);
sprintf(comment, "%sMaximum absolute value of distortion",
idis?"":"[pix] ");
wcshdo_util(ctrl, keyword, "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
}
}
}
// DVERRa
if (dis->totdis != 0.0) {
sprintf(keyvalue, "%20.2f", dis->totdis);
sprintf(comment, "Maximum combined distortion");
wcshdo_util(ctrl, "DVERR", "", 0, 0x0, 0, 0, 0, alt, 0, 0,
keyvalue, comment, nkeyrec, header, &status);
}
}
// Add identification.
wcshdo_util(ctrl, "", "", 0, 0x0, 0, 0, 0, ' ', 0, 0, "", "",
nkeyrec, header, &status);
if (dotpd == DIS_DOTPD) {
// TPD by translation.
sprintf(comment, "Translated from %s to TPD by WCSLIB %s", tpdsrc,
wcslib_version(0x0));
} else {
sprintf(comment, "WCS header keyrecords produced by WCSLIB %s",
wcslib_version(0x0));
}
wcshdo_util(ctrl, "COMMENT", "", 0, 0x0, 0, 0, 0, ' ', 0, 0,
"", comment, nkeyrec, header, &status);
if (status == WCSHDRERR_MEMORY) {
wcserr_set(WCSHDR_ERRMSG(status));
}
return status;
}
//----------------------------------------------------------------------------
// Determine a suitable floating point format for a set of parameters.
void wcshdo_format(
int fmt,
int nval,
const double val[],
char *format)
{
int emax = -999;
int emin = +999;
int precision = 0;
for (int i = 0; i < nval; i++) {
// Double precision has at least 15 significant digits, and up to 17:
// http://en.wikipedia.org/wiki/Double-precision_floating-point_format
char cval[24];
wcsutil_double2str(cval, "%21.14E", val[i]);
int cpi = 16;
while (2 < cpi && cval[cpi] == '0') cpi--;
// Precision for 'E' format.
cpi -= 2;
if (precision < cpi) precision = cpi;
// Range of significant digits for 'f' format.
int expon;
sscanf(cval+18, "%d", &expon);
if (emax < expon) emax = expon;
expon -= cpi;
if (expon < emin) emin = expon;
}
if (fmt == 'G') {
// Because e.g. writing 1e4 as 10000 requires an extra digit.
emax++;
if (emin < -15 || 15 < emax || 15 < (emax - emin)) {
fmt = 'E';
} else {
fmt = 'f';
}
}
if (fmt == 'f') {
precision = -emin;
if (precision < 1) precision = 1;
if (17 < precision) precision = 17;
sprintf(format, "%%20.%df", precision);
} else {
if (precision < 1) precision = 1;
if (14 < precision) precision = 14;
if (precision < 14) {
sprintf(format, "%%20.%dE", precision);
} else {
sprintf(format, "%%21.%dE", precision);
}
}
}
//----------------------------------------------------------------------------
// Construct a string that identifies the term of a TPD or TPV polynomial.
void wcshdo_tpdterm(
int m,
int direct,
char *term)
{
const int nTPD[] = {1, 4, 7, 12, 17, 24, 31, 40, 49, 60};
int degree, k;
for (degree = 0; degree <= 9; degree++) {
if (m < nTPD[degree]) break;
}
if (degree == 0) {
strcpy(term, "1");
} else {
k = degree - (m - nTPD[degree-1]);
if (k < 0) {
memcpy(term, "rrrrrrrrr", degree);
} else if (direct) {
memcpy(term, "xxxxxxxxx", k);
memcpy(term+k, "yyyyyyyyy", degree-k);
} else {
memcpy(term, "yyyyyyyyy", k);
memcpy(term+k, "xxxxxxxxx", degree-k);
}
term[degree] = '\0';
}
}
//----------------------------------------------------------------------------
// Construct a keyrecord from the components given.
void wcshdo_util(
int relax,
const char pikey[],
const char tbkey[],
int level,
const char tlkey[],
int i,
int j,
int m,
char alt,
int btcol,
int plcol[],
char keyvalue[],
const char keycomment[],
int *nkeyrec,
char **header,
int *status)
{
char ch0, ch1, *hptr, keyword[32], *kptr;
int nbyte, nc = 47, nv;
if (*status) return;
// Reallocate memory in blocks of 2880 bytes.
if ((*nkeyrec)%32 == 0) {
nbyte = ((*nkeyrec)/32 + 1) * 2880;
if (!(hptr = realloc(*header, nbyte))) {
*status = WCSHDRERR_MEMORY;
return;
}
*header = hptr;
}
// Construct the keyword.
if (alt == ' ') alt = '\0';
if (btcol) {
// Binary table image array.
if (i > 0 && j) {
if (j > 0) {
sprintf(keyword, "%d%d%s%d%c", i, j, tbkey, btcol, alt);
} else {
sprintf(keyword, "%d%s%d_%d%c", i, tbkey, btcol, m, alt);
}
} else if (i > 0) {
sprintf(keyword, "%d%s%d%c", i, tbkey, btcol, alt);
} else if (j > 0) {
sprintf(keyword, "%d%s%d%c", j, tbkey, btcol, alt);
} else {
sprintf(keyword, "%s%d%c", tbkey, btcol, alt);
}
if ((strlen(keyword) < 8) && tlkey && (relax & level)) {
// Use the long form.
if (i > 0 && j) {
if (j > 0) {
sprintf(keyword, "%d%d%s%d%c", i, j, tlkey, btcol, alt);
} else {
sprintf(keyword, "%d%s%d_%d%c", i, tlkey, btcol, m, alt);
}
} else if (i > 0) {
sprintf(keyword, "%d%s%d%c", i, tlkey, btcol, alt);
} else if (j > 0) {
sprintf(keyword, "%d%s%d%c", j, tlkey, btcol, alt);
} else {
sprintf(keyword, "%s%d%c", tlkey, btcol, alt);
}
}
} else if (plcol && plcol[0]) {
// Pixel list.
if (i > 0 && j) {
if (j > 0) {
sprintf(keyword, "T%s%d_%d%c", tbkey, plcol[i-1], plcol[j-1], alt);
} else {
sprintf(keyword, "T%s%d_%d%c", tbkey, plcol[i-1], m, alt);
}
} else if (i > 0) {
sprintf(keyword, "T%s%d%c", tbkey, plcol[i-1], alt);
} else if (j > 0) {
sprintf(keyword, "T%s%d%c", tbkey, plcol[j-1], alt);
} else {
sprintf(keyword, "%s%d%c", tbkey, plcol[0], alt);
}
if ((strlen(keyword) < 8) && tlkey && (relax & level)) {
// Use the long form.
if (i > 0 && j) {
if (j > 0) {
sprintf(keyword, "T%s%d_%d%c", tlkey, plcol[i-1], plcol[j-1], alt);
} else {
sprintf(keyword, "T%s%d_%d%c", tlkey, plcol[i-1], m, alt);
}
} else if (i > 0) {
sprintf(keyword, "T%s%d%c", tlkey, plcol[i-1], alt);
} else if (j > 0) {
sprintf(keyword, "T%s%d%c", tlkey, plcol[j-1], alt);
} else {
sprintf(keyword, "%s%d%c", tlkey, plcol[0], alt);
}
}
} else {
if (i > 0 && j) {
if (j > 0) {
sprintf(keyword, "%s%d_%d%c", pikey, i, j, alt);
} else {
sprintf(keyword, "%s%d_%d%c", pikey, i, m, alt);
}
} else if (i > 0) {
sprintf(keyword, "%s%d%c", pikey, i, alt);
} else if (j > 0) {
sprintf(keyword, "%s%d%c", pikey, j, alt);
} else {
sprintf(keyword, "%s%c", pikey, alt);
}
}
// Double-up single-quotes in string keyvalues.
if (*keyvalue == '\'') {
hptr = keyvalue + 1;
while (*hptr) {
if (*hptr == '\'') {
kptr = hptr++;
if (*hptr) {
ch0 = *kptr;
while (*kptr) {
ch1 = *(++kptr);
*kptr = ch0;
ch0 = ch1;
}
} else {
break;
}
}
hptr++;
}
// Check length.
if (strlen(keyvalue) > 70) {
// Truncate.
keyvalue[69] = '\'';
keyvalue[70] = '\0';
}
} else {
// Check length.
if (strlen(keyvalue) > 70) {
// Truncate.
keyvalue[70] = '\0';
}
}
if ((nv = strlen(keyvalue) > 20)) {
// Rob the keycomment to make space for the keyvalue.
nc -= (nv - 20);
}
hptr = *header + (80 * ((*nkeyrec)++));
if (*keyword == '\0') {
sprintf(hptr, "%80.80s", " ");
} else if (strcmp(keyword, "COMMENT") == 0) {
sprintf(hptr, "%-8.8s %-71.71s", keyword, keycomment);
} else {
sprintf(hptr, "%-8.8s= %-20s / %-*.*s", keyword, keyvalue, nc, nc,
keycomment);
}
}
| 31.763241 | 78 | 0.528397 | [
"vector"
] |
343a84d3c8599a4e5617c0b60f353f5b3f626c09 | 2,558 | h | C | source/adios2/engine/ssc/SscWriter.h | eschnett/ADIOS2 | fe969818c11e82a5acf8e066fcdd231ad1553ce0 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | source/adios2/engine/ssc/SscWriter.h | eschnett/ADIOS2 | fe969818c11e82a5acf8e066fcdd231ad1553ce0 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | source/adios2/engine/ssc/SscWriter.h | eschnett/ADIOS2 | fe969818c11e82a5acf8e066fcdd231ad1553ce0 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | /*
* Distributed under the OSI-approved Apache License, Version 2.0. See
* accompanying file Copyright.txt for details.
*
* SscWriter.h
*
* Created on: Nov 1, 2018
* Author: Jason Wang
*/
#ifndef ADIOS2_ENGINE_SSCWRITER_H_
#define ADIOS2_ENGINE_SSCWRITER_H_
#include "SscHelper.h"
#include "adios2/core/Engine.h"
#include "adios2/helper/adiosMpiHandshake.h"
#include "adios2/toolkit/profiling/taustubs/tautimer.hpp"
#include <mpi.h>
#include <queue>
namespace adios2
{
namespace core
{
namespace engine
{
class SscWriter : public Engine
{
public:
SscWriter(IO &adios, const std::string &name, const Mode mode,
helper::Comm comm);
~SscWriter() = default;
StepStatus BeginStep(
StepMode mode,
const float timeoutSeconds = std::numeric_limits<float>::max()) final;
size_t CurrentStep() const final;
void PerformPuts() final;
void EndStep() final;
void Flush(const int transportIndex = -1) final;
private:
int64_t m_CurrentStep = -1;
ssc::BlockVecVec m_GlobalWritePattern;
ssc::BlockVecVec m_GlobalReadPattern;
ssc::RankPosMap m_AllSendingReaderRanks;
ssc::Buffer m_Buffer;
MPI_Win m_MpiWin;
MPI_Group m_ReaderGroup;
MPI_Comm m_StreamComm;
MPI_Comm m_WriterComm;
std::vector<MPI_Request> m_MpiRequests;
std::thread m_EndStepThread;
int m_StreamRank;
int m_StreamSize;
int m_WriterRank;
int m_WriterSize;
int m_WriterMasterStreamRank;
int m_ReaderMasterStreamRank;
void SyncMpiPattern();
void SyncWritePattern(bool finalStep = false);
void SyncReadPattern();
void EndStepFirst();
void EndStepConsequentFixed();
void EndStepConsequentFlexible();
#define declare_type(T) \
void DoPutSync(Variable<T> &, const T *) final; \
void DoPutDeferred(Variable<T> &, const T *) final;
ADIOS2_FOREACH_STDTYPE_1ARG(declare_type)
#undef declare_type
void DoClose(const int transportIndex = -1) final;
template <class T>
void PutDeferredCommon(Variable<T> &variable, const T *values);
void CalculatePosition(ssc::BlockVecVec &writerMapVec,
ssc::BlockVecVec &readerMapVec, const int writerRank,
ssc::RankPosMap &allOverlapRanks);
int m_Verbosity = 0;
int m_OpenTimeoutSecs = 10;
bool m_Threading = false;
};
} // end namespace engine
} // end namespace core
} // end namespace adios2
#endif // ADIOS2_ENGINE_SSCWRITER_H_
| 26.102041 | 80 | 0.677873 | [
"vector"
] |
343cd4ca2aa061ff0b9c49c60f7a212a5ba64ab1 | 30,907 | c | C | wireshark-2.0.13/epan/dissectors/packet-pgsql.c | mahrukhfida/mi | 7187765aa225e71983969ef5285771ac77c8309a | [
"Apache-2.0"
] | null | null | null | wireshark-2.0.13/epan/dissectors/packet-pgsql.c | mahrukhfida/mi | 7187765aa225e71983969ef5285771ac77c8309a | [
"Apache-2.0"
] | null | null | null | wireshark-2.0.13/epan/dissectors/packet-pgsql.c | mahrukhfida/mi | 7187765aa225e71983969ef5285771ac77c8309a | [
"Apache-2.0"
] | null | null | null | /* packet-pgsql.c
* Routines for PostgreSQL v3 protocol dissection.
* <http://www.postgresql.org/docs/current/static/protocol.html>
* Copyright 2004 Abhijit Menon-Sen <ams@oryx.com>
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include <epan/packet.h>
#include <epan/prefs.h>
#include "packet-ssl-utils.h"
#include "packet-tcp.h"
void proto_register_pgsql(void);
void proto_reg_handoff_pgsql(void);
static dissector_handle_t pgsql_handle;
static dissector_handle_t ssl_handle;
static int proto_pgsql = -1;
static int hf_frontend = -1;
static int hf_type = -1;
static int hf_length = -1;
static int hf_parameter_name = -1;
static int hf_parameter_value = -1;
static int hf_query = -1;
static int hf_authtype = -1;
static int hf_passwd = -1;
static int hf_salt = -1;
static int hf_statement = -1;
static int hf_portal = -1;
static int hf_return = -1;
static int hf_tag = -1;
static int hf_status = -1;
static int hf_copydata = -1;
static int hf_error = -1;
static int hf_pid = -1;
static int hf_key = -1;
static int hf_condition = -1;
static int hf_text = -1;
static int hf_tableoid = -1;
static int hf_typeoid = -1;
static int hf_oid = -1;
static int hf_format = -1;
static int hf_field_count = -1;
static int hf_val_name = -1;
static int hf_val_idx = -1;
static int hf_val_length = -1;
static int hf_val_data = -1;
static int hf_val_mod = -1;
static int hf_severity = -1;
static int hf_code = -1;
static int hf_message = -1;
static int hf_detail = -1;
static int hf_hint = -1;
static int hf_position = -1;
static int hf_internal_position = -1;
static int hf_internal_query = -1;
static int hf_where = -1;
static int hf_schema_name = -1;
static int hf_table_name = -1;
static int hf_column_name = -1;
static int hf_type_name = -1;
static int hf_constraint_name = -1;
static int hf_file = -1;
static int hf_line = -1;
static int hf_routine = -1;
static gint ett_pgsql = -1;
static gint ett_values = -1;
static guint pgsql_port = 5432;
static gboolean pgsql_desegment = TRUE;
static gboolean first_message = TRUE;
typedef struct pgsql_conn_data {
gboolean ssl_requested;
} pgsql_conn_data_t;
static const value_string fe_messages[] = {
{ 'p', "Password message" },
{ 'Q', "Simple query" },
{ 'P', "Parse" },
{ 'B', "Bind" },
{ 'E', "Execute" },
{ 'D', "Describe" },
{ 'C', "Close" },
{ 'H', "Flush" },
{ 'S', "Sync" },
{ 'F', "Function call" },
{ 'd', "Copy data" },
{ 'c', "Copy completion" },
{ 'f', "Copy failure" },
{ 'X', "Termination" },
{ 0, NULL }
};
static const value_string be_messages[] = {
{ 'R', "Authentication request" },
{ 'K', "Backend key data" },
{ 'S', "Parameter status" },
{ '1', "Parse completion" },
{ '2', "Bind completion" },
{ '3', "Close completion" },
{ 'C', "Command completion" },
{ 't', "Parameter description" },
{ 'T', "Row description" },
{ 'D', "Data row" },
{ 'I', "Empty query" },
{ 'n', "No data" },
{ 'E', "Error" },
{ 'N', "Notice" },
{ 's', "Portal suspended" },
{ 'Z', "Ready for query" },
{ 'A', "Notification" },
{ 'V', "Function call response" },
{ 'G', "CopyIn response" },
{ 'H', "CopyOut response" },
{ 'd', "Copy data" },
{ 'c', "Copy completion" },
{ 0, NULL }
};
static const value_string auth_types[] = {
{ 0, "Success" },
{ 1, "Kerberos V4" },
{ 2, "Kerberos V5" },
{ 3, "Plaintext password" },
{ 4, "crypt()ed password" },
{ 5, "MD5 password" },
{ 6, "SCM credentials" },
{ 0, NULL }
};
static const value_string status_vals[] = {
{ 'I', "Idle" },
{ 'T', "In a transaction" },
{ 'E', "In a failed transaction" },
{ 0, NULL }
};
static const value_string format_vals[] = {
{ 0, "Text" },
{ 1, "Binary" },
{ 0, NULL }
};
static void dissect_pgsql_fe_msg(guchar type, guint length, tvbuff_t *tvb,
gint n, proto_tree *tree,
pgsql_conn_data_t *conv_data)
{
guchar c;
gint i, siz;
char *s;
proto_tree *shrub;
switch (type) {
/* Password */
case 'p':
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_passwd, tvb, n, siz, ENC_ASCII|ENC_NA);
break;
/* Simple query */
case 'Q':
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_query, tvb, n, siz, ENC_ASCII|ENC_NA);
break;
/* Parse */
case 'P':
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_statement, tvb, n, siz, ENC_ASCII|ENC_NA);
n += siz;
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_query, tvb, n, siz, ENC_ASCII|ENC_NA);
n += siz;
i = tvb_get_ntohs(tvb, n);
shrub = proto_tree_add_subtree_format(tree, tvb, n, 2, ett_values, NULL, "Parameters: %d", i);
n += 2;
while (i-- > 0) {
proto_tree_add_item(shrub, hf_typeoid, tvb, n, 4, ENC_BIG_ENDIAN);
n += 4;
}
break;
/* Bind */
case 'B':
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_portal, tvb, n, siz, ENC_ASCII|ENC_NA);
n += siz;
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_statement, tvb, n, siz, ENC_ASCII|ENC_NA);
n += siz;
i = tvb_get_ntohs(tvb, n);
shrub = proto_tree_add_subtree_format(tree, tvb, n, 2, ett_values, NULL, "Parameter formats: %d", i);
n += 2;
while (i-- > 0) {
proto_tree_add_item(shrub, hf_format, tvb, n, 2, ENC_BIG_ENDIAN);
n += 2;
}
i = tvb_get_ntohs(tvb, n);
shrub = proto_tree_add_subtree_format(tree, tvb, n, 2, ett_values, NULL, "Parameter values: %d", i);
n += 2;
while (i-- > 0) {
siz = tvb_get_ntohl(tvb, n);
proto_tree_add_int(shrub, hf_val_length, tvb, n, 4, siz);
n += 4;
if (siz > 0) {
proto_tree_add_item(shrub, hf_val_data, tvb, n, siz, ENC_NA);
n += siz;
}
}
i = tvb_get_ntohs(tvb, n);
shrub = proto_tree_add_subtree_format(tree, tvb, n, 2, ett_values, NULL, "Result formats: %d", i);
n += 2;
while (i-- > 0) {
proto_tree_add_item(shrub, hf_format, tvb, n, 2, ENC_BIG_ENDIAN);
n += 2;
}
break;
/* Execute */
case 'E':
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_portal, tvb, n, siz, ENC_ASCII|ENC_NA);
n += siz;
i = tvb_get_ntohl(tvb, n);
if (i == 0)
proto_tree_add_uint_format_value(tree, hf_return, tvb, n, 4, i, "all rows");
else
proto_tree_add_uint_format_value(tree, hf_return, tvb, n, 4, i, "%d rows", i);
break;
/* Describe, Close */
case 'D':
case 'C':
c = tvb_get_guint8(tvb, n);
if (c == 'P')
i = hf_portal;
else
i = hf_statement;
n += 1;
s = tvb_get_stringz_enc(wmem_packet_scope(), tvb, n, &siz, ENC_ASCII);
proto_tree_add_string(tree, i, tvb, n, siz, s);
break;
/* Messages without a type identifier */
case '\0':
i = tvb_get_ntohl(tvb, n);
n += 4;
length -= n;
switch (i) {
/* Startup message */
case 196608:
while ((signed)length > 0) {
siz = tvb_strsize(tvb, n);
length -= siz;
if ((signed)length <= 0) {
break;
}
proto_tree_add_item(tree, hf_parameter_name, tvb, n, siz, ENC_ASCII|ENC_NA);
i = tvb_strsize(tvb, n+siz);
proto_tree_add_item(tree, hf_parameter_value, tvb, n + siz, i, ENC_ASCII|ENC_NA);
length -= i;
n += siz+i;
if (length == 1 && tvb_get_guint8(tvb, n) == 0)
break;
}
break;
/* SSL request */
case 80877103:
/* Next reply will be a single byte. */
conv_data->ssl_requested = TRUE;
break;
/* Cancellation request */
case 80877102:
proto_tree_add_item(tree, hf_pid, tvb, n, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_key, tvb, n+4, 4, ENC_BIG_ENDIAN);
break;
}
break;
/* Copy data */
case 'd':
proto_tree_add_item(tree, hf_copydata, tvb, n, length-n+1, ENC_NA);
break;
/* Copy failure */
case 'f':
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_error, tvb, n, siz, ENC_ASCII|ENC_NA);
break;
/* Function call */
case 'F':
proto_tree_add_item(tree, hf_oid, tvb, n, 4, ENC_BIG_ENDIAN);
n += 4;
i = tvb_get_ntohs(tvb, n);
shrub = proto_tree_add_subtree_format(tree, tvb, n, 2, ett_values, NULL, "Parameter formats: %d", i);
n += 2;
while (i-- > 0) {
proto_tree_add_item(shrub, hf_format, tvb, n, 2, ENC_BIG_ENDIAN);
n += 2;
}
i = tvb_get_ntohs(tvb, n);
shrub = proto_tree_add_subtree_format(tree, tvb, n, 2, ett_values, NULL, "Parameter values: %d", i);
n += 2;
while (i-- > 0) {
siz = tvb_get_ntohl(tvb, n);
proto_tree_add_item(shrub, hf_val_length, tvb, n, 4, ENC_BIG_ENDIAN);
n += 4;
if (siz > 0) {
proto_tree_add_item(shrub, hf_val_data, tvb, n, siz, ENC_NA);
n += siz;
}
}
proto_tree_add_item(tree, hf_format, tvb, n, 2, ENC_BIG_ENDIAN);
break;
}
}
static void dissect_pgsql_be_msg(guchar type, guint length, tvbuff_t *tvb,
gint n, proto_tree *tree)
{
guchar c;
gint i, siz;
char *s, *t;
proto_item *ti;
proto_tree *shrub;
switch (type) {
/* Authentication request */
case 'R':
proto_tree_add_item(tree, hf_authtype, tvb, n, 4, ENC_BIG_ENDIAN);
i = tvb_get_ntohl(tvb, n);
if (i == 4 || i == 5) {
/* i -= (6-i); :-) */
n += 4;
siz = (i == 4 ? 2 : 4);
proto_tree_add_item(tree, hf_salt, tvb, n, siz, ENC_NA);
}
break;
/* Key data */
case 'K':
proto_tree_add_item(tree, hf_pid, tvb, n, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(tree, hf_key, tvb, n+4, 4, ENC_BIG_ENDIAN);
break;
/* Parameter status */
case 'S':
s = tvb_get_stringz_enc(wmem_packet_scope(), tvb, n, &siz, ENC_ASCII);
proto_tree_add_string(tree, hf_parameter_name, tvb, n, siz, s);
n += siz;
t = tvb_get_stringz_enc(wmem_packet_scope(), tvb, n, &i, ENC_ASCII);
proto_tree_add_string(tree, hf_parameter_value, tvb, n, i, t);
break;
/* Parameter description */
case 't':
i = tvb_get_ntohs(tvb, n);
shrub = proto_tree_add_subtree_format(tree, tvb, n, 2, ett_values, NULL, "Parameters: %d", i);
n += 2;
while (i-- > 0) {
proto_tree_add_item(shrub, hf_typeoid, tvb, n, 4, ENC_BIG_ENDIAN);
n += 4;
}
break;
/* Row description */
case 'T':
i = tvb_get_ntohs(tvb, n);
ti = proto_tree_add_item(tree, hf_field_count, tvb, n, 2, ENC_BIG_ENDIAN);
shrub = proto_item_add_subtree(ti, ett_values);
n += 2;
while (i-- > 0) {
proto_tree *twig;
siz = tvb_strsize(tvb, n);
ti = proto_tree_add_item(shrub, hf_val_name, tvb, n, siz, ENC_ASCII|ENC_NA);
twig = proto_item_add_subtree(ti, ett_values);
n += siz;
proto_tree_add_item(twig, hf_tableoid, tvb, n, 4, ENC_BIG_ENDIAN);
n += 4;
proto_tree_add_item(twig, hf_val_idx, tvb, n, 2, ENC_BIG_ENDIAN);
n += 2;
proto_tree_add_item(twig, hf_typeoid, tvb, n, 4, ENC_BIG_ENDIAN);
n += 4;
proto_tree_add_item(twig, hf_val_length, tvb, n, 2, ENC_BIG_ENDIAN);
n += 2;
proto_tree_add_item(twig, hf_val_mod, tvb, n, 4, ENC_BIG_ENDIAN);
n += 4;
proto_tree_add_item(twig, hf_format, tvb, n, 2, ENC_BIG_ENDIAN);
n += 2;
}
break;
/* Data row */
case 'D':
i = tvb_get_ntohs(tvb, n);
ti = proto_tree_add_item(tree, hf_field_count, tvb, n, 2, ENC_BIG_ENDIAN);
shrub = proto_item_add_subtree(ti, ett_values);
n += 2;
while (i-- > 0) {
siz = tvb_get_ntohl(tvb, n);
proto_tree_add_int(shrub, hf_val_length, tvb, n, 4, siz);
n += 4;
if (siz > 0) {
proto_tree_add_item(shrub, hf_val_data, tvb, n, siz, ENC_NA);
n += siz;
}
}
break;
/* Command completion */
case 'C':
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_tag, tvb, n, siz, ENC_ASCII|ENC_NA);
break;
/* Ready */
case 'Z':
proto_tree_add_item(tree, hf_status, tvb, n, 1, ENC_BIG_ENDIAN);
break;
/* Error, Notice */
case 'E':
case 'N':
length -= 4;
while ((signed)length > 0) {
c = tvb_get_guint8(tvb, n);
if (c == '\0')
break;
s = tvb_get_stringz_enc(wmem_packet_scope(), tvb, n+1, &siz, ENC_ASCII);
i = hf_text;
switch (c) {
case 'S': i = hf_severity; break;
case 'C': i = hf_code; break;
case 'M': i = hf_message; break;
case 'D': i = hf_detail; break;
case 'H': i = hf_hint; break;
case 'P': i = hf_position; break;
case 'p': i = hf_internal_position; break;
case 'q': i = hf_internal_query; break;
case 'W': i = hf_where; break;
case 's': i = hf_schema_name; break;
case 't': i = hf_table_name; break;
case 'c': i = hf_column_name; break;
case 'd': i = hf_type_name; break;
case 'n': i = hf_constraint_name; break;
case 'F': i = hf_file; break;
case 'L': i = hf_line; break;
case 'R': i = hf_routine; break;
}
proto_tree_add_string(tree, i, tvb, n, siz+1, s);
length -= siz+1;
n += siz+1;
}
break;
/* NOTICE response */
case 'A':
proto_tree_add_item(tree, hf_pid, tvb, n, 4, ENC_BIG_ENDIAN);
n += 4;
siz = tvb_strsize(tvb, n);
proto_tree_add_item(tree, hf_condition, tvb, n, siz, ENC_ASCII|ENC_NA);
n += siz;
siz = tvb_strsize(tvb, n);
if (siz > 1)
proto_tree_add_item(tree, hf_text, tvb, n, siz, ENC_ASCII|ENC_NA);
break;
/* Copy in/out */
case 'G':
case 'H':
proto_tree_add_item(tree, hf_format, tvb, n, 1, ENC_BIG_ENDIAN);
n += 1;
i = tvb_get_ntohs(tvb, n);
shrub = proto_tree_add_subtree_format(tree, tvb, n, 2, ett_values, NULL, "Columns: %d", i);
n += 2;
while (i-- > 2) {
proto_tree_add_item(shrub, hf_format, tvb, n, 2, ENC_BIG_ENDIAN);
n += 2;
}
break;
/* Copy data */
case 'd':
proto_tree_add_item(tree, hf_copydata, tvb, n, length-n+1, ENC_NA);
break;
/* Function call response */
case 'V':
siz = tvb_get_ntohl(tvb, n);
proto_tree_add_int(tree, hf_val_length, tvb, n, 4, siz);
if (siz > 0)
proto_tree_add_item(tree, hf_val_data, tvb, n+4, siz, ENC_NA);
break;
}
}
/* This function is called by tcp_dissect_pdus() to find the size of the
message starting at tvb[offset]. */
static guint
pgsql_length(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_)
{
gint n = 0;
guchar type;
guint length;
/* The length is either the four bytes after the type, or, if the
type is 0, the first four bytes. */
type = tvb_get_guint8(tvb, offset);
if (type != '\0')
n = 1;
length = tvb_get_ntohl(tvb, offset+n);
return length+n;
}
/* This function is responsible for dissecting a single message. */
static int
dissect_pgsql_msg(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
{
proto_item *ti, *hidden_item;
proto_tree *ptree;
conversation_t *conversation;
pgsql_conn_data_t *conn_data;
gint n;
guchar type;
const char *typestr;
guint length;
gboolean fe = (pinfo->match_uint == pinfo->destport);
conversation = find_or_create_conversation(pinfo);
conn_data = (pgsql_conn_data_t *)conversation_get_proto_data(conversation, proto_pgsql);
if (!conn_data) {
conn_data = wmem_new(wmem_file_scope(), pgsql_conn_data_t);
conn_data->ssl_requested = FALSE;
conversation_add_proto_data(conversation, proto_pgsql, conn_data);
}
n = 0;
type = tvb_get_guint8(tvb, 0);
if (type != '\0')
n += 1;
length = tvb_get_ntohl(tvb, n);
/* This is like specifying VALS(messages) for hf_type, which we can't do
directly because of messages without type bytes, and because the type
interpretation depends on fe. */
if (fe) {
/* There are a few frontend messages that have no leading type byte.
We identify them by the fact that the first byte of their length
must be zero, and that the next four bytes are a unique tag. */
if (type == '\0') {
guint tag = tvb_get_ntohl(tvb, 4);
if (length == 16 && tag == 80877102)
typestr = "Cancel request";
else if (length == 8 && tag == 80877103)
typestr = "SSL request";
else if (tag == 196608)
typestr = "Startup message";
else
typestr = "Unknown";
} else
typestr = val_to_str_const(type, fe_messages, "Unknown");
}
else {
typestr = val_to_str_const(type, be_messages, "Unknown");
}
/* This is a terrible hack. It makes the "Info" column reflect
the contents of every message in a TCP packet. Could it be
done any better? */
col_append_fstr(pinfo->cinfo, COL_INFO, "%s%c",
( first_message ? "" : "/" ), type);
first_message = FALSE;
{
ti = proto_tree_add_item(tree, proto_pgsql, tvb, 0, -1, ENC_NA);
ptree = proto_item_add_subtree(ti, ett_pgsql);
n = 1;
if (type == '\0')
n = 0;
proto_tree_add_string(ptree, hf_type, tvb, 0, n, typestr);
proto_tree_add_item(ptree, hf_length, tvb, n, 4, ENC_BIG_ENDIAN);
hidden_item = proto_tree_add_boolean(ptree, hf_frontend, tvb, 0, 0, fe);
PROTO_ITEM_SET_HIDDEN(hidden_item);
n += 4;
if (fe)
dissect_pgsql_fe_msg(type, length, tvb, n, ptree, conn_data);
else
dissect_pgsql_be_msg(type, length, tvb, n, ptree);
}
return tvb_captured_length(tvb);
}
/* This function is called once per TCP packet. It sets COL_PROTOCOL and
* identifies FE/BE messages by adding a ">" or "<" to COL_INFO. Then it
* arranges for each message to be dissected individually. */
static int
dissect_pgsql(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
{
conversation_t *conversation;
pgsql_conn_data_t *conn_data;
first_message = TRUE;
conversation = find_or_create_conversation(pinfo);
conn_data = (pgsql_conn_data_t *)conversation_get_proto_data(conversation, proto_pgsql);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "PGSQL");
col_set_str(pinfo->cinfo, COL_INFO,
(pinfo->match_uint == pinfo->destport) ?
">" : "<");
if (conn_data && conn_data->ssl_requested) {
/* Response to SSLRequest. */
switch (tvb_get_guint8(tvb, 0)) {
case 'S': /* Willing to perform SSL */
/* Next packet will start using SSL. */
ssl_starttls_ack(ssl_handle, pinfo, pgsql_handle);
break;
case 'N': /* Unwilling to perform SSL */
default: /* ErrorMessage when server does not support SSL. */
/* TODO: maybe add expert info here? */
break;
}
conn_data->ssl_requested = FALSE;
return tvb_captured_length(tvb);
}
tcp_dissect_pdus(tvb, pinfo, tree, pgsql_desegment, 5,
pgsql_length, dissect_pgsql_msg, data);
return tvb_captured_length(tvb);
}
void
proto_register_pgsql(void)
{
static hf_register_info hf[] = {
{ &hf_frontend,
{ "Frontend", "pgsql.frontend", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
"True for messages from the frontend, false otherwise.",
HFILL }
},
{ &hf_type,
{ "Type", "pgsql.type", FT_STRING, BASE_NONE, NULL, 0,
"A one-byte message type identifier.", HFILL }
},
{ &hf_length,
{ "Length", "pgsql.length", FT_UINT32, BASE_DEC, NULL, 0,
"The length of the message (not including the type).",
HFILL }
},
{ &hf_parameter_name,
{ "Parameter name", "pgsql.parameter_name", FT_STRINGZ,
BASE_NONE, NULL, 0, "The name of a database parameter.",
HFILL }
},
{ &hf_parameter_value,
{ "Parameter value", "pgsql.parameter_value", FT_STRINGZ,
BASE_NONE, NULL, 0, "The value of a database parameter.",
HFILL }
},
{ &hf_query,
{ "Query", "pgsql.query", FT_STRINGZ, BASE_NONE, NULL, 0,
"A query string.", HFILL }
},
{ &hf_passwd,
{ "Password", "pgsql.password", FT_STRINGZ, BASE_NONE, NULL, 0,
"A password.", HFILL }
},
{ &hf_authtype,
{ "Authentication type", "pgsql.authtype", FT_INT32, BASE_DEC,
VALS(auth_types), 0,
"The type of authentication requested by the backend.", HFILL }
},
{ &hf_salt,
{ "Salt value", "pgsql.salt", FT_BYTES, BASE_NONE, NULL, 0,
"The salt to use while encrypting a password.", HFILL }
},
{ &hf_statement,
{ "Statement", "pgsql.statement", FT_STRINGZ, BASE_NONE, NULL, 0,
"The name of a prepared statement.", HFILL }
},
{ &hf_portal,
{ "Portal", "pgsql.portal", FT_STRINGZ, BASE_NONE, NULL, 0,
"The name of a portal.", HFILL }
},
{ &hf_return,
{ "Returns", "pgsql.returns", FT_UINT32, BASE_DEC,
NULL, 0,
NULL, HFILL }
},
{ &hf_tag,
{ "Tag", "pgsql.tag", FT_STRINGZ, BASE_NONE, NULL, 0,
"A completion tag.", HFILL }
},
{ &hf_status,
{ "Status", "pgsql.status", FT_UINT8, BASE_DEC, VALS(status_vals),
0, "The transaction status of the backend.", HFILL }
},
{ &hf_copydata,
{ "Copy data", "pgsql.copydata", FT_BYTES, BASE_NONE, NULL, 0,
"Data sent following a Copy-in or Copy-out response.", HFILL }
},
{ &hf_error,
{ "Error", "pgsql.error", FT_STRINGZ, BASE_NONE, NULL, 0,
"An error message.", HFILL }
},
{ &hf_pid,
{ "PID", "pgsql.pid", FT_UINT32, BASE_DEC, NULL, 0,
"The process ID of a backend.", HFILL }
},
{ &hf_key,
{ "Key", "pgsql.key", FT_UINT32, BASE_DEC, NULL, 0,
"The secret key used by a particular backend.", HFILL }
},
{ &hf_condition,
{ "Condition", "pgsql.condition", FT_STRINGZ, BASE_NONE, NULL, 0,
"The name of a NOTIFY condition.", HFILL }
},
{ &hf_text,
{ "Text", "pgsql.text", FT_STRINGZ, BASE_NONE, NULL, 0,
"Text from the backend.", HFILL }
},
{ &hf_tableoid,
{ "Table OID", "pgsql.oid.table", FT_UINT32, BASE_DEC, NULL, 0,
"The object identifier of a table.", HFILL }
},
{ &hf_typeoid,
{ "Type OID", "pgsql.oid.type", FT_UINT32, BASE_DEC, NULL, 0,
"The object identifier of a type.", HFILL }
},
{ &hf_oid,
{ "OID", "pgsql.oid", FT_UINT32, BASE_DEC, NULL, 0,
"An object identifier.", HFILL }
},
{ &hf_format,
{ "Format", "pgsql.format", FT_UINT16, BASE_DEC, VALS(format_vals),
0, "A format specifier.", HFILL }
},
{ &hf_field_count,
{ "Field count", "pgsql.field.count", FT_UINT16, BASE_DEC, NULL, 0,
"The number of fields within a row.", HFILL }
},
{ &hf_val_name,
{ "Column name", "pgsql.col.name", FT_STRINGZ, BASE_NONE, NULL, 0,
"The name of a column.", HFILL }
},
{ &hf_val_idx,
{ "Column index", "pgsql.col.index", FT_UINT32, BASE_DEC, NULL, 0,
"The position of a column within a row.", HFILL }
},
{ &hf_val_length,
{ "Column length", "pgsql.val.length", FT_INT32, BASE_DEC, NULL, 0,
"The length of a parameter value, in bytes. -1 means NULL.",
HFILL }
},
{ &hf_val_data,
{ "Data", "pgsql.val.data", FT_BYTES, BASE_NONE, NULL, 0,
"Parameter data.", HFILL }
},
{ &hf_val_mod,
{ "Type modifier", "pgsql.col.typemod", FT_INT32, BASE_DEC, NULL, 0,
"The type modifier for a column.", HFILL }
},
{ &hf_severity,
{ "Severity", "pgsql.severity", FT_STRINGZ, BASE_NONE, NULL, 0,
"Message severity.", HFILL }
},
{ &hf_code,
{ "Code", "pgsql.code", FT_STRINGZ, BASE_NONE, NULL, 0,
"SQLState code.", HFILL }
},
{ &hf_message,
{ "Message", "pgsql.message", FT_STRINGZ, BASE_NONE, NULL, 0,
"Error message.", HFILL }
},
{ &hf_detail,
{ "Detail", "pgsql.detail", FT_STRINGZ, BASE_NONE, NULL, 0,
"Detailed error message.", HFILL }
},
{ &hf_hint,
{ "Hint", "pgsql.hint", FT_STRINGZ, BASE_NONE, NULL, 0,
"A suggestion to resolve an error.", HFILL }
},
{ &hf_position,
{ "Position", "pgsql.position", FT_STRINGZ, BASE_NONE, NULL, 0,
"The index of the error within the query string.", HFILL }
},
{ &hf_internal_position,
{ "Position (Internal)", "pgsql.internal_position", FT_STRINGZ, BASE_NONE, NULL, 0,
"The index of the error within the internally-generated query string.", HFILL }
},
{ &hf_internal_query,
{ "Query (Internal)", "pgsql.internal_query", FT_STRINGZ, BASE_NONE, NULL, 0,
"The internally-generated query string", HFILL }
},
{ &hf_where,
{ "Context", "pgsql.where", FT_STRINGZ, BASE_NONE, NULL, 0,
"The context in which an error occurred.", HFILL }
},
{ &hf_schema_name,
{ "Schema", "pgsql.schema_name", FT_STRINGZ, BASE_NONE, NULL, 0,
"The schema with which an error is associated.", HFILL }
},
{ &hf_table_name,
{ "Table", "pgsql.table_name", FT_STRINGZ, BASE_NONE, NULL, 0,
"The table with which an error is associated.", HFILL }
},
{ &hf_column_name,
{ "Column", "pgsql.column_name", FT_STRINGZ, BASE_NONE, NULL, 0,
"The column with which an error is associated.", HFILL }
},
{ &hf_type_name,
{ "Type", "pgsql.type_name", FT_STRINGZ, BASE_NONE, NULL, 0,
"The date type with which an error is associated.", HFILL }
},
{ &hf_constraint_name,
{ "Constraint", "pgsql.constraint_name", FT_STRINGZ, BASE_NONE, NULL, 0,
"The constraint with which an error is associated.", HFILL }
},
{ &hf_file,
{ "File", "pgsql.file", FT_STRINGZ, BASE_NONE, NULL, 0,
"The source-code file where an error was reported.", HFILL }
},
{ &hf_line,
{ "Line", "pgsql.line", FT_STRINGZ, BASE_NONE, NULL, 0,
"The line number on which an error was reported.", HFILL }
},
{ &hf_routine,
{ "Routine", "pgsql.routine", FT_STRINGZ, BASE_NONE, NULL, 0,
"The routine that reported an error.", HFILL }
}
};
static gint *ett[] = {
&ett_pgsql,
&ett_values
};
module_t *mod_pgsql;
proto_pgsql = proto_register_protocol("PostgreSQL", "PGSQL", "pgsql");
proto_register_field_array(proto_pgsql, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
mod_pgsql = prefs_register_protocol(proto_pgsql, proto_reg_handoff_pgsql);
prefs_register_uint_preference(
mod_pgsql, "tcp.port", "PGSQL TCP port", "Set the port for PGSQL "
"messages (if different from the default of 5432)", 10, &pgsql_port
);
}
void
proto_reg_handoff_pgsql(void)
{
static gboolean initialized = FALSE;
static guint saved_pgsql_port;
if (!initialized) {
pgsql_handle = new_create_dissector_handle(dissect_pgsql, proto_pgsql);
initialized = TRUE;
} else {
dissector_delete_uint("tcp.port", saved_pgsql_port, pgsql_handle);
}
dissector_add_uint("tcp.port", pgsql_port, pgsql_handle);
saved_pgsql_port = pgsql_port;
ssl_handle = find_dissector("ssl");
}
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 4
* tab-width: 8
* indent-tabs-mode: nil
* End:
*
* vi: set shiftwidth=4 tabstop=8 expandtab:
* :indentSize=4:tabSize=8:noTabs=true:
*/
| 33.197637 | 109 | 0.555117 | [
"object"
] |
344054b00d9418006e2aea8449b00d9c207b9030 | 9,800 | c | C | src/glibc-2.23/nis/nis_print.c | wwkenwong/piecewise | 2cecb3f67fd2e1cd5b67102d49f9e16cf9a2e52f | [
"BSD-3-Clause-Clear"
] | 12 | 2018-09-18T19:51:27.000Z | 2022-01-18T15:31:41.000Z | src/glibc-2.23/nis/nis_print.c | wwkenwong/piecewise | 2cecb3f67fd2e1cd5b67102d49f9e16cf9a2e52f | [
"BSD-3-Clause-Clear"
] | null | null | null | src/glibc-2.23/nis/nis_print.c | wwkenwong/piecewise | 2cecb3f67fd2e1cd5b67102d49f9e16cf9a2e52f | [
"BSD-3-Clause-Clear"
] | 3 | 2019-06-12T19:38:54.000Z | 2020-03-05T19:17:23.000Z | /* Copyright (c) 1997-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
#include <time.h>
#include <string.h>
#include <libintl.h>
#include <stdint.h>
#include <rpcsvc/nis.h>
static const char *
nis_nstype2str (const nstype type)
{
/* Name service names mustn't be translated, only UNKNOWN needs it */
switch (type)
{
case NIS:
return "NIS";
case SUNYP:
return "SUNYP";
case IVY:
return "IVY";
case DNS:
return "DNS";
case X500:
return "X500";
case DNANS:
return "DNANS";
case XCHS:
return "XCHS";
case CDS:
return "CDS";
default:
return N_("UNKNOWN");
}
}
static void
print_ttl (const uint32_t ttl)
{
uint32_t time, s, m, h;
time = ttl;
h = time / (60 * 60);
time %= (60 * 60);
m = time / 60;
time %= 60;
s = time;
printf ("%u:%u:%u\n", h, m, s);
}
static void
print_flags (const unsigned int flags)
{
fputs ("(", stdout);
if (flags & TA_SEARCHABLE)
fputs ("SEARCHABLE, ", stdout);
if (flags & TA_BINARY)
{
fputs ("BINARY DATA", stdout);
if (flags & TA_XDR)
fputs (", XDR ENCODED", stdout);
if (flags & TA_ASN1)
fputs (", ASN.1 ENCODED", stdout);
if (flags & TA_CRYPT)
fputs (", ENCRYPTED", stdout);
}
else
{
fputs ("TEXTUAL DATA", stdout);
if (flags & TA_SEARCHABLE)
{
if (flags & TA_CASE)
fputs (", CASE INSENSITIVE", stdout);
else
fputs (", CASE SENSITIVE", stdout);
}
}
fputs (")\n", stdout);
}
static void
nis_print_objtype (enum zotypes type)
{
switch (type)
{
case NIS_BOGUS_OBJ:
fputs (_("BOGUS OBJECT\n"), stdout);
break;
case NIS_NO_OBJ:
fputs (_("NO OBJECT\n"), stdout);
break;
case NIS_DIRECTORY_OBJ:
fputs (_("DIRECTORY\n"), stdout);
break;
case NIS_GROUP_OBJ:
fputs (_("GROUP\n"), stdout);
break;
case NIS_TABLE_OBJ:
fputs (_("TABLE\n"), stdout);
break;
case NIS_ENTRY_OBJ:
fputs (_("ENTRY\n"), stdout);
break;
case NIS_LINK_OBJ:
fputs (_("LINK\n"), stdout);
break;
case NIS_PRIVATE_OBJ:
fputs (_("PRIVATE\n"), stdout);
break;
default:
fputs (_("(Unknown object)\n"), stdout);
break;
}
}
void
nis_print_rights (const unsigned int access)
{
char result[17];
unsigned int acc;
int i;
acc = access; /* Parameter is const ! */
result[i = 16] = '\0';
while (i > 0)
{
i -= 4;
result[i + 0] = (acc & NIS_READ_ACC) ? 'r' : '-';
result[i + 1] = (acc & NIS_MODIFY_ACC) ? 'm' : '-';
result[i + 2] = (acc & NIS_CREATE_ACC) ? 'c' : '-';
result[i + 3] = (acc & NIS_DESTROY_ACC) ? 'd' : '-';
acc >>= 8;
}
fputs (result, stdout);
}
libnsl_hidden_def (nis_print_rights)
void
nis_print_directory (const directory_obj *dir)
{
nis_server *sptr;
unsigned int i;
printf (_("Name : `%s'\n"), dir->do_name);
printf (_("Type : %s\n"), nis_nstype2str (dir->do_type));
sptr = dir->do_servers.do_servers_val;
for (i = 0; i < dir->do_servers.do_servers_len; i++)
{
if (i == 0)
fputs (_("Master Server :\n"), stdout);
else
fputs (_("Replicate :\n"), stdout);
printf (_("\tName : %s\n"), sptr->name);
fputs (_("\tPublic Key : "), stdout);
switch (sptr->key_type)
{
case NIS_PK_NONE:
fputs (_("None.\n"), stdout);
break;
case NIS_PK_DH:
printf (_("Diffie-Hellmann (%d bits)\n"),
(sptr->pkey.n_len - 1) * 4);
/* sptr->pkey.n_len counts the last 0, too */
break;
case NIS_PK_RSA:
printf (_("RSA (%d bits)\n"), (sptr->pkey.n_len - 1) * 4);
break;
case NIS_PK_KERB:
fputs (_("Kerberos.\n"), stdout);
break;
default:
printf (_("Unknown (type = %d, bits = %d)\n"), sptr->key_type,
(sptr->pkey.n_len - 1) * 4);
break;
}
if (sptr->ep.ep_len != 0)
{
unsigned int j;
endpoint *ptr;
ptr = sptr->ep.ep_val;
printf (_("\tUniversal addresses (%u)\n"), sptr->ep.ep_len);
for (j = 0; j < sptr->ep.ep_len; j++)
{
printf ("\t[%d] - ", j + 1);
if (ptr->proto != NULL && ptr->proto[0] != '\0')
printf ("%s, ", ptr->proto);
else
printf ("-, ");
if (ptr->family != NULL && ptr->family[0] != '\0')
printf ("%s, ", ptr->family);
else
printf ("-, ");
if (ptr->uaddr != NULL && ptr->uaddr[0] != '\0')
printf ("%s\n", ptr->uaddr);
else
fputs ("-\n", stdout);
ptr++;
}
}
sptr++;
}
fputs (_("Time to live : "), stdout);
print_ttl (dir->do_ttl);
fputs (_("Default Access rights :\n"), stdout);
if (dir->do_armask.do_armask_len != 0)
{
oar_mask *ptr;
ptr = dir->do_armask.do_armask_val;
for (i = 0; i < dir->do_armask.do_armask_len; i++)
{
nis_print_rights (ptr->oa_rights);
printf (_("\tType : %s\n"), nis_nstype2str (ptr->oa_otype));
fputs (_("\tAccess rights: "), stdout);
nis_print_rights (ptr->oa_rights);
fputs ("\n", stdout);
ptr++;
}
}
}
libnsl_hidden_def (nis_print_directory)
void
nis_print_group (const group_obj *obj)
{
unsigned int i;
fputs (_("Group Flags :"), stdout);
if (obj->gr_flags)
printf ("0x%08X", obj->gr_flags);
fputs (_("\nGroup Members :\n"), stdout);
for (i = 0; i < obj->gr_members.gr_members_len; i++)
printf ("\t%s\n", obj->gr_members.gr_members_val[i]);
}
libnsl_hidden_def (nis_print_group)
void
nis_print_table (const table_obj *obj)
{
unsigned int i;
printf (_("Table Type : %s\n"), obj->ta_type);
printf (_("Number of Columns : %d\n"), obj->ta_maxcol);
printf (_("Character Separator : %c\n"), obj->ta_sep);
printf (_("Search Path : %s\n"), obj->ta_path);
fputs (_("Columns :\n"), stdout);
for (i = 0; i < obj->ta_cols.ta_cols_len; i++)
{
printf (_("\t[%d]\tName : %s\n"), i,
obj->ta_cols.ta_cols_val[i].tc_name);
fputs (_("\t\tAttributes : "), stdout);
print_flags (obj->ta_cols.ta_cols_val[i].tc_flags);
fputs (_("\t\tAccess Rights : "), stdout);
nis_print_rights (obj->ta_cols.ta_cols_val[i].tc_rights);
fputc ('\n', stdout);
}
}
libnsl_hidden_def (nis_print_table)
void
nis_print_link (const link_obj *obj)
{
fputs (_("Linked Object Type : "), stdout);
nis_print_objtype (obj->li_rtype);
printf (_("Linked to : %s\n"), obj->li_name);
/* XXX Print the attributes here, if they exists */
}
libnsl_hidden_def (nis_print_link)
void
nis_print_entry (const entry_obj *obj)
{
unsigned int i;
printf (_("\tEntry data of type %s\n"), obj->en_type);
for (i = 0; i < obj->en_cols.en_cols_len; i++)
{
printf (_("\t[%u] - [%u bytes] "), i,
obj->en_cols.en_cols_val[i].ec_value.ec_value_len);
if ((obj->en_cols.en_cols_val[i].ec_flags & EN_CRYPT) == EN_CRYPT)
fputs (_("Encrypted data\n"), stdout);
else if ((obj->en_cols.en_cols_val[i].ec_flags & EN_BINARY) == EN_BINARY)
fputs (_("Binary data\n"), stdout);
else if (obj->en_cols.en_cols_val[i].ec_value.ec_value_len == 0)
fputs ("'(nil)'\n", stdout);
else
printf ("'%.*s'\n",
(int)obj->en_cols.en_cols_val[i].ec_value.ec_value_len,
obj->en_cols.en_cols_val[i].ec_value.ec_value_val);
}
}
libnsl_hidden_def (nis_print_entry)
void
nis_print_object (const nis_object * obj)
{
time_t buf;
printf (_("Object Name : %s\n"), obj->zo_name);
printf (_("Directory : %s\n"), obj->zo_domain);
printf (_("Owner : %s\n"), obj->zo_owner);
printf (_("Group : %s\n"), obj->zo_group);
fputs (_("Access Rights : "), stdout);
nis_print_rights (obj->zo_access);
printf (_("\nTime to Live : "));
print_ttl (obj->zo_ttl);
buf = obj->zo_oid.ctime;
printf (_("Creation Time : %s"), ctime (&buf));
buf = obj->zo_oid.mtime;
printf (_("Mod. Time : %s"), ctime (&buf));
fputs (_("Object Type : "), stdout);
nis_print_objtype (obj->zo_data.zo_type);
switch (obj->zo_data.zo_type)
{
case NIS_DIRECTORY_OBJ:
nis_print_directory (&obj->zo_data.objdata_u.di_data);
break;
case NIS_GROUP_OBJ:
nis_print_group (&obj->zo_data.objdata_u.gr_data);
break;
case NIS_TABLE_OBJ:
nis_print_table (&obj->zo_data.objdata_u.ta_data);
break;
case NIS_ENTRY_OBJ:
nis_print_entry (&obj->zo_data.objdata_u.en_data);
break;
case NIS_LINK_OBJ:
nis_print_link (&obj->zo_data.objdata_u.li_data);
break;
case NIS_PRIVATE_OBJ:
printf (_(" Data Length = %u\n"),
obj->zo_data.objdata_u.po_data.po_data_len);
break;
default:
break;
}
}
libnsl_hidden_def (nis_print_object)
void
nis_print_result (const nis_result *res)
{
unsigned int i;
printf (_("Status : %s\n"), nis_sperrno (NIS_RES_STATUS (res)));
printf (_("Number of objects : %u\n"), res->objects.objects_len);
for (i = 0; i < res->objects.objects_len; i++)
{
printf (_("Object #%d:\n"), i);
nis_print_object (&res->objects.objects_val[i]);
}
}
| 25.721785 | 79 | 0.594592 | [
"object"
] |
3443deeb6cbc954270c7040b087583bd0763e70c | 17,455 | h | C | TVTest_0.7.23_Src/ProgramGuide.h | mark10als/TVTest_0.7.23_fix_Sources | 313c295ab67a39bb285303ad814ee4f5aa15d921 | [
"libpng-2.0"
] | null | null | null | TVTest_0.7.23_Src/ProgramGuide.h | mark10als/TVTest_0.7.23_fix_Sources | 313c295ab67a39bb285303ad814ee4f5aa15d921 | [
"libpng-2.0"
] | null | null | null | TVTest_0.7.23_Src/ProgramGuide.h | mark10als/TVTest_0.7.23_fix_Sources | 313c295ab67a39bb285303ad814ee4f5aa15d921 | [
"libpng-2.0"
] | null | null | null | #ifndef PROGRAM_GUIDE_H
#define PROGRAM_GUIDE_H
#include "View.h"
#include "EpgProgramList.h"
#include "EpgUtil.h"
#include "ChannelList.h"
#include "DriverManager.h"
#include "Theme.h"
#include "DrawUtil.h"
#include "ProgramSearch.h"
#include "EventInfoPopup.h"
#include "Tooltip.h"
#include "StatusView.h"
namespace ProgramGuide
{
class CEventItem;
class CEventLayout;
class CServiceInfo;
class CEventLayoutList
{
std::vector<CEventLayout*> m_LayoutList;
public:
~CEventLayoutList();
void Clear();
size_t Length() const { return m_LayoutList.size(); }
void Add(CEventLayout *pLayout);
const CEventLayout *operator[](size_t Index) const;
};
class CServiceList
{
std::vector<CServiceInfo*> m_ServiceList;
public:
~CServiceList();
size_t NumServices() const { return m_ServiceList.size(); }
CServiceInfo *GetItem(size_t Index);
const CServiceInfo *GetItem(size_t Index) const;
CServiceInfo *FindItem(WORD TransportStreamID,WORD ServiceID);
const CServiceInfo *FindItem(WORD TransportStreamID,WORD ServiceID) const;
CEventInfoData *FindEvent(WORD TransportStreamID,WORD ServiceID,WORD EventID);
const CEventInfoData *FindEvent(WORD TransportStreamID,WORD ServiceID,WORD EventID) const;
void Add(CServiceInfo *pInfo);
void Clear();
};
}
class CProgramGuideTool
{
public:
enum { MAX_NAME=64, MAX_COMMAND=MAX_PATH*2 };
private:
TCHAR m_szName[MAX_NAME];
TCHAR m_szCommand[MAX_COMMAND];
HICON m_hIcon;
static bool GetCommandFileName(LPCTSTR *ppszCommand,LPTSTR pszFileName,int MaxFileName);
static CProgramGuideTool *GetThis(HWND hDlg);
static INT_PTR CALLBACK DlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam);
public:
CProgramGuideTool();
CProgramGuideTool(const CProgramGuideTool &Tool);
CProgramGuideTool(LPCTSTR pszName,LPCTSTR pszCommand);
~CProgramGuideTool();
CProgramGuideTool &operator=(const CProgramGuideTool &Tool);
LPCTSTR GetName() const { return m_szName; }
LPCTSTR GetCommand() const { return m_szCommand; }
bool GetPath(LPTSTR pszPath,int MaxLength) const;
HICON GetIcon();
bool Execute(const ProgramGuide::CServiceInfo *pServiceInfo,
const CEventInfoData *pEventInfo,HWND hwnd);
bool ShowDialog(HWND hwndOwner);
};
class CProgramGuideToolList
{
std::vector<CProgramGuideTool*> m_ToolList;
public:
CProgramGuideToolList();
CProgramGuideToolList(const CProgramGuideToolList &Src);
~CProgramGuideToolList();
CProgramGuideToolList &operator=(const CProgramGuideToolList &Src);
void Clear();
bool Add(CProgramGuideTool *pTool);
CProgramGuideTool *GetTool(size_t Index);
const CProgramGuideTool *GetTool(size_t Index) const;
size_t NumTools() const { return m_ToolList.size(); }
};
class CProgramGuide : public CCustomWindow, protected CDoubleBufferingDraw
{
public:
enum ListMode {
LIST_SERVICES,
LIST_WEEK
};
enum {
DAY_TODAY,
DAY_TOMORROW,
DAY_DAYAFTERTOMORROW,
DAY_2DAYSAFTERTOMORROW,
DAY_3DAYSAFTERTOMORROW,
DAY_4DAYSAFTERTOMORROW,
DAY_5DAYSAFTERTOMORROW,
DAY_LAST=DAY_5DAYSAFTERTOMORROW
};
enum {
COLOR_BACK,
COLOR_TEXT,
COLOR_CHANNELNAMETEXT,
COLOR_CURCHANNELNAMETEXT,
COLOR_TIMETEXT,
COLOR_TIMELINE,
COLOR_CURTIMELINE,
COLOR_CONTENT_NEWS,
COLOR_CONTENT_SPORTS,
COLOR_CONTENT_INFORMATION,
COLOR_CONTENT_DRAMA,
COLOR_CONTENT_MUSIC,
COLOR_CONTENT_VARIETY,
COLOR_CONTENT_MOVIE,
COLOR_CONTENT_ANIME,
COLOR_CONTENT_DOCUMENTARY,
COLOR_CONTENT_THEATER,
COLOR_CONTENT_EDUCATION,
COLOR_CONTENT_WELFARE,
COLOR_CONTENT_OTHER,
COLOR_CONTENT_FIRST=COLOR_CONTENT_NEWS,
COLOR_CONTENT_LAST=COLOR_CONTENT_OTHER,
COLOR_LAST=COLOR_CONTENT_LAST,
NUM_COLORS=COLOR_LAST+1
};
enum { MIN_LINES_PER_HOUR=8, MAX_LINES_PER_HOUR=60 };
enum { MIN_ITEM_WIDTH=100, MAX_ITEM_WIDTH=500 };
enum { TIME_BAR_BACK_COLORS=8 };
enum {
FILTER_FREE =0x00000001U,
FILTER_NEWPROGRAM =0x00000002U,
FILTER_ORIGINAL =0x00000004U,
FILTER_RERUN =0x00000008U,
FILTER_NOT_SHOPPING =0x00000010U,
FILTER_GENRE_FIRST =0x00000100U,
FILTER_GENRE_MASK =0x000FFF00U,
FILTER_NEWS =0x00000100U,
FILTER_SPORTS =0x00000200U,
FILTER_INFORMATION =0x00000400U,
FILTER_DRAMA =0x00000800U,
FILTER_MUSIC =0x00001000U,
FILTER_VARIETY =0x00002000U,
FILTER_MOVIE =0x00004000U,
FILTER_ANIME =0x00008000U,
FILTER_DOCUMENTARY =0x00010000U,
FILTER_THEATER =0x00020000U,
FILTER_EDUCATION =0x00040000U,
FILTER_WELFARE =0x00080000U
};
struct ServiceInfo
{
WORD NetworkID;
WORD TransportStreamID;
WORD ServiceID;
ServiceInfo() { Clear(); }
ServiceInfo(WORD NID,WORD TSID,WORD SID)
: NetworkID(NID), TransportStreamID(TSID), ServiceID(SID) {}
void Clear() {
NetworkID=0;
TransportStreamID=0;
ServiceID=0;
}
};
typedef std::vector<ServiceInfo> ServiceInfoList;
class ABSTRACT_CLASS(CFrame)
{
protected:
CProgramGuide *m_pProgramGuide;
public:
CFrame();
virtual ~CFrame() = 0;
virtual void SetCaption(LPCTSTR pszCaption) {}
virtual void OnDateChanged() {}
virtual void OnSpaceChanged() {}
virtual void OnListModeChanged() {}
virtual void OnTimeRangeChanged() {}
virtual bool SetAlwaysOnTop(bool fTop) { return false; }
virtual bool GetAlwaysOnTop() const { return false; }
friend class CProgramGuide;
};
class ABSTRACT_CLASS(CEventHandler)
{
protected:
class CProgramGuide *m_pProgramGuide;
public:
CEventHandler();
virtual ~CEventHandler();
virtual bool OnClose() { return true; }
virtual void OnDestroy() {}
virtual void OnServiceTitleLButtonDown(LPCTSTR pszDriverFileName,const CServiceInfoData *pServiceInfo) {}
virtual bool OnBeginUpdate() { return true; }
virtual void OnEndUpdate() {}
virtual bool OnRefresh() { return true; }
virtual bool OnKeyDown(UINT KeyCode,UINT Flags) { return false; }
virtual bool OnMenuInitialize(HMENU hmenu,UINT CommandBase) { return false; }
virtual bool OnMenuSelected(UINT Command) { return false; }
friend class CProgramGuide;
};
class ABSTRACT_CLASS(CProgramCustomizer)
{
protected:
class CProgramGuide *m_pProgramGuide;
public:
CProgramCustomizer();
virtual ~CProgramCustomizer();
virtual bool Initialize() { return true; }
virtual void Finalize() {}
virtual bool DrawBackground(const CEventInfoData &Event,HDC hdc,
const RECT &ItemRect,const RECT &TitleRect,const RECT &ContentRect,
COLORREF BackgroundColor) { return false; }
virtual bool InitializeMenu(const CEventInfoData &Event,HMENU hmenu,UINT CommandBase,
const POINT &CursorPos,const RECT &ItemRect) { return false; }
virtual bool ProcessMenu(const CEventInfoData &Event,UINT Command) { return false; }
virtual bool OnLButtonDoubleClick(const CEventInfoData &Event,
const POINT &CursorPos,const RECT &ItemRect) { return false; }
friend class CProgramGuide;
};
static bool Initialize(HINSTANCE hinst);
CProgramGuide();
~CProgramGuide();
// CBasicWindow
bool Create(HWND hwndParent,DWORD Style,DWORD ExStyle=0,int ID=0) override;
// CProgramGuide
bool SetEpgProgramList(CEpgProgramList *pList);
void Clear();
bool UpdateProgramGuide(bool fUpdateList=false);
bool SetTuningSpaceList(LPCTSTR pszDriverFileName,const CTuningSpaceList *pList,int Space);
const CChannelList *GetChannelList() const { return &m_ChannelList; }
const ProgramGuide::CServiceList &GetServiceList() const { return m_ServiceList; }
bool UpdateChannelList();
bool SetDriverList(const CDriverManager *pDriverManager);
void SetCurrentService(WORD NetworkID,WORD TSID,WORD ServiceID);
void ClearCurrentService() { SetCurrentService(0,0,0); }
int GetCurrentTuningSpace() const { return m_CurrentTuningSpace; }
bool GetTuningSpaceName(int Space,LPTSTR pszName,int MaxName) const;
bool EnumDriver(int *pIndex,LPTSTR pszName,int MaxName) const;
bool GetExcludeNoEventServices() const { return m_fExcludeNoEventServices; }
bool SetExcludeNoEventServices(bool fExclude);
bool SetExcludeServiceList(const ServiceInfoList &List);
bool GetExcludeServiceList(ServiceInfoList *pList) const;
bool IsExcludeService(WORD NetworkID,WORD TransportStreamID,WORD ServiceID) const;
bool SetExcludeService(WORD NetworkID,WORD TransportStreamID,WORD ServiceID,bool fExclude);
ListMode GetListMode() const { return m_ListMode; }
bool SetServiceListMode();
bool SetWeekListMode(int Service);
int GetWeekListService() const { return m_WeekListService; }
bool SetBeginHour(int Hour);
bool SetTimeRange(const SYSTEMTIME *pFirstTime,const SYSTEMTIME *pLastTime);
bool GetTimeRange(SYSTEMTIME *pFirstTime,SYSTEMTIME *pLastTime) const;
bool GetCurrentTimeRange(SYSTEMTIME *pFirstTime,SYSTEMTIME *pLastTime) const;
bool GetDayTimeRange(int Day,SYSTEMTIME *pFirstTime,SYSTEMTIME *pLastTime) const;
bool SetViewDay(int Day);
int GetViewDay() const { return m_Day; }
int GetLinesPerHour() const { return m_LinesPerHour; }
int GetItemWidth() const { return m_ItemWidth; }
bool SetUIOptions(int LinesPerHour,int ItemWidth,int LineMargin);
bool SetColor(int Type,COLORREF Color);
void SetBackColors(const Theme::GradientInfo *pChannelBackGradient,
const Theme::GradientInfo *pCurChannelBackGradient,
const Theme::GradientInfo *pTimeBarMarginGradient,
const Theme::GradientInfo *pTimeBarBackGradient);
bool SetFont(const LOGFONT *pFont);
bool GetFont(LOGFONT *pFont) const;
bool SetEventInfoFont(const LOGFONT *pFont);
bool SetShowToolTip(bool fShow);
bool GetShowToolTip() const { return m_fShowToolTip; }
void SetEventHandler(CEventHandler *pEventHandler);
void SetFrame(CFrame *pFrame);
void SetProgramCustomizer(CProgramCustomizer *pProgramCustomizer);
CProgramGuideToolList *GetToolList() { return &m_ToolList; }
int GetWheelScrollLines() const { return m_WheelScrollLines; }
void SetWheelScrollLines(int Lines) { m_WheelScrollLines=Lines; }
bool GetDragScroll() const { return m_fDragScroll; }
bool SetDragScroll(bool fDragScroll);
bool SetFilter(unsigned int Filter);
unsigned int GetFilter() const { return m_Filter; }
void SetVisibleEventIcons(UINT VisibleIcons);
UINT GetVisibleEventIcons() const { return m_VisibleEventIcons; }
CProgramSearch *GetProgramSearch() { return &m_ProgramSearch; }
void GetInfoPopupSize(int *pWidth,int *pHeight) { m_EventInfoPopup.GetSize(pWidth,pHeight); }
bool SetInfoPopupSize(int Width,int Height) { return m_EventInfoPopup.SetSize(Width,Height); }
bool OnClose();
private:
CEpgProgramList *m_pProgramList;
ProgramGuide::CServiceList m_ServiceList;
ProgramGuide::CEventLayoutList m_EventLayoutList;
ListMode m_ListMode;
int m_WeekListService;
int m_LinesPerHour;
DrawUtil::CFont m_Font;
DrawUtil::CFont m_TitleFont;
DrawUtil::CFont m_TimeFont;
int m_FontHeight;
int m_LineMargin;
int m_ItemWidth;
int m_ItemMargin;
int m_TextLeftMargin;
int m_HeaderHeight;
int m_TimeBarWidth;
POINT m_ScrollPos;
POINT m_OldScrollPos;
bool m_fDragScroll;
HCURSOR m_hDragCursor1;
HCURSOR m_hDragCursor2;
struct {
POINT StartCursorPos;
POINT StartScrollPos;
} m_DragInfo;
DrawUtil::CMonoColorBitmap m_Chevron;
CEpgIcons m_EpgIcons;
UINT m_VisibleEventIcons;
bool m_fBarShadow;
CEventInfoPopup m_EventInfoPopup;
CEventInfoPopupManager m_EventInfoPopupManager;
class CEventInfoPopupHandler : public CEventInfoPopupManager::CEventHandler
, public CEventInfoPopup::CEventHandler
{
CProgramGuide *m_pProgramGuide;
// CEventInfoPopupManager::CEventHandler
bool HitTest(int x,int y,LPARAM *pParam);
bool GetEventInfo(LPARAM Param,const CEventInfoData **ppInfo);
bool OnShow(const CEventInfoData *pInfo);
// CEventInfoPopup::CEventHandler
bool OnMenuPopup(HMENU hmenu);
void OnMenuSelected(int Command);
public:
CEventInfoPopupHandler(CProgramGuide *pProgramGuide);
};
friend CEventInfoPopupHandler;
CEventInfoPopupHandler m_EventInfoPopupHandler;
bool m_fShowToolTip;
CTooltip m_Tooltip;
CChannelList m_ChannelList;
CTuningSpaceList m_TuningSpaceList;
int m_CurrentTuningSpace;
ServiceInfo m_CurrentChannel;
bool m_fExcludeNoEventServices;
ServiceInfoList m_ExcludeServiceList;
TCHAR m_szDriverFileName[MAX_PATH];
const CDriverManager *m_pDriverManager;
int m_BeginHour;
SYSTEMTIME m_stFirstTime;
SYSTEMTIME m_stLastTime;
SYSTEMTIME m_stCurTime;
int m_Day;
int m_Hours;
struct {
bool fValid;
int ListIndex;
int EventIndex;
} m_CurItem;
bool m_fUpdating;
CEventHandler *m_pEventHandler;
CFrame *m_pFrame;
CProgramCustomizer *m_pProgramCustomizer;
COLORREF m_ColorList[NUM_COLORS];
Theme::GradientInfo m_ChannelNameBackGradient;
Theme::GradientInfo m_CurChannelNameBackGradient;
Theme::GradientInfo m_TimeBarMarginGradient;
Theme::GradientInfo m_TimeBarBackGradient[TIME_BAR_BACK_COLORS];
CProgramGuideToolList m_ToolList;
int m_WheelScrollLines;
unsigned int m_Filter;
CProgramSearch m_ProgramSearch;
class CProgramSearchEventHandler : public CProgramSearch::CEventHandler {
CProgramGuide *m_pProgramGuide;
public:
CProgramSearchEventHandler(CProgramGuide *pProgramGuide);
bool Search(LPCTSTR pszKeyword);
};
friend CProgramSearchEventHandler;
CProgramSearchEventHandler m_ProgramSearchEventHandler;
static const LPCTSTR m_pszWindowClass;
static HINSTANCE m_hinst;
bool UpdateList(bool fUpdateList=false);
bool UpdateService(ProgramGuide::CServiceInfo *pService,bool fUpdateEpg);
bool SetTuningSpace(int Space);
void CalcLayout();
void DrawEventList(const ProgramGuide::CEventLayout *pLayout,
HDC hdc,const RECT &Rect,const RECT &PaintRect) const;
void DrawHeaderBackground(HDC hdc,const RECT &Rect,bool fCur) const;
void DrawServiceHeader(ProgramGuide::CServiceInfo *pServiceInfo,
HDC hdc,const RECT &Rect,int Chevron,
bool fLeftAlign=false);
void DrawDayHeader(int Day,HDC hdc,const RECT &Rect) const;
void DrawTimeBar(HDC hdc,const RECT &Rect,bool fRight);
void Draw(HDC hdc,const RECT &PaintRect);
int GetCurTimeLinePos() const;
void GetProgramGuideRect(RECT *pRect) const;
void Scroll(int XOffset,int YOffset);
void SetScrollBar();
void SetCaption();
void SetTooltip();
bool EventHitTest(int x,int y,int *pListIndex,int *pEventIndex,RECT *pItemRect=NULL) const;
void OnCommand(int id);
// CCustomWindow
LRESULT OnMessage(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam) override;
};
class CCalendarBar : public CBasicWindow
{
bool m_fUseBufferedPaint;
CBufferedPaint m_BufferedPaint;
public:
CCalendarBar();
~CCalendarBar();
bool Create(HWND hwndParent,DWORD Style,DWORD ExStyle=0,int ID=0);
void EnableBufferedPaint(bool fEnable) { m_fUseBufferedPaint=fEnable; }
bool SetButtons(const SYSTEMTIME *pDateList,int Days,int FirstCommand);
void SelectButton(int Button);
void UnselectButton();
void GetBarSize(SIZE *pSize);
bool OnNotify(LPARAM lParam,LRESULT *pResult);
};
class ABSTRACT_CLASS(CProgramGuideFrameBase) : public CProgramGuide::CFrame
{
public:
CProgramGuideFrameBase(CProgramGuide *pProgramGuide);
virtual ~CProgramGuideFrameBase() = 0;
void SetStatusTheme(const CStatusView::ThemeInfo *pTheme);
protected:
CProgramGuide *m_pProgramGuide;
CStatusView m_StatusView[2];
CCalendarBar m_CalendarBar;
RECT m_StatusMargin;
int m_StatusItemMargin;
// CProgramGuide::CFrame
void OnDateChanged() override;
void OnSpaceChanged() override;
void OnListModeChanged() override;
void OnTimeRangeChanged() override;
LRESULT DefaultMessageHandler(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam);
void OnWindowCreate(HWND hwnd,bool fBufferedPaint);
void OnWindowDestroy();
void OnSizeChanged(int Width,int Height);
};
class CProgramGuideFrame : public CProgramGuideFrameBase, public CCustomWindow
{
public:
static bool Initialize(HINSTANCE hinst);
CProgramGuideFrame(CProgramGuide *pProgramGuide);
~CProgramGuideFrame();
CProgramGuide *GetProgramGuide() { return m_pProgramGuide; }
// CBasicWindow
bool Create(HWND hwndParent,DWORD Style,DWORD ExStyle=0,int ID=0) override;
// CProgramGuide::CFrame
bool SetAlwaysOnTop(bool fTop) override;
bool GetAlwaysOnTop() const override { return m_fAlwaysOnTop; }
private:
CAeroGlass m_AeroGlass;
bool m_fAlwaysOnTop;
// CProgramGuide::CFrame
void SetCaption(LPCTSTR pszCaption) override;
// CCustomWindow
LRESULT OnMessage(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam) override;
static const LPCTSTR m_pszWindowClass;
static HINSTANCE m_hinst;
};
class CProgramGuideDisplay : public CProgramGuideFrameBase, public CDisplayView
{
public:
class ABSTRACT_CLASS(CEventHandler) {
protected:
class CProgramGuideDisplay *m_pProgramGuideDisplay;
public:
CEventHandler();
virtual ~CEventHandler() = 0;
virtual bool OnHide() { return true; }
virtual bool SetAlwaysOnTop(bool fTop) = 0;
virtual bool GetAlwaysOnTop() const = 0;
virtual void OnRButtonDown(int x,int y) {}
virtual void OnLButtonDoubleClick(int x,int y) {}
friend class CProgramGuideDisplay;
};
static bool Initialize(HINSTANCE hinst);
CProgramGuideDisplay(CProgramGuide *pProgramGuide);
~CProgramGuideDisplay();
// CBasicWindow
bool Create(HWND hwndParent,DWORD Style,DWORD ExStyle=0,int ID=0) override;
// CProgramGuideDisplay
void SetEventHandler(CEventHandler *pHandler);
private:
CEventHandler *m_pEventHandler;
static const LPCTSTR m_pszWindowClass;
static HINSTANCE m_hinst;
// CDisplayView
bool OnVisibleChange(bool fVisible) override;
// CProgramGuide::CFrame
bool SetAlwaysOnTop(bool fTop) override;
bool GetAlwaysOnTop() const override;
// CCustomWindow
LRESULT OnMessage(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam) override;
};
#endif
| 31.678766 | 107 | 0.789115 | [
"vector"
] |
34467f08e5840bb7ced2d3a17f12cae137b96cb9 | 34,901 | h | C | src/common/Coordinate.h | dtip/magics | 3247535760ca962f859c203295b508d442aca4ed | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | src/common/Coordinate.h | dtip/magics | 3247535760ca962f859c203295b508d442aca4ed | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | src/common/Coordinate.h | dtip/magics | 3247535760ca962f859c203295b508d442aca4ed | [
"ECL-2.0",
"Apache-2.0"
] | 1 | 2019-12-18T17:01:56.000Z | 2019-12-18T17:01:56.000Z | /*
* (C) Copyright 1996-2016 ECMWF.
*
* This software is licensed under the terms of the Apache Licence Version 2.0
* which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
* In applying this licence, ECMWF does not waive the privileges and immunities
* granted to it by virtue of its status as an intergovernmental organisation nor
* does it submit to any jurisdiction.
*/
/*! \file Coordinate.h
\brief Definition of the Template class Coordinate.
Magics Team - ECMWF 2006
Started: Thu 10-Aug-2006
Changes:
*/
#ifndef Coordinate_H
#define Coordinate_H
#include "Factory.h"
#include "MagTranslator.h"
#include "magics.h"
#include "XRegularCoordinateAttributes.h"
#include "YRegularCoordinateAttributes.h"
#include "XLogarithmicCoordinateAttributes.h"
#include "YLogarithmicCoordinateAttributes.h"
#include "XDateCoordinateAttributes.h"
#include "YDateCoordinateAttributes.h"
#include "MagDateTime.h"
#include "UserPoint.h"
#include "XHyperCoordinateAttributes.h"
#include "YHyperCoordinateAttributes.h"
#include "XmlNode.h"
#include <limits>
namespace magics {
class XmlNode;
class Coordinate {
public:
Coordinate();
virtual ~Coordinate();
virtual double min() { return 0; }
virtual double max() { return 100; }
virtual double minpc() { return 0; }
virtual double maxpc() { return 100; }
virtual vector<double> maxs() {
vector<double> vmax;
vmax.push_back(max());
return vmax;
}
virtual vector<double> mins() {
vector<double> vmin;
vmin.push_back(min());
return vmin;
}
virtual string reference() { return ""; }
virtual double operator()(double c) { return c; }
virtual double revert(double c) { return c; }
virtual void set(const XmlNode&) { MagLog::dev() << "(const XmlNode&)---> to be checked!...\n"; }
virtual void set(const map<string, string>&) {
MagLog::dev() << "(const map<string, string&)---> to be checked!...\n";
}
virtual void metadata(ostream& out) { out << "axis : {}"; }
virtual void set() {}
virtual bool accept(const string&) {
MagLog::dev() << "(const map<string, string&)---> to be checked!...\n";
return false;
}
virtual void toxml(ostream&) const {}
virtual AxisAutomaticSetting automatic() { return m_off; }
virtual void automatic(bool) {}
virtual double operator()(const string& val) const { return tonumber(val); }
virtual string type() const { return "regular"; }
virtual void minmax(double max, double min) { NOTIMP; }
virtual void dataMinMax(double min, double max) = 0;
virtual void dataMinMax(double min, double max, const string&) = 0;
virtual void setAutomatic(AxisAutomaticSetting) {}
virtual void getNewDefinition(const UserPoint&, const UserPoint&, map<string, string>&) const {}
protected:
//! Method to print string about this class on to a stream of type ostream (virtual).
virtual void print(ostream&) const;
private:
//! Copy constructor - No copy allowed
Coordinate(const Coordinate&);
//! Overloaded << operator to copy - No copy allowed
Coordinate& operator=(const Coordinate&);
// -- Friends
//! Overloaded << operator to call print().
friend ostream& operator<<(ostream& s, const Coordinate& p) {
p.print(s);
return s;
}
};
class XCoordinate : public Coordinate {
public:
XCoordinate() {}
virtual ~XCoordinate() {}
virtual XCoordinate* clone() const {
MagLog::dev() << "(const map<string, string&)---> to be checked!...\n";
return new XCoordinate();
}
virtual void toxml(ostream& out) const {}
void set(const XmlNode& node) {}
void set(const map<string, string>& map) {}
void set() {}
void print(ostream& out) const {}
virtual AxisAutomaticSetting automatic() { return m_off; }
virtual void automatic(bool val) {}
bool accept(const string& tag) { return false; }
//! Overloaded << operator to call print().
friend ostream& operator<<(ostream& s, const XCoordinate& p) {
p.print(s);
return s;
}
virtual void getNewDefinition(const UserPoint& ll, const UserPoint& ur, map<string, string>& def) const {
def["x_axis_type"] = type();
def["x_min"] = tostring(ll.x_);
def["x_max"] = tostring(ur.x_);
def["x_automatic"] = "off";
}
virtual void dataMinMax(double min, double max) { minmax(min, max); }
virtual void dataMinMax(double min, double max, const string&) { minmax(min, max); }
};
class YCoordinate : public Coordinate {
public:
YCoordinate() {}
virtual ~YCoordinate() {}
virtual void toxml(ostream& out) const {}
virtual YCoordinate* clone() const {
MagLog::dev() << "(const map<string, string&)---> to be checked!...\n";
return new YCoordinate();
}
virtual void automatic(bool val) {}
void set(const XmlNode& node) {}
void set(const map<string, string>& map) {}
void set() {}
void print(ostream& out) const {}
bool accept(const string& tag) { return false; }
virtual AxisAutomaticSetting automatic() { return m_off; }
//! Overloaded << operator to call print().
friend ostream& operator<<(ostream& s, const YCoordinate& p) {
p.print(s);
return s;
}
virtual void getNewDefinition(const UserPoint& ll, const UserPoint& ur, map<string, string>& def) const {
def["y_axis_type"] = type();
def["y_min"] = tostring(ll.y_);
def["y_max"] = tostring(ur.y_);
def["y_automatic"] = "off";
}
virtual void dataMinMax(double min, double max) { minmax(min, max); }
virtual void dataMinMax(double min, double max, const string&) { minmax(min, max); }
};
class RegularCoordinate {
public:
RegularCoordinate() {}
virtual ~RegularCoordinate() {}
};
class XRegularCoordinate : public RegularCoordinate, public XCoordinate, public XRegularCoordinateAttributes {
public:
XRegularCoordinate() { set(); }
virtual ~XRegularCoordinate() {}
void toxml(ostream& out) const { XRegularCoordinateAttributes::toxml(out); }
void set() {
switch (automatic_) {
case m_both:
if (reverse_) {
max_ = std::numeric_limits<double>::max();
min_ = -max_;
}
else {
min_ = std::numeric_limits<double>::max();
max_ = -min_;
}
break;
case m_min_only:
min_ = std::numeric_limits<double>::max();
break;
case m_max_only:
max_ = -std::numeric_limits<double>::max();
break;
default:
break;
}
}
virtual void set(const XmlNode& node) {
XRegularCoordinateAttributes::set(node);
set();
}
void set(const map<string, string>& map) {
XRegularCoordinateAttributes::set(map);
set();
}
virtual bool accept(const string& node) { return XRegularCoordinateAttributes::accept(node); }
double min() { return min_; }
double max() { return max_; }
double minpc() { return min_; }
double maxpc() { return max_; }
AxisAutomaticSetting automatic() { return automatic_; }
void setAutomatic(AxisAutomaticSetting automatic) { automatic_ = automatic; }
virtual void automatic(bool automatic) {
automatic_ = automatic ? m_both : m_off;
set();
}
void minmax(double min, double max) {
switch (automatic_) {
case m_both:
// set the
if (reverse_) {
max_ = std::min(min, max_);
min_ = std::max(max, min_);
}
else {
min_ = std::min(min, min_);
max_ = std::max(max, max_);
}
break;
case m_min_only:
if (reverse_)
max_ = std::min(min, max_);
else
min_ = std::min(min, min_);
break;
case m_max_only:
if (reverse_)
min_ = std::max(max, min_);
else
max_ = std::max(max, max_);
break;
default:
break;
}
}
virtual XCoordinate* clone() const {
XRegularCoordinate* x = new XRegularCoordinate();
x->copy(*this);
return x;
}
protected:
virtual void print(ostream& out) const { XRegularCoordinateAttributes::print(out); }
};
class YRegularCoordinate : public RegularCoordinate, public YCoordinate, public YRegularCoordinateAttributes {
public:
YRegularCoordinate() { set(); }
virtual ~YRegularCoordinate() {}
void toxml(ostream& out) const { YRegularCoordinateAttributes::toxml(out); }
void set() {
switch (automatic_) {
case m_both:
if (reverse_) {
max_ = std::numeric_limits<double>::max();
min_ = -max_;
}
else {
min_ = std::numeric_limits<double>::max();
max_ = -min_;
}
break;
case m_min_only:
min_ = std::numeric_limits<double>::max();
break;
case m_max_only:
max_ = -std::numeric_limits<double>::max();
break;
default:
break;
}
}
double min() { return min_; }
double max() { return max_; }
double minpc() { return min_; }
double maxpc() { return max_; }
virtual void setAutomatic(AxisAutomaticSetting automatic) {
automatic_ = automatic;
set();
}
void minmax(double min, double max) {
switch (automatic_) {
case m_both:
// set the
if (reverse_) {
max_ = std::min(min, max_);
min_ = std::max(max, min_);
}
else {
min_ = std::min(min, min_);
max_ = std::max(max, max_);
}
break;
case m_min_only:
if (reverse_)
max_ = std::min(min, max_);
else
min_ = std::min(min, min_);
break;
case m_max_only:
if (reverse_)
min_ = std::max(max, min_);
else
max_ = std::max(max, max_);
break;
default:
break;
}
}
virtual void automatic(bool automatic) {
automatic_ = automatic ? m_both : m_off;
set();
}
virtual YCoordinate* clone() const {
YRegularCoordinate* y = new YRegularCoordinate();
y->copy(*this);
return y;
}
void set(const XmlNode& node) {
YRegularCoordinateAttributes::set(node);
set();
}
void set(const map<string, string>& map) {
YRegularCoordinateAttributes::set(map);
set();
}
bool accept(const string& node) { return YRegularCoordinateAttributes::accept(node); }
void setMin(double min) { min_ = min; }
void setMax(double max) { max_ = max; }
AxisAutomaticSetting automatic() { return automatic_; }
protected:
virtual void print(ostream& out) const { YRegularCoordinateAttributes::print(out); }
};
class LogarithmicCoordinate : public Coordinate {
public:
LogarithmicCoordinate() {}
virtual ~LogarithmicCoordinate() {}
string type() const { return "logarithmic"; }
};
class XLogarithmicCoordinate : public LogarithmicCoordinate,
public XCoordinate,
public XLogarithmicCoordinateAttributes {
public:
XLogarithmicCoordinate() {}
virtual ~XLogarithmicCoordinate() {}
virtual void toxml(ostream& out) const { XLogarithmicCoordinateAttributes::toxml(out); }
double min() { return min_; }
double max() { return max_; }
double minpc() { return (*this)(min_); }
double maxpc() { return (*this)(max_); }
void set(const XmlNode& node) {
if (!magCompare(node.name(), "x_logarithmic"))
return;
XmlNode regular = node;
regular.name("x_regular");
XLogarithmicCoordinateAttributes::set(regular);
set();
}
void set(const map<string, string>& map) {
XLogarithmicCoordinateAttributes::set(map);
set();
}
void set() {
switch (automatic_) {
case m_both:
if (reverse_) {
max_ = std::numeric_limits<double>::max();
min_ = -max_;
}
else {
min_ = std::numeric_limits<double>::max();
max_ = -min_;
}
break;
case m_min_only:
automatic_ = m_off;
min_ = std::numeric_limits<double>::max();
break;
case m_max_only:
automatic_ = m_off;
max_ = -std::numeric_limits<double>::max();
break;
default:
break;
}
}
void minmax(double min, double max) {
switch (automatic_) {
case m_both:
// set the
if (reverse_) {
max_ = std::min(min, max_);
min_ = std::max(max, min_);
}
else {
min_ = std::min(min, min_);
max_ = std::max(max, max_);
}
break;
case m_min_only:
if (reverse_)
max_ = std::min(min, max_);
else
min_ = std::min(min, min_);
break;
case m_max_only:
if (reverse_)
min_ = std::max(max, min_);
else
max_ = std::max(max, max_);
break;
default:
break;
}
}
double operator()(double c) { return (c) ? log10(c) : 0; }
double revert(double c) { return pow(c, 10); }
virtual XCoordinate* clone() const {
XLogarithmicCoordinate* x = new XLogarithmicCoordinate();
x->copy(*this);
MagLog::dev() << "(const map<string, string&)---> to be checked!...\n";
return x;
}
void getNewDefinition(const UserPoint& ll, const UserPoint& ur, map<string, string>& def) const {
def["x_axis_type"] = "logarithmic";
def["x_min"] = tostring(ll.x_);
def["x_max"] = tostring(ur.x_);
def["x_automatic"] = "off";
}
virtual void dataMinMax(double min, double max) { NOTIMP; }
virtual void dataMinMax(double min, double max, const string&) { NOTIMP; }
AxisAutomaticSetting automatic() { return automatic_; }
virtual void automatic(bool automatic) { automatic_ = (automatic ? m_both : m_off); }
virtual void setAutomatic(AxisAutomaticSetting automatic) { automatic_ = automatic; }
protected:
virtual void print(ostream& out) const {
out << "XLogarithmicCoordinate[";
XLogarithmicCoordinateAttributes::print(out);
out << "]";
}
};
class YLogarithmicCoordinate : public LogarithmicCoordinate,
public YCoordinate,
public YLogarithmicCoordinateAttributes {
public:
YLogarithmicCoordinate() {}
virtual ~YLogarithmicCoordinate() {}
virtual void set(const XmlNode& node) {
if (!magCompare(node.name(), "y_logarithmic"))
return;
XmlNode regular = node;
regular.name("y_regular");
YLogarithmicCoordinateAttributes::set(regular);
set();
}
virtual void set(const map<string, string>& map) {
YLogarithmicCoordinateAttributes::set(map);
set();
}
virtual void toxml(ostream& out) const { YLogarithmicCoordinateAttributes::toxml(out); }
void set() {
switch (automatic_) {
case m_both:
if (reverse_) {
max_ = std::numeric_limits<double>::max();
min_ = -max_;
}
else {
min_ = std::numeric_limits<double>::max();
max_ = -min_;
}
break;
case m_min_only:
min_ = std::numeric_limits<double>::max();
break;
case m_max_only:
max_ = -std::numeric_limits<double>::max();
break;
default:
break;
}
}
double min() { return min_; }
double max() { return max_; }
double minpc() { return (*this)(min_); }
double maxpc() { return (*this)(max_); }
virtual void dataMinMax(double min, double max) { NOTIMP; }
virtual void dataMinMax(double min, double max, const string&) { NOTIMP; }
void minmax(double min, double max) {
switch (automatic_) {
case m_both:
// set the
if (reverse_) {
max_ = std::min(min, max_);
min_ = std::max(max, min_);
}
else {
min_ = std::min(min, min_);
max_ = std::max(max, max_);
}
break;
case m_min_only:
if (reverse_)
max_ = std::min(min, max_);
else
min_ = std::min(min, min_);
break;
case m_max_only:
if (reverse_)
min_ = std::max(max, min_);
else
max_ = std::max(max, max_);
break;
default:
break;
}
}
void getNewDefinition(const UserPoint& ll, const UserPoint& ur, map<string, string>& def) const {
def["y_axis_type"] = "logarithmic";
def["y_min"] = tostring(::pow(10., ll.y_));
def["y_max"] = tostring(::pow(10., ur.y_));
def["y_automatic"] = "off";
}
AxisAutomaticSetting automatic() { return automatic_; }
void setMinMax(double min, double max) {
min_ = min;
max_ = max;
}
double operator()(double c) { return (c) ? log10(c) : 0; }
double revert(double c) { return ::pow(10., c); }
virtual YCoordinate* clone() const {
YLogarithmicCoordinate* y = new YLogarithmicCoordinate();
y->copy(*this);
return y;
}
virtual void automatic(bool automatic) { automatic_ = automatic ? m_both : m_off; }
virtual void setAutomatic(AxisAutomaticSetting automatic) { automatic_ = automatic; }
protected:
virtual void print(ostream& out) const {
out << "YLogarithmicCoordinate[";
YLogarithmicCoordinateAttributes::print(out);
out << "]";
}
};
class DateCoordinate {
public:
DateCoordinate() {}
virtual ~DateCoordinate() {}
virtual string type() const { return "date"; }
};
class XDateCoordinate : public DateCoordinate, public XDateCoordinateAttributes, public XCoordinate {
public:
XDateCoordinate() { anna_ = false; }
virtual ~XDateCoordinate() {}
virtual void toxml(ostream& out) const { XDateCoordinateAttributes::toxml(out); }
double min() { return 0; }
double max() { return DateTime(date_max_) - DateTime(date_min_); }
double minpc() { return anna_ ? min_anna_ : 0; }
double maxpc() { return anna_ ? max_anna_ : max(); }
void min(double min) {
min_anna_ = min;
anna_ = true;
}
void max(double max) {
max_anna_ = max;
anna_ = true;
}
string reference() { return DateTime(date_min_); }
virtual XCoordinate* clone() const {
XDateCoordinate* x = new XDateCoordinate();
return x;
}
virtual string type() const { return "date"; }
AxisAutomaticSetting automatic() { return automatic_ ? m_both : m_off; }
void set(const XmlNode& node) { XDateCoordinateAttributes::set(node); }
void set(const map<string, string>& map) { XDateCoordinateAttributes::set(map); }
bool accept(const string& xml) { return XDateCoordinateAttributes::accept(xml); }
void setMin(double) {}
void setMax(double) {}
void automatic(bool automatic) { automatic_ = (automatic ? m_both : m_off); }
virtual void setAutomatic(AxisAutomaticSetting automatic) { automatic_ = (automatic); }
void setMinMax(const string& min, const string& max) {
date_min_ = min;
date_max_ = max;
}
void dataMinMax(double min, double max, const string& date) {
DateTime base(date);
DateTime mind = base + Second(min);
DateTime maxd = base + Second(max);
if (date_min_.empty())
date_min_ = string(mind);
if (date_max_.empty())
date_max_ = string(maxd);
DateTime mind_(date_min_);
DateTime maxd_(date_max_);
switch (automatic_) {
case m_both:
// set the
if (reverse_) {
maxd_ = std::min(mind, maxd_);
mind_ = std::max(maxd, mind_);
}
else {
mind_ = std::min(mind, mind_);
maxd_ = std::max(maxd, maxd_);
}
break;
case m_min_only:
if (reverse_)
maxd_ = std::min(mind, maxd_);
else
mind_ = std::min(mind, mind_);
break;
case m_max_only:
if (reverse_)
mind_ = std::max(maxd, mind_);
else
maxd_ = std::max(maxd, maxd_);
break;
default:
break;
}
date_max_ = string(maxd_);
date_min_ = string(mind_);
}
double operator()(double c) { return c; }
double operator()(const string& val) const {
DateTime date(val);
return date - DateTime(date_min_);
}
void getNewDefinition(const UserPoint& ll, const UserPoint& ur, map<string, string>& def) const {
DateTime min = DateTime(date_min_) + Second(ll.x_);
DateTime max = DateTime(date_min_) + Second(ur.x_);
def["x_axis_type"] = "date";
def["x_date_min"] = tostring(min);
def["x_date_max"] = tostring(max);
def["x_automatic"] = "off";
}
protected:
virtual void print(ostream& out) const { XDateCoordinateAttributes::print(out); }
// patch for anna!
double min_anna_;
double max_anna_;
bool anna_;
};
class YDateCoordinate : public DateCoordinate, public YDateCoordinateAttributes, public YCoordinate {
public:
YDateCoordinate() {}
virtual ~YDateCoordinate() {}
virtual void toxml(ostream& out) const { YDateCoordinateAttributes::toxml(out); }
double min() { return 0; }
double max() { return DateTime(date_max_) - DateTime(date_min_); }
double minpc() { return 0; }
double maxpc() { return DateTime(date_max_) - DateTime(date_min_); }
string reference() { return DateTime(date_min_); }
virtual string type() const { return "date"; }
bool accept(const string& xml) { return YDateCoordinateAttributes::accept(xml); }
void set(const XmlNode& node) { YDateCoordinateAttributes::set(node); }
void set(const map<string, string>& map) { YDateCoordinateAttributes::set(map); }
void setAutomatic(AxisAutomaticSetting automatic) { automatic_ = (automatic); }
void automatic(bool automatic) { automatic_ = (automatic ? m_both : m_off); }
virtual YCoordinate* clone() const {
YDateCoordinate* y = new YDateCoordinate();
// y->copy(*this);
return y;
}
AxisAutomaticSetting automatic() { return automatic_ ? m_both : m_off; }
void setMinMax(double, double) {}
void setMinMax(const string& min, const string& max) {
date_min_ = min;
date_max_ = max;
}
double operator()(double c) { return c; }
double operator()(const string& val) const {
DateTime date(val);
return date - DateTime(date_min_);
}
void dataMinMax(double min, double max, const string& date) {
DateTime base(date);
DateTime mind = base + Second(min);
DateTime maxd = base + Second(max);
if (date_min_.empty())
date_min_ = string(mind);
if (date_max_.empty())
date_max_ = string(maxd);
DateTime mind_(date_min_);
DateTime maxd_(date_max_);
switch (automatic_) {
case m_both:
// set the
if (reverse_) {
maxd_ = std::min(mind, maxd_);
mind_ = std::max(maxd, mind_);
}
else {
mind_ = std::min(mind, mind_);
maxd_ = std::max(maxd, maxd_);
}
break;
case m_min_only:
if (reverse_)
maxd_ = std::min(mind, maxd_);
else
mind_ = std::min(mind, mind_);
break;
case m_max_only:
if (reverse_)
mind_ = std::max(maxd, mind_);
else
maxd_ = std::max(maxd, maxd_);
break;
default:
break;
}
date_max_ = string(maxd_);
date_min_ = string(mind_);
}
void getNewDefinition(const UserPoint& ll, const UserPoint& ur, map<string, string>& def) const {
DateTime min = DateTime(date_min_) + Second(ll.y_);
DateTime max = DateTime(date_min_) + Second(ur.y_);
def["y_axis_type"] = "date";
def["y_date_min"] = tostring(min);
def["y_date_max"] = tostring(max);
def["y_automatic"] = "off";
}
protected:
virtual void print(ostream& out) const { YDateCoordinateAttributes::print(out); }
};
class YHyperCoordinate : public YHyperCoordinateAttributes, public YCoordinate {
public:
YHyperCoordinate() {}
virtual ~YHyperCoordinate() {}
double min() { return (min_lon_ == max_lon_) ? min_lat_ : min_lon_; }
double max() { return (min_lon_ == max_lon_) ? max_lat_ : max_lon_; }
double minpc() { return (min_lon_ == max_lon_) ? min_lat_ : min_lon_; }
double maxpc() { return (min_lon_ == max_lon_) ? max_lat_ : max_lon_; }
string reference() { return ""; }
void toxml(ostream& out) const { YHyperCoordinateAttributes::toxml(out); }
bool accept(const string& xml) { return YHyperCoordinateAttributes::accept(xml); }
void set(const XmlNode& node) { YHyperCoordinateAttributes::set(node); }
void set(const map<string, string>& map) { YHyperCoordinateAttributes::set(map); }
void setAutomatic(AxisAutomaticSetting automatic) { YCoordinate::setAutomatic(automatic); }
void setAutomatic(bool automatic) { automatic_ = automatic ? m_both : m_off; }
void automatic(bool automatic) { automatic_ = automatic ? m_both : m_off; }
virtual YCoordinate* clone() const {
YHyperCoordinate* y = new YHyperCoordinate();
// y->copy(*this);
return y;
}
AxisAutomaticSetting automatic() { return automatic_; }
void setMinMax(double, double) {}
vector<double> mins() {
vector<double> mins;
mins.push_back(min_lon_);
mins.push_back(min_lat_);
return mins;
}
vector<double> maxs() {
vector<double> maxs;
maxs.push_back(max_lon_);
maxs.push_back(max_lat_);
return maxs;
}
string type() const { return "geoline"; }
void getNewDefinition(const UserPoint& ll, const UserPoint& ur, map<string, string>& def) const {
double lon1 = ll.y();
double lon2 = ur.y();
double lat1 =
(max_lat_ - min_lat_) ? min_lat_ + ((lon1 - min_lon_) / (max_lon_ - min_lon_)) * (max_lat_ - min_lat_) : 0;
double lat2 =
(max_lat_ - min_lat_) ? min_lat_ + ((lon2 - min_lon_) / (max_lon_ - min_lon_)) * (max_lat_ - min_lat_) : 0;
def["y_automatic"] = "off";
def["y_axis_type"] = "geoline";
def["y_min_latitude"] = tostring(lat1);
def["y_max_latitude"] = tostring(lat2);
def["y_min_longitude"] = tostring(lon1);
def["y_max_longitude"] = tostring(lon2);
}
void dataMinMax(double min, double max, const string& info) {
// interpret the info : lonmin/latmin
Tokenizer tokenizer("/");
vector<string> tokens;
tokenizer(info, tokens);
switch (automatic_) {
case m_both:
case m_min_only: {
if (reverse_) {
max_lon_ = tonumber(tokens[0]);
max_lat_ = tonumber(tokens[1]);
}
else {
min_lon_ = tonumber(tokens[0]);
min_lat_ = tonumber(tokens[1]);
}
break;
}
default:
break;
}
automatic_ = (automatic_ == m_both) ? m_max_only : m_off;
// interpret the info : lonmin/latmin
tokens.clear();
tokenizer(info, tokens);
switch (automatic_) {
case m_both:
case m_max_only: {
if (reverse_) {
min_lon_ = tonumber(tokens[2]);
min_lat_ = tonumber(tokens[3]);
}
else {
max_lon_ = tonumber(tokens[2]);
max_lat_ = tonumber(tokens[3]);
}
break;
}
default:
break;
}
automatic_ = (automatic_ == m_both) ? m_min_only : m_off;
}
protected:
virtual void print(ostream& out) const { YHyperCoordinateAttributes::print(out); }
};
class XHyperCoordinate : public XHyperCoordinateAttributes, public XCoordinate {
public:
XHyperCoordinate() {}
virtual ~XHyperCoordinate() {}
double min() { return (min_lon_ == max_lon_) ? min_lat_ : min_lon_; }
double max() { return (min_lon_ == max_lon_) ? max_lat_ : max_lon_; }
double minpc() { return (min_lon_ == max_lon_) ? min_lat_ : min_lon_; }
double maxpc() { return (min_lon_ == max_lon_) ? max_lat_ : max_lon_; }
string reference() { return ""; }
void toxml(ostream& out) const { XHyperCoordinateAttributes::toxml(out); }
bool accept(const string& xml) { return XHyperCoordinateAttributes::accept(xml); }
void set(const XmlNode& node) { XHyperCoordinateAttributes::set(node); }
void set(const map<string, string>& map) { XHyperCoordinateAttributes::set(map); }
void setAutomatic(AxisAutomaticSetting automatic) { XCoordinate::setAutomatic(automatic); }
void setAutomatic(bool automatic) { automatic_ = (automatic ? m_both : m_off); }
void automatic(bool automatic) { automatic_ = automatic ? m_both : m_off; }
vector<double> mins() {
vector<double> mins;
mins.push_back(min_lon_);
mins.push_back(min_lat_);
return mins;
}
vector<double> maxs() {
vector<double> maxs;
maxs.push_back(max_lon_);
maxs.push_back(max_lat_);
return maxs;
}
virtual XCoordinate* clone() const {
XHyperCoordinate* x = new XHyperCoordinate();
return x;
}
AxisAutomaticSetting automatic() { return automatic_ ? m_both : m_off; }
void setMinMax(double, double) {}
string type() const { return "geoline"; }
void dataMinMax(double min, double max, const string& info) {
// interpret the info : lonmin/latmin
Tokenizer tokenizer("/");
vector<string> tokens;
tokenizer(info, tokens);
switch (automatic_) {
case m_both:
case m_min_only: {
if (reverse_) {
max_lon_ = tonumber(tokens[0]);
max_lat_ = tonumber(tokens[1]);
}
else {
min_lon_ = tonumber(tokens[0]);
min_lat_ = tonumber(tokens[1]);
}
break;
}
default:
break;
}
automatic_ = (automatic_ == m_both) ? m_max_only : m_off;
// interpret the info : lonmin/latmin
switch (automatic_) {
case m_both:
case m_max_only: {
if (reverse_) {
min_lon_ = tonumber(tokens[2]);
min_lat_ = tonumber(tokens[3]);
}
else {
max_lon_ = tonumber(tokens[2]);
max_lat_ = tonumber(tokens[3]);
}
}
default:
break;
}
automatic_ = (automatic_ == m_both) ? m_min_only : m_off;
}
void getNewDefinition(const UserPoint& ll, const UserPoint& ur, map<string, string>& def) const {
double lon1 = ll.x();
double lon2 = ur.x();
// we have to compute the lat and lon of the point!
double lat1 =
(max_lat_ - min_lat_) ? min_lat_ + ((lon1 - min_lon_) / (max_lon_ - min_lon_)) * (max_lat_ - min_lat_) : 0;
double lat2 =
(max_lat_ - min_lat_) ? min_lat_ + ((lon2 - min_lon_) / (max_lon_ - min_lon_)) * (max_lat_ - min_lat_) : 0;
def["x_automatic"] = "off";
def["x_axis_type"] = "geoline";
def["x_min_latitude"] = tostring(lat1);
def["x_max_latitude"] = tostring(lat2);
def["x_min_longitude"] = tostring(lon1);
def["x_max_longitude"] = tostring(lon2);
}
protected:
virtual void print(ostream& out) const { XHyperCoordinateAttributes::print(out); }
};
template <>
class MagTranslator<string, XCoordinate> {
public:
XCoordinate* operator()(const string& val) { return SimpleObjectMaker<XCoordinate>::create(val); }
XCoordinate* magics(const string& param) {
XCoordinate* object;
ParameterManager::update(param, object);
return object;
}
};
template <>
class MagTranslator<string, YCoordinate> {
public:
YCoordinate* operator()(const string& val) { return SimpleObjectMaker<YCoordinate>::create(val); }
YCoordinate* magics(const string& param) {
YCoordinate* object;
ParameterManager::update(param, object);
return object;
}
};
} // namespace magics
#endif
| 33.081517 | 119 | 0.552105 | [
"object",
"vector"
] |
3447ca6f787352b57b94e825e157f269a372ebee | 18,328 | h | C | 3rdparty/webkit/Source/WebCore/rendering/RenderLayerBacking.h | mchiasson/PhaserNative | f867454602c395484bf730a7c43b9c586c102ac2 | [
"MIT"
] | 1 | 2020-05-25T16:06:49.000Z | 2020-05-25T16:06:49.000Z | WebLayoutCore/Source/WebCore/rendering/RenderLayerBacking.h | gubaojian/trylearn | 74dd5c6c977f8d867d6aa360b84bc98cb82f480c | [
"MIT"
] | null | null | null | WebLayoutCore/Source/WebCore/rendering/RenderLayerBacking.h | gubaojian/trylearn | 74dd5c6c977f8d867d6aa360b84bc98cb82f480c | [
"MIT"
] | 1 | 2018-07-10T10:53:18.000Z | 2018-07-10T10:53:18.000Z | /*
* Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "FloatPoint.h"
#include "FloatPoint3D.h"
#include "GraphicsLayer.h"
#include "GraphicsLayerClient.h"
#include "RenderLayer.h"
#include "ScrollingCoordinator.h"
namespace WebCore {
class KeyframeList;
class PaintedContentsInfo;
class RenderLayerCompositor;
class TiledBacking;
class TransformationMatrix;
enum CompositingLayerType {
NormalCompositingLayer, // non-tiled layer with backing store
TiledCompositingLayer, // tiled layer (always has backing store)
MediaCompositingLayer, // layer that contains an image, video, webGL or plugin
ContainerCompositingLayer // layer with no backing store
};
// RenderLayerBacking controls the compositing behavior for a single RenderLayer.
// It holds the various GraphicsLayers, and makes decisions about intra-layer rendering
// optimizations.
//
// There is one RenderLayerBacking for each RenderLayer that is composited.
class RenderLayerBacking final : public GraphicsLayerClient {
WTF_MAKE_NONCOPYABLE(RenderLayerBacking); WTF_MAKE_FAST_ALLOCATED;
public:
explicit RenderLayerBacking(RenderLayer&);
~RenderLayerBacking();
#if PLATFORM(IOS)
void layerWillBeDestroyed();
#endif
RenderLayer& owningLayer() const { return m_owningLayer; }
enum class UpdateAfterLayoutFlags {
NeedsFullRepaint = 1 << 0,
IsUpdateRoot = 1 << 1
};
void updateAfterLayout(OptionSet<UpdateAfterLayoutFlags>);
// Returns true if layer configuration changed.
bool updateConfiguration();
// Update graphics layer position and bounds.
void updateGeometry();
// Update state the requires that descendant layers have been updated.
void updateAfterDescendants();
// Update contents and clipping structure.
void updateDrawsContent();
GraphicsLayer* graphicsLayer() const { return m_graphicsLayer.get(); }
// Layer to clip children
bool hasClippingLayer() const { return (m_childContainmentLayer && !m_isFrameLayerWithTiledBacking); }
GraphicsLayer* clippingLayer() const { return !m_isFrameLayerWithTiledBacking ? m_childContainmentLayer.get() : nullptr; }
// Layer to get clipped by ancestor
bool hasAncestorClippingLayer() const { return m_ancestorClippingLayer != nullptr; }
GraphicsLayer* ancestorClippingLayer() const { return m_ancestorClippingLayer.get(); }
GraphicsLayer* contentsContainmentLayer() const { return m_contentsContainmentLayer.get(); }
GraphicsLayer* foregroundLayer() const { return m_foregroundLayer.get(); }
GraphicsLayer* backgroundLayer() const { return m_backgroundLayer.get(); }
bool backgroundLayerPaintsFixedRootBackground() const { return m_backgroundLayerPaintsFixedRootBackground; }
bool hasScrollingLayer() const { return m_scrollingLayer != nullptr; }
GraphicsLayer* scrollingLayer() const { return m_scrollingLayer.get(); }
GraphicsLayer* scrollingContentsLayer() const { return m_scrollingContentsLayer.get(); }
void detachFromScrollingCoordinator(LayerScrollCoordinationRoles);
ScrollingNodeID scrollingNodeIDForRole(LayerScrollCoordinationRole role) const
{
switch (role) {
case Scrolling:
return m_scrollingNodeID;
case ViewportConstrained:
return m_viewportConstrainedNodeID;
}
return 0;
}
void setScrollingNodeIDForRole(ScrollingNodeID nodeID, LayerScrollCoordinationRole role)
{
switch (role) {
case Scrolling:
m_scrollingNodeID = nodeID;
break;
case ViewportConstrained:
m_viewportConstrainedNodeID = nodeID;
setIsScrollCoordinatedWithViewportConstrainedRole(nodeID);
break;
}
}
ScrollingNodeID scrollingNodeIDForChildren() const { return m_scrollingNodeID ? m_scrollingNodeID : m_viewportConstrainedNodeID; }
void setIsScrollCoordinatedWithViewportConstrainedRole(bool);
bool hasMaskLayer() const { return m_maskLayer != 0; }
bool hasChildClippingMaskLayer() const { return m_childClippingMaskLayer != nullptr; }
GraphicsLayer* parentForSublayers() const;
GraphicsLayer* childForSuperlayers() const;
// RenderLayers with backing normally short-circuit paintLayer() because
// their content is rendered via callbacks from GraphicsLayer. However, the document
// layer is special, because it has a GraphicsLayer to act as a container for the GraphicsLayers
// for descendants, but its contents usually render into the window (in which case this returns true).
// This returns false for other layers, and when the document layer actually needs to paint into its backing store
// for some reason.
bool paintsIntoWindow() const;
// Returns true for a composited layer that has no backing store of its own, so
// paints into some ancestor layer.
bool paintsIntoCompositedAncestor() const { return !m_requiresOwnBackingStore; }
void setRequiresOwnBackingStore(bool);
void setContentsNeedDisplay(GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
// r is in the coordinate space of the layer's render object
void setContentsNeedDisplayInRect(const LayoutRect&, GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
// Notification from the renderer that its content changed.
void contentChanged(ContentChangeType);
// Interface to start, finish, suspend and resume animations and transitions
bool startTransition(double, CSSPropertyID, const RenderStyle* fromStyle, const RenderStyle* toStyle);
void transitionPaused(double timeOffset, CSSPropertyID);
void transitionFinished(CSSPropertyID);
bool startAnimation(double timeOffset, const Animation* anim, const KeyframeList& keyframes);
void animationPaused(double timeOffset, const String& name);
void animationFinished(const String& name);
void suspendAnimations(double time = 0);
void resumeAnimations();
LayoutRect compositedBounds() const;
void setCompositedBounds(const LayoutRect&);
void updateCompositedBounds();
void updateAfterWidgetResize();
void positionOverflowControlsLayers();
bool hasUnpositionedOverflowControlsLayers() const;
bool isFrameLayerWithTiledBacking() const { return m_isFrameLayerWithTiledBacking; }
WEBCORE_EXPORT TiledBacking* tiledBacking() const;
void adjustTiledBackingCoverage();
void setTiledBackingHasMargins(bool hasExtendedBackgroundOnLeftAndRight, bool hasExtendedBackgroundOnTopAndBottom);
void updateDebugIndicators(bool showBorder, bool showRepaintCounter);
bool paintsSubpixelAntialiasedText() const { return m_paintsSubpixelAntialiasedText; }
// GraphicsLayerClient interface
void tiledBackingUsageChanged(const GraphicsLayer*, bool /*usingTiledBacking*/) override;
void notifyAnimationStarted(const GraphicsLayer*, const String& animationKey, double startTime) override;
void notifyFlushRequired(const GraphicsLayer*) override;
void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) override;
void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& clip, GraphicsLayerPaintBehavior) override;
float deviceScaleFactor() const override;
float contentsScaleMultiplierForNewTiles(const GraphicsLayer*) const override;
bool paintsOpaquelyAtNonIntegralScales(const GraphicsLayer*) const override;
float pageScaleFactor() const override;
float zoomedOutPageScaleFactor() const override;
void didCommitChangesForLayer(const GraphicsLayer*) const override;
bool getCurrentTransform(const GraphicsLayer*, TransformationMatrix&) const override;
bool isTrackingRepaints() const override;
bool shouldSkipLayerInDump(const GraphicsLayer*, LayerTreeAsTextBehavior) const override;
bool shouldDumpPropertyForLayer(const GraphicsLayer*, const char* propertyName) const override;
bool shouldAggressivelyRetainTiles(const GraphicsLayer*) const override;
bool shouldTemporarilyRetainTileCohorts(const GraphicsLayer*) const override;
bool useGiantTiles() const override;
void logFilledVisibleFreshTile(unsigned) override;
bool needsPixelAligment() const override { return !m_isMainFrameRenderViewLayer; }
LayoutSize subpixelOffsetFromRenderer() const { return m_subpixelOffsetFromRenderer; }
#if PLATFORM(IOS)
bool needsIOSDumpRenderTreeMainFrameRenderViewLayerIsAlwaysOpaqueHack(const GraphicsLayer&) const override;
#endif
#ifndef NDEBUG
void verifyNotPainting() override;
#endif
WEBCORE_EXPORT LayoutRect contentsBox() const;
// For informative purposes only.
WEBCORE_EXPORT CompositingLayerType compositingLayerType() const;
GraphicsLayer* layerForHorizontalScrollbar() const { return m_layerForHorizontalScrollbar.get(); }
GraphicsLayer* layerForVerticalScrollbar() const { return m_layerForVerticalScrollbar.get(); }
GraphicsLayer* layerForScrollCorner() const { return m_layerForScrollCorner.get(); }
bool canCompositeFilters() const { return m_canCompositeFilters; }
#if ENABLE(FILTERS_LEVEL_2)
bool canCompositeBackdropFilters() const { return m_canCompositeBackdropFilters; }
#endif
// Return an estimate of the backing store area (in pixels) allocated by this object's GraphicsLayers.
WEBCORE_EXPORT double backingStoreMemoryEstimate() const;
// For testing only.
WEBCORE_EXPORT void setUsesDisplayListDrawing(bool);
WEBCORE_EXPORT String displayListAsText(DisplayList::AsTextFlags) const;
WEBCORE_EXPORT void setIsTrackingDisplayListReplay(bool);
WEBCORE_EXPORT String replayDisplayListAsText(DisplayList::AsTextFlags) const;
private:
friend class PaintedContentsInfo;
FloatRect backgroundBoxForSimpleContainerPainting() const;
void createPrimaryGraphicsLayer();
void destroyGraphicsLayers();
void willDestroyLayer(const GraphicsLayer*);
LayoutRect compositedBoundsIncludingMargin() const;
std::unique_ptr<GraphicsLayer> createGraphicsLayer(const String&, GraphicsLayer::Type = GraphicsLayer::Type::Normal);
RenderLayerModelObject& renderer() const { return m_owningLayer.renderer(); }
RenderBox* renderBox() const { return m_owningLayer.renderBox(); }
RenderLayerCompositor& compositor() const { return m_owningLayer.compositor(); }
void updateInternalHierarchy();
bool updateAncestorClippingLayer(bool needsAncestorClip);
bool updateDescendantClippingLayer(bool needsDescendantClip);
bool updateOverflowControlsLayers(bool needsHorizontalScrollbarLayer, bool needsVerticalScrollbarLayer, bool needsScrollCornerLayer);
bool updateForegroundLayer(bool needsForegroundLayer);
bool updateBackgroundLayer(bool needsBackgroundLayer);
void updateMaskingLayer(bool hasMask, bool hasClipPath);
bool requiresHorizontalScrollbarLayer() const;
bool requiresVerticalScrollbarLayer() const;
bool requiresScrollCornerLayer() const;
bool updateScrollingLayers(bool scrollingLayers);
void updateChildClippingStrategy(bool needsDescendantsClippingLayer);
void updateMaskingLayerGeometry();
void updateRootLayerConfiguration();
void setBackgroundLayerPaintsFixedRootBackground(bool);
GraphicsLayerPaintingPhase paintingPhaseForPrimaryLayer() const;
LayoutSize contentOffsetInCompostingLayer() const;
// Result is transform origin in device pixels.
FloatPoint3D computeTransformOriginForPainting(const LayoutRect& borderBox) const;
void updateOpacity(const RenderStyle&);
void updateTransform(const RenderStyle&);
void updateFilters(const RenderStyle&);
#if ENABLE(FILTERS_LEVEL_2)
void updateBackdropFilters(const RenderStyle&);
void updateBackdropFiltersGeometry();
#endif
#if ENABLE(CSS_COMPOSITING)
void updateBlendMode(const RenderStyle&);
#endif
void updateCustomAppearance(const RenderStyle&);
// Return the opacity value that this layer should use for compositing.
float compositingOpacity(float rendererOpacity) const;
Color rendererBackgroundColor() const;
bool isMainFrameRenderViewLayer() const;
bool paintsBoxDecorations() const;
bool paintsContent(RenderLayer::PaintedContentRequest&) const;
void updateDrawsContent(PaintedContentsInfo&);
// Returns true if this compositing layer has no visible content.
bool isSimpleContainerCompositingLayer(PaintedContentsInfo&) const;
// Returns true if this layer has content that needs to be rendered by painting into the backing store.
bool containsPaintedContent(PaintedContentsInfo&) const;
// Returns true if the RenderLayer just contains an image that we can composite directly.
bool isDirectlyCompositedImage() const;
void updateImageContents(PaintedContentsInfo&);
void updateDirectlyCompositedBoxDecorations(PaintedContentsInfo&, bool& didUpdateContentsRect);
void updateDirectlyCompositedBackgroundColor(PaintedContentsInfo&, bool& didUpdateContentsRect);
void updateDirectlyCompositedBackgroundImage(PaintedContentsInfo&, bool& didUpdateContentsRect);
void resetContentsRect();
bool isPaintDestinationForDescendantLayers(RenderLayer::PaintedContentRequest&) const;
bool hasVisibleNonCompositedDescendants() const;
bool shouldClipCompositedBounds() const;
bool hasTiledBackingFlatteningLayer() const { return (m_childContainmentLayer && m_isFrameLayerWithTiledBacking); }
GraphicsLayer* tileCacheFlatteningLayer() const { return m_isFrameLayerWithTiledBacking ? m_childContainmentLayer.get() : nullptr; }
void paintIntoLayer(const GraphicsLayer*, GraphicsContext&, const IntRect& paintDirtyRect, PaintBehavior, GraphicsLayerPaintingPhase);
static CSSPropertyID graphicsLayerToCSSProperty(AnimatedPropertyID);
static AnimatedPropertyID cssToGraphicsLayerProperty(CSSPropertyID);
bool canIssueSetNeedsDisplay() const { return !paintsIntoWindow() && !paintsIntoCompositedAncestor(); }
LayoutRect computeParentGraphicsLayerRect(RenderLayer* compositedAncestor, LayoutSize& ancestorClippingLayerOffset) const;
LayoutRect computePrimaryGraphicsLayerRect(const LayoutRect& parentGraphicsLayerRect) const;
RenderLayer& m_owningLayer;
std::unique_ptr<GraphicsLayer> m_ancestorClippingLayer; // Only used if we are clipped by an ancestor which is not a stacking context.
std::unique_ptr<GraphicsLayer> m_contentsContainmentLayer; // Only used if we have a background layer; takes the transform.
std::unique_ptr<GraphicsLayer> m_graphicsLayer;
std::unique_ptr<GraphicsLayer> m_foregroundLayer; // Only used in cases where we need to draw the foreground separately.
std::unique_ptr<GraphicsLayer> m_backgroundLayer; // Only used in cases where we need to draw the background separately.
std::unique_ptr<GraphicsLayer> m_childContainmentLayer; // Only used if we have clipping on a stacking context with compositing children, or if the layer has a tile cache.
std::unique_ptr<GraphicsLayer> m_maskLayer; // Only used if we have a mask and/or clip-path.
std::unique_ptr<GraphicsLayer> m_childClippingMaskLayer; // Only used if we have to clip child layers or accelerated contents with border radius or clip-path.
std::unique_ptr<GraphicsLayer> m_layerForHorizontalScrollbar;
std::unique_ptr<GraphicsLayer> m_layerForVerticalScrollbar;
std::unique_ptr<GraphicsLayer> m_layerForScrollCorner;
std::unique_ptr<GraphicsLayer> m_scrollingLayer; // Only used if the layer is using composited scrolling.
std::unique_ptr<GraphicsLayer> m_scrollingContentsLayer; // Only used if the layer is using composited scrolling.
LayoutRect m_compositedBounds;
LayoutSize m_subpixelOffsetFromRenderer; // This is the subpixel distance between the primary graphics layer and the associated renderer's bounds.
LayoutSize m_compositedBoundsOffsetFromGraphicsLayer; // This is the subpixel distance between the primary graphics layer and the render layer bounds.
ScrollingNodeID m_viewportConstrainedNodeID { 0 };
ScrollingNodeID m_scrollingNodeID { 0 };
bool m_artificiallyInflatedBounds { false }; // bounds had to be made non-zero to make transform-origin work
bool m_isMainFrameRenderViewLayer { false };
bool m_isFrameLayerWithTiledBacking { false };
bool m_requiresOwnBackingStore { true };
bool m_canCompositeFilters { false };
#if ENABLE(FILTERS_LEVEL_2)
bool m_canCompositeBackdropFilters { false };
#endif
bool m_backgroundLayerPaintsFixedRootBackground { false };
bool m_paintsSubpixelAntialiasedText { false }; // This is for logging only.
};
enum CanvasCompositingStrategy {
UnacceleratedCanvas,
CanvasPaintedToLayer,
CanvasAsLayerContents
};
CanvasCompositingStrategy canvasCompositingStrategy(const RenderObject&);
WTF::TextStream& operator<<(WTF::TextStream&, const RenderLayerBacking&);
} // namespace WebCore
| 45.934837 | 175 | 0.777226 | [
"render",
"object",
"transform"
] |
344b5a684604c3a31851f9b020ec6e6b8e39284c | 7,463 | c | C | ANL-TD-Iterative-Pflow/pflow-helics-dist.c | GMLC-TDC/Use-Cases | 14d687fe04af731c1ee466e05acfd5813095660a | [
"BSD-3-Clause"
] | 1 | 2021-01-04T07:27:34.000Z | 2021-01-04T07:27:34.000Z | ANL-TD-Iterative-Pflow/pflow-helics-dist.c | GMLC-TDC/Use-Cases | 14d687fe04af731c1ee466e05acfd5813095660a | [
"BSD-3-Clause"
] | null | null | null | ANL-TD-Iterative-Pflow/pflow-helics-dist.c | GMLC-TDC/Use-Cases | 14d687fe04af731c1ee466e05acfd5813095660a | [
"BSD-3-Clause"
] | 2 | 2019-08-01T21:49:40.000Z | 2019-09-23T19:30:36.000Z | static char help[] = "This code implements the distribution federate of the T-D power flow use-case. A global convergence for the federation is implemented in this use-case. The The distribution federate obtains the upstream distribution substation voltage from transmission federate, solves power flow, and sends the updated injection into transmission. This code does not use HELICS iterative API\n\n";
#include <petsc.h>
#include <ValueFederate.h>
#include <opendss.h>
#include <complex.h>
typedef struct {
helics_federate vfed;
helics_publication pub;
helics_subscription sub;
helics_time_t currenttime;
helics_iteration_status currenttimeiter;
char pub_topic[PETSC_MAX_PATH_LEN];
} UserData;
helics_status CreateDistributionFederate(helics_federate *distfed,char* pub_topic)
{
helics_federate_info_t fedinfo;
helics_status status;
const char* fedinitstring="--federates=1";
helics_federate vfed;
char fedname[PETSC_MAX_PATH_LEN];
PetscErrorCode ierr;
/* Create Federate Info object that describes the federate properties */
fedinfo = helicsFederateInfoCreate();
ierr = PetscStrcpy(fedname,"Distribution Federate ");CHKERRQ(ierr);
ierr = PetscStrcat(fedname,pub_topic);CHKERRQ(ierr);
/* Set Federate name */
status = helicsFederateInfoSetFederateName(fedinfo,fedname);
/* Set core type from string */
status = helicsFederateInfoSetCoreTypeFromString(fedinfo,"zmq");
/* Federate init string */
status = helicsFederateInfoSetCoreInitString(fedinfo,fedinitstring);
/* Set the message interval (timedelta) for federate. Note that
HELICS minimum message time interval is 1 ns and by default
it uses a time delta of 1 second. What is provided to the
setTimedelta routine is a multiplier for the default timedelta.
*/
/* Set one second message interval */
status = helicsFederateInfoSetTimeDelta(fedinfo,1.0);
status = helicsFederateInfoSetLoggingLevel(fedinfo,1);
status = helicsFederateInfoSetMaxIterations(fedinfo,100);
/* Create value federate */
vfed = helicsCreateValueFederate(fedinfo);
*distfed = vfed;
return status;
}
int main(int argc,char **argv)
{
PetscErrorCode ierr;
const char* helicsversion;
UserData user;
helics_status status;
PetscBool flg;
char netfile[PETSC_MAX_PATH_LEN],dcommand[PETSC_MAX_PATH_LEN];
char sub_topic[PETSC_MAX_PATH_LEN];
double complex *Stotal;
PetscInt iter=0;
PetscScalar Vm,Va;
PetscScalar Pg,Qg,Pgprv,Qgprv;
PetscInt pflowT_conv=0,pflowD_conv=0,global_conv=0;
char pubstr[PETSC_MAX_PATH_LEN],substr[PETSC_MAX_PATH_LEN];
PetscInt strlen;
PetscReal tol=1E-6,mis;
PetscInitialize(&argc,&argv,NULL,help);
helicsversion = helicsGetVersion();
printf("D FED: Helics version = %s\n",helicsversion);
/* Get network data file from command line */
ierr = PetscOptionsGetString(NULL,NULL,"-netfile",netfile,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
ierr = PetscSNPrintf(dcommand,PETSC_MAX_PATH_LEN-1,"Redirect ");CHKERRQ(ierr);
ierr = PetscStrcat(dcommand,netfile);CHKERRQ(ierr);
/* Load the D file */
ierr = OpenDSSRunCommand(dcommand);CHKERRQ(ierr);
flg = PETSC_FALSE;
/* Get the distribution topic for publication stream */
ierr = PetscOptionsGetString(NULL,NULL,"-dtopic",user.pub_topic,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if(!flg) {
SETERRQ(PETSC_COMM_SELF,0,"Need to specify the publication name, option -dtopic <topic_name>.\n This is same as the distribution feeder file name without the extension");
}
/* Create distribution federate */
status = CreateDistributionFederate(&user.vfed,user.pub_topic);
printf("Created D FEDERATE %s\n",user.pub_topic);
/* Register the publication */
user.pub = helicsFederateRegisterGlobalPublication(user.vfed,user.pub_topic,"string","");
printf("D FEDERATE %s: Publication registered\n",user.pub_topic);
/* Subscribe to transmission federate's publication */
ierr = PetscStrcpy(sub_topic,"Trans/");
ierr = PetscStrcat(sub_topic,user.pub_topic);
user.sub = helicsFederateRegisterSubscription(user.vfed,sub_topic,"string","");
printf("D FEDERATE %s: Subscription registered\n",user.pub_topic);
status = helicsFederateEnterInitializationMode(user.vfed);
printf("D FEDERATE %s: Entered initialization mode\n",user.pub_topic);
user.currenttime = 0.0;
user.currenttimeiter = iterating;
PetscInt solve;
/* Solve power flow */
// printf("D FEDERATE %s running power flow\n",user.pub_topic);
ierr = OpenDSSSolutionGetSolve(&solve);CHKERRQ(ierr);
/* Send power injection to transmission */
/* Get the net injection at the boundary bus */
ierr = OpenDSSCircuitGetTotalPower(&Stotal);CHKERRQ(ierr);
Pgprv = -creal(Stotal[0])/1000.0; /* Conversion to MW */
Qgprv = -cimag(Stotal[0])/1000.0;
ierr = PetscSNPrintf(pubstr,PETSC_MAX_PATH_LEN-1,"%18.16f,%18.16f,%d",Pgprv,Qgprv,pflowD_conv);CHKERRQ(ierr);
status = helicsPublicationPublishString(user.pub,pubstr);
// printf("D FEDERATE %s sent Pg = %4.3f, Qg = %4.3f, conv = %d from T FEDERATE\n",user.pub_topic,Pgprv,Qgprv,pflowD_conv);
status = helicsFederateEnterExecutionMode(user.vfed);
printf("D FEDERATE %s: Entered execution mode\n",user.pub_topic);
while(user.currenttimeiter == iterating) {
iter++;
status = helicsSubscriptionGetString(user.sub,substr,PETSC_MAX_PATH_LEN-1,&strlen);
sscanf(substr,"%lf,%lf,%d",&Vm,&Va,&pflowT_conv);
// printf("D FEDERATE %s received Vm = %4.3f, Va = %4.3f, conv = %d from T FEDERATE\n",user.pub_topic,Vm,Va,pflowT_conv);
global_conv = pflowT_conv & pflowD_conv;
if(global_conv) {
helicsFederateRequestTimeIterative(user.vfed,user.currenttime,no_iteration,&user.currenttime,&user.currenttimeiter);
} else {
/* Set source bus voltage */
ierr = OpenDSSVsourcesSetPU(Vm);CHKERRQ(ierr);
ierr = OpenDSSVsourcesSetAngleDeg(Va);CHKERRQ(ierr);
/* 2. Solve power flow */
// printf("D FEDERATE %s running power flow\n",user.pub_topic);
ierr = OpenDSSSolutionGetSolve(&solve);CHKERRQ(ierr);
/* Send power injection to transmission */
/* Get the net injection at the boundary bus */
ierr = OpenDSSCircuitGetTotalPower(&Stotal);CHKERRQ(ierr);
Pg = -creal(Stotal[0])/1000.0; /* Conversion to MW */
Qg = -cimag(Stotal[0])/1000.0;
mis = PetscSqrtScalar((Pg-Pgprv)/100*(Pg-Pgprv)/100 + (Qg-Qgprv)/100*(Qg-Qgprv)/100); /* Divide by 100 for conversion to pu */
if(mis < tol) {
pflowD_conv = 1;
} else {
pflowD_conv = 0;
Pgprv = Pg;
Qgprv = Qg;
}
ierr = PetscSNPrintf(pubstr,PETSC_MAX_PATH_LEN-1,"%18.16f,%18.16f,%d",Pg,Qg,pflowD_conv);CHKERRQ(ierr);
status = helicsPublicationPublishString(user.pub,pubstr);
// printf("D FEDERATE %s sent Pg = %4.3f, Qg = %4.3f, conv = %d to T FEDERATE\n",user.pub_topic,Pg,Qg,pflowD_conv);
fflush(NULL);
/*3. Publish Pg, Qg, and convergence status to transmission */
status = helicsFederateRequestTimeIterative(user.vfed,user.currenttime,force_iteration,&user.currenttime,&user.currenttimeiter);
printf("Iteration %d: D Federate %s mis = %g,converged = %d\n",iter,user.pub_topic,mis,pflowD_conv);
}
}
status = helicsFederateEnterExecutionModeComplete(user.vfed);
status = helicsFederateFinalize(user.vfed);
PetscFinalize();
return 0;
}
| 38.271795 | 404 | 0.717138 | [
"object"
] |
344dbb754dad1336961051d51db2af02b51f878b | 16,523 | c | C | wjt.c | tdukv/wjt | 086e2ba180605fe4375aded1e416f0790fd11bcd | [
"MIT"
] | null | null | null | wjt.c | tdukv/wjt | 086e2ba180605fe4375aded1e416f0790fd11bcd | [
"MIT"
] | null | null | null | wjt.c | tdukv/wjt | 086e2ba180605fe4375aded1e416f0790fd11bcd | [
"MIT"
] | null | null | null | /* See LICENSE file for copyright and license details. */
#include <ctype.h>
#include <locale.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#ifdef XINERAMA
#include <X11/extensions/Xinerama.h>
#endif
#include <X11/Xft/Xft.h>
#include <X11/Xresource.h>
#include "drw.h"
#include "util.h"
/* macros */
#define INTERSECT(x,y,w,h,r) (MAX(0, MIN((x)+(w),(r).x_org+(r).width) - MAX((x),(r).x_org)) \
* MAX(0, MIN((y)+(h),(r).y_org+(r).height) - MAX((y),(r).y_org)))
#define LENGTH(X) (sizeof X / sizeof X[0])
#define TEXTW(X) (drw_fontset_getwidth(drw, (X)) + lrpad)
#define MAXVAL 1000000000
#define VBUFSIZE 12 /* enough to hold negation of above */
#define VERROR " must be a resonably sized integer"
/* enums */
enum { SchemePrompt, SchemeSlider, SchemeValue, SchemeLast }; /* color schemes */
static char *embed;
static int sw, sh;
static int winx;
static int sx = 0;
static int promptw = 0;
static int lrpad; /* sum of left and right padding */
static int mon = -1, screen;
static char minstr[VBUFSIZE];
static char maxstr[VBUFSIZE];
static char valstr[VBUFSIZE];
static int minw;
static int maxw;
static int valw;
static int valx;
static int valout;
static int val = MAXVAL + 1;
static Display *dpy;
static Window root, parentwin, win;
static XIC xic;
static Drw *drw;
static Clr *scheme[SchemeLast];
#include "config.h"
static void
quit(int status)
{
size_t i;
XUngrabKeyboard(dpy, CurrentTime);
XUngrabPointer(dpy, CurrentTime);
for (i = 0; i < SchemeLast; i++)
free(scheme[i]);
drw_free(drw);
XSync(dpy, False);
XCloseDisplay(dpy);
exit(status);
}
static float
lerp(float a0, float a1, float b0, float b1, float x)
{
return a0 + (a1 - a0) * (x - b0) / (b1 - b0);
}
static void
drawslider(void)
{
drw_setscheme(drw, scheme[SchemeSlider]);
drw_rect(drw, 0, 0, sw, sh, 1, 1);
if (prompt && *prompt) {
drw_setscheme(drw, scheme[SchemePrompt]);
drw_text(drw, 0, 0, promptw, sh, lrpad / 2, prompt, 1, 0);
}
drw_setscheme(drw, scheme[SchemeValue]);
drw_rect(drw, sx, 0, valx, sh, 1, 1);
if (labelval)
drw_text(drw, sx + (sw - sx) / 2 - valw / 2, 0, valw, sh, lrpad / 2, valstr, 0, 0);
if (labelexts) {
drw_setscheme(drw, scheme[SchemeSlider]);
drw_text(drw, sx, 0, minw, sh, lrpad / 2, minstr, 0, 0);
drw_text(drw, sw - maxw, 0, maxw, sh, lrpad / 2, maxstr, 0, 0);
}
drw_map(drw, win, 0, 0, sw, sh);
}
static void
grabfocus(void)
{
struct timespec ts = { .tv_sec = 0, .tv_nsec = 10000000 };
Window focuswin;
int i, revertwin;
for (i = 0; i < 100; ++i) {
XGetInputFocus(dpy, &focuswin, &revertwin);
if (focuswin == win)
return;
XSetInputFocus(dpy, win, RevertToParent, CurrentTime);
nanosleep(&ts, NULL);
}
die("cannot grab focus");
}
static void
grabinput(void)
{
struct timespec ts = { .tv_sec = 0, .tv_nsec = 1000000 };
int ownkbd = 0;
int ownptr = 0;
int i;
if (embed)
return;
/* try to grab keyboard and pointer, we may have to wait for another process to ungrab */
for (i = 0; i < 1000; i++) {
if (!ownkbd)
ownkbd = (XGrabKeyboard(dpy, DefaultRootWindow(dpy), True, GrabModeAsync,
GrabModeAsync, CurrentTime) == GrabSuccess);
if (!ownptr)
ownptr = (XGrabPointer(dpy, DefaultRootWindow(dpy), True,
ButtonPressMask | ButtonReleaseMask | Button1MotionMask,
GrabModeAsync, GrabModeAsync, None, None,
CurrentTime) == GrabSuccess);
if (ownkbd && ownptr)
return;
nanosleep(&ts, NULL);
}
if (!ownkbd)
die("cannot grab keyboard");
die("cannot grab pointer");
}
static void
val2str(char * str, int val)
{
if (timeformat) {
int h, m, s, w=0;
if (val < 0) {
str[w++] = '-';
val = -val;
}
h = val / 3600;
m = (val % 3600) / 60;
s = val % 60;
if (h) {
w+=snprintf(str+w, VBUFSIZE, "%d:", h);
w+=snprintf(str+w, VBUFSIZE, "%02d:", m);
} else {
w+=snprintf(str+w, VBUFSIZE, "%d:", m);
}
w+=snprintf(str+w, VBUFSIZE, "%02d", s);
} else {
snprintf(str, VBUFSIZE, "%d", val);
}
}
static void
adjustval(int v)
{
if (v < min)
v = min;
else if (v > max)
v = max;
valx = (int)lerp(0, sw - 1 - sx, min, max, v);
if (v != val) {
val = v;
val2str(valstr, val);
valw = TEXTW(valstr);
}
}
static void
updateval(int v)
{
adjustval(v);
if (val != valout) {
valout = val;
puts(valstr);
fflush(stdout);
}
}
static void
xtoval(int x)
{
float fv;
int v;
fv = lerp(min, max, sx, sw - 1, x);
v = (int)fv;
if (v > min && v < max) {
v = (int)(fv / step + copysignf(0.5, fv)) * step;
}
updateval(v);
}
static void
printspecial(void)
{
if (special && *special) {
puts(special);
fflush(stdout);
}
}
static void
keypress(XKeyEvent *ev)
{
char buf[32];
KeySym ksym = NoSymbol;
Status status;
XmbLookupString(xic, ev, buf, sizeof buf, &ksym, &status);
if (status == XBufferOverflow)
return;
if (ev->state & ControlMask) {
switch(ksym) {
case XK_a:
ksym = XK_Home;
break;
case XK_b:
ksym = XK_Left;
break;
case XK_c:
case XK_bracketleft:
ksym = XK_Escape;
break;
case XK_e:
ksym = XK_End;
break;
case XK_f:
ksym = XK_Right;
break;
case XK_p:
ksym = XK_Down;
break;
case XK_n:
ksym = XK_Up;
break;
case XK_j:
case XK_m:
ksym = XK_Return;
break;
default:
return;
}
}
switch(ksym) {
case XK_space:
printspecial();
break;
case XK_KP_Enter:
case XK_Return:
quit(0);
case XK_Escape:
quit(1);
case XK_h:
case XK_minus:
case XK_Left:
updateval(val - step);
break;
case XK_l:
case XK_plus:
case XK_equal:
case XK_Right:
updateval(val + step);
break;
case XK_j:
case XK_Down:
case XK_Page_Down:
updateval(val - jump);
break;
case XK_k:
case XK_Up:
case XK_Page_Up:
updateval(val + jump);
break;
case XK_g:
case XK_Home:
updateval(min);
break;
case XK_G:
case XK_End:
updateval(max);
break;
/* map number row to deciles */
case XK_grave: updateval(min); break;
case XK_1: updateval(min + 1 * (max - min) / 10); break;
case XK_2: updateval(min + 2 * (max - min) / 10); break;
case XK_3: updateval(min + 3 * (max - min) / 10); break;
case XK_4: updateval(min + 4 * (max - min) / 10); break;
case XK_5: updateval(min + 5 * (max - min) / 10); break;
case XK_6: updateval(min + 6 * (max - min) / 10); break;
case XK_7: updateval(min + 7 * (max - min) / 10); break;
case XK_8: updateval(min + 8 * (max - min) / 10); break;
case XK_9: updateval(min + 9 * (max - min) / 10); break;
case XK_0: updateval(max); break;
default:
return;
}
drawslider();
}
static void
buttonpress(XButtonPressedEvent *ev)
{
switch (ev->button) {
case Button1:
xtoval(ev->x_root - winx);
break;
case Button4:
updateval(val + (ev->state & ControlMask ? jump : step));
break;
case Button5:
updateval(val - (ev->state & ControlMask ? jump : step));
break;
default:
return;
}
drawslider();
}
static void
buttonrelease(XButtonReleasedEvent *ev)
{
switch (ev->button) {
case Button1:
xtoval(ev->x_root - winx);
break;
case Button2:
printspecial();
return;
case Button3:
quit(0);
default:
return;
}
drawslider();
}
static void
buttonmove(XMotionEvent *ev)
{
xtoval(ev->x_root - winx);
drawslider();
}
static void
run(void)
{
XEvent ev;
while (!XNextEvent(dpy, &ev)) {
if (XFilterEvent(&ev, win))
continue;
switch(ev.type) {
case DestroyNotify:
if (ev.xdestroywindow.window != win)
break;
quit(1);
case Expose:
if (ev.xexpose.count == 0)
drw_map(drw, win, 0, 0, sw, sh);
break;
case FocusIn:
/* regrab focus from parent window */
if (ev.xfocus.window != win)
grabfocus();
break;
case KeyPress:
keypress(&ev.xkey);
break;
case ButtonPress:
buttonpress(&ev.xbutton);
break;
case ButtonRelease:
buttonrelease(&ev.xbutton);
break;
case MotionNotify:
buttonmove(&ev.xmotion);
break;
case VisibilityNotify:
if (ev.xvisibility.state != VisibilityUnobscured)
XRaiseWindow(dpy, win);
break;
}
}
}
static void
setup(void)
{
int x, y, i = 0;
unsigned int du;
XSetWindowAttributes swa;
XIM xim;
Window w, dw, *dws;
XWindowAttributes wa;
XClassHint ch = {"wjt", "wjt"};
#ifdef XINERAMA
XineramaScreenInfo *info;
Window pw;
int a, j, di, n, area = 0;
#endif
/* init appearance */
scheme[SchemeSlider] = drw_scm_create(drw, colors[SchemeSlider], 2);
scheme[SchemePrompt] = drw_scm_create(drw, colors[SchemePrompt], 2);
scheme[SchemeValue] = drw_scm_create(drw, colors[SchemeValue], 2);
/* calculate slider geometry */
sh = drw->fonts->h + 2;
#ifdef XINERAMA
if (parentwin == root && (info = XineramaQueryScreens(dpy, &n))) {
XGetInputFocus(dpy, &w, &di);
if (mon >= 0 && mon < n)
i = mon;
else if (w != root && w != PointerRoot && w != None) {
/* find top-level window containing current input focus */
do {
if (XQueryTree(dpy, (pw = w), &dw, &w, &dws, &du) && dws)
XFree(dws);
} while (w != root && w != pw);
/* find xinerama screen with which the window intersects most */
if (XGetWindowAttributes(dpy, pw, &wa))
for (j = 0; j < n; j++)
if ((a = INTERSECT(wa.x, wa.y, wa.width, wa.height, info[j])) > area) {
area = a;
i = j;
}
}
/* no focused window is on screen, so use pointer location instead */
if (mon < 0 && !area && XQueryPointer(dpy, root, &dw, &dw, &x, &y, &di, &di, &du))
for (i = 0; i < n; i++)
if (INTERSECT(x, y, 1, 1, info[i]))
break;
if (!position) {
sw = width;
x = info[i].x_org + ((info[i].width - sw) / 2);
y = info[i].y_org + ((info[i].height - sh) / 2);
} else {
x = info[i].x_org;
y = info[i].y_org + ( (position & 1) ? 0 : info[i].height - sh - 2*border_width_e);
sw = info[i].width - 2*border_width_e;
}
XFree(info);
} else
#endif
{
if (!XGetWindowAttributes(dpy, parentwin, &wa))
die("could not get embedding window attributes: 0x%lx",
parentwin);
if (!position) {
sw = width;
x = (wa.width - sw) / 2;
y = (wa.height - sh) / 2;
} else {
x = 0;
y = (position & 1) ? 0 : wa.height - sh - 2*border_width_e;
sw = wa.width - 2*border_width_e;
}
}
winx = x;
if (prompt && *prompt) {
promptw = TEXTW(prompt);
sx = promptw + lrpad / 4;
}
/* create slider window */
swa.override_redirect = True;
swa.background_pixel = scheme[SchemeSlider][ColBg].pixel;
swa.event_mask = ExposureMask | KeyPressMask | ButtonPressMask | ButtonReleaseMask |
Button1MotionMask | VisibilityChangeMask;
win = XCreateWindow(dpy, parentwin, x, y, sw, sh,
(position ? border_width_e : border_width_c),
CopyFromParent, CopyFromParent, CopyFromParent,
CWOverrideRedirect | CWBackPixel | CWEventMask, &swa);
XSetWindowBorder(dpy, win, scheme[SchemePrompt][ColBg].pixel);
XSetClassHint(dpy, win, &ch);
/* input methods */
if ((xim = XOpenIM(dpy, NULL, NULL, NULL)) == NULL)
die("XOpenIM failed: could not open input device");
xic = XCreateIC(xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
XNClientWindow, win, XNFocusWindow, win, NULL);
XMapRaised(dpy, win);
if (embed) {
XSelectInput(dpy, parentwin, FocusChangeMask | SubstructureNotifyMask);
if (XQueryTree(dpy, parentwin, &dw, &w, &dws, &du) && dws) {
for (i = 0; i < du && dws[i] != win; ++i)
XSelectInput(dpy, dws[i], FocusChangeMask);
XFree(dws);
}
grabfocus();
}
drw_resize(drw, sw, sh);
adjustval(initval);
val2str(minstr, min);
val2str(maxstr, max);
minw = TEXTW(minstr);
maxw = TEXTW(maxstr);
drawslider();
}
static void
usage(void)
{
fputs("usage: wjt [-v] [-b] [-c ] [-lv] [-le] [-wd width] [-m monnum] [-w winid] [-p prompt]\n"
" [-l lower] [-u upper] [-s step]\n"
" [-j jump] [-x value] [-z special]\n", stderr);
exit(1);
}
void
readxresources(void) {
XrmInitialize();
char* xrm;
if (!(xrm = XResourceManagerString(drw->dpy)))
return;
char *type;
XrmDatabase xdb = XrmGetStringDatabase(xrm);
XrmValue xval;
if (XrmGetResource(xdb, "wjt.font", "*", &type, &xval))
fonts[0] = strdup(xval.addr);
else
fonts[0] = strdup(fonts[0]);
if (XrmGetResource(xdb, "wjt.promptbg", "*", &type, &xval))
colors[SchemePrompt][ColBg] = strdup(xval.addr);
else
colors[SchemePrompt][ColBg] = strdup(colors[SchemePrompt][ColBg]);
if (XrmGetResource(xdb, "wjt.promptfg", "*", &type, &xval))
colors[SchemePrompt][ColFg] = strdup(xval.addr);
else
colors[SchemePrompt][ColFg] = strdup(colors[SchemePrompt][ColFg]);
if (XrmGetResource(xdb, "wjt.sliderbg", "*", &type, &xval))
colors[SchemeSlider][ColBg] = strdup(xval.addr);
else
colors[SchemeSlider][ColBg] = strdup(colors[SchemeSlider][ColBg]);
if (XrmGetResource(xdb, "wjt.sliderfg", "*", &type, &xval))
colors[SchemeSlider][ColFg] = strdup(xval.addr);
else
colors[SchemeSlider][ColFg] = strdup(colors[SchemeSlider][ColFg]);
if (XrmGetResource(xdb, "wjt.valuebg", "*", &type, &xval))
colors[SchemeValue][ColBg] = strdup(xval.addr);
else
colors[SchemeValue][ColBg] = strdup(colors[SchemeValue][ColBg]);
if (XrmGetResource(xdb, "wjt.valuefg", "*", &type, &xval))
colors[SchemeValue][ColFg] = strdup(xval.addr);
else
colors[SchemeValue][ColFg] = strdup(colors[SchemeValue][ColFg]);
}
static int
valarg(char *arg, int *ok)
{
long x;
char *p;
x = strtol(arg, &p, 0);
while (p[0] == ':') {
x *= 60;
if (x < 0)
x -= strtol(++p, &p, 0);
else
x += strtol(++p, &p, 0);
}
if (ok) {
*ok = (p != arg && labs(x) <= MAXVAL);
}
return x;
}
int
main(int argc, char *argv[])
{
XWindowAttributes wa;
int i;
int ok;
for (i = 1; i < argc; i++) {
/* these options take no arguments */
if (!strcmp(argv[i], "-v")) {
puts("wjt-"VERSION);
exit(0);
} else if (!strcmp(argv[i], "-b")) { /* bottom */
position = 2;
} else if (!strcmp(argv[i], "-t")) { /* top */
position = 1;
} else if (!strcmp(argv[i], "-c")) { /* centered */
position = 0;
}
else if (!strcmp(argv[i], "-lv")) /* invert whether to display value label */
labelval = !labelval;
else if (!strcmp(argv[i], "-le")) /* invert whether to display extent labels */
labelexts = !labelexts;
else if (!strcmp(argv[i], "-tf")) /* use hh:mm:ss */
timeformat = !timeformat;
else if (i + 1 == argc)
usage();
/* these options take one argument */
else if (!strcmp(argv[i], "-wd")) /* monitor number */
width = atoi(argv[++i]);
else if (!strcmp(argv[i], "-m")) /* monitor number */
mon = atoi(argv[++i]);
else if (!strcmp(argv[i], "-w")) /* embedding window id */
embed = argv[++i];
else if (!strcmp(argv[i], "-p")) /* adds prompt to left of slider */
prompt = argv[++i];
else if (!strcmp(argv[i], "-l")) { /* lower bound */
min = valarg(argv[++i], &ok);
if (!ok)
die("lower bound"VERROR);
} else if (!strcmp(argv[i], "-u")) { /* upper bound */
max = valarg(argv[++i], &ok);
if (!ok)
die("upper bound"VERROR);
} else if (!strcmp(argv[i], "-j")) { /* jump */
jump = valarg(argv[++i], &ok);
if (!ok)
die("jump"VERROR);
} else if (!strcmp(argv[i], "-s")) { /* step */
step = valarg(argv[++i], &ok);
if (!ok)
die("step"VERROR);
} else if (!strcmp(argv[i], "-x")) { /* initial value */
initval = valarg(argv[++i], &ok);
valout = initval;
if (!ok)
die("initial value"VERROR);
} else if (!strcmp(argv[i], "-z")) /* special text */
special = argv[++i];
else
usage();
}
if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
fputs("warning: no locale support\n", stderr);
if (!(dpy = XOpenDisplay(NULL)))
die("cannot open display");
screen = DefaultScreen(dpy);
root = RootWindow(dpy, screen);
if (!embed || !(parentwin = strtol(embed, NULL, 0)))
parentwin = root;
if (!XGetWindowAttributes(dpy, parentwin, &wa))
die("could not get embedding window attributes: 0x%lx",
parentwin);
drw = drw_create(dpy, screen, root, wa.width, wa.height);
readxresources();
if (!drw_fontset_create(drw, fonts, LENGTH(fonts)))
die("no fonts could be loaded.");
lrpad = drw->fonts->h;
if (max <= min)
die("upper bound must be greater than lower bound");
if (step < 1)
die("step must be positive");
if (jump <= step)
die("jump must not be less than step");
grabinput();
setup();
run();
return 1; /* unreachable */
}
| 23.739943 | 96 | 0.61248 | [
"geometry"
] |
344f61366fcc5f4da79128b6ecb9318679a8cbc4 | 3,135 | c | C | usr/src/cmd/sgs/link_audit/common/symbindrep.c | AsahiOS/gate | 283d47da4e17a5871d9d575e7ffb81e8f6c52e51 | [
"MIT"
] | null | null | null | usr/src/cmd/sgs/link_audit/common/symbindrep.c | AsahiOS/gate | 283d47da4e17a5871d9d575e7ffb81e8f6c52e51 | [
"MIT"
] | null | null | null | usr/src/cmd/sgs/link_audit/common/symbindrep.c | AsahiOS/gate | 283d47da4e17a5871d9d575e7ffb81e8f6c52e51 | [
"MIT"
] | 1 | 2020-12-30T00:04:16.000Z | 2020-12-30T00:04:16.000Z | /*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <link.h>
#include "env.h"
static Elist *bindto_list = NULL;
static Elist *bindfrom_list = NULL;
static FILE *output = stdout;
uint_t
la_version(uint_t version)
{
if (version < LAV_CURRENT) {
(void) fprintf(stderr,
"symbindrep.so: unexpected version: %d\n", version);
return (0);
}
build_env_list(&bindto_list, (const char *)"SYMBINDREP_BINDTO");
build_env_list(&bindfrom_list, (const char *)"SYMBINDREP_BINDFROM");
#ifdef _LP64
(void) fprintf(output,
" Symbol Bindings\n\n"
"Referencing Defining\n"
"Object Object Symbol\n"
"---------------------------------------------------------------"
"-------------------\n");
#else
(void) fprintf(output,
" Symbol Bindings\n\n"
"Referencing Defining\n"
"Object Object Symbol\n"
"---------------------------------------------------------------"
"---\n");
#endif
return (LAV_CURRENT);
}
/* ARGSUSED1 */
uint_t
la_objopen(Link_map *lmp, Lmid_t lmid, uintptr_t *cookie)
{
uint_t flags;
if ((bindto_list == NULL) ||
(check_list(bindto_list, lmp->l_name)))
flags = LA_FLG_BINDTO;
else
flags = 0;
if ((bindfrom_list == NULL) ||
(check_list(bindfrom_list, lmp->l_name)))
flags |= LA_FLG_BINDFROM;
*cookie = (uintptr_t)lmp->l_name;
return (flags);
}
/* ARGSUSED1 */
#if defined(_LP64)
uintptr_t
la_symbind64(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcook,
uintptr_t *defcook, uint_t *sb_flags, const char *sym_name)
#else
uintptr_t
la_symbind32(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcook,
uintptr_t *defcook, uint_t *sb_flags)
#endif
{
#if !defined(_LP64)
const char *sym_name = (const char *)symp->st_name;
#endif
(void) fprintf(output, "%-28s %-28s %s\n", (char *)(*refcook),
(char *)(*defcook), sym_name);
return (symp->st_value);
}
/*
* Since we only want to report on the symbol bindings for this
* process and we *do not* want the actual program to run we exit
* at this point.
*/
/* ARGSUSED0 */
void
la_preinit(uintptr_t *cookie)
{
(void) fflush(output);
exit(0);
}
| 26.125 | 79 | 0.631898 | [
"object"
] |
e737126e2266eaa21b7d0c5b11e36cfef71bc75a | 5,450 | h | C | include/QuadRendererBase.h | gmalysa/gui2d | 0675d396b3f1e28073b77903026c3c797cd445b9 | [
"BSD-3-Clause"
] | null | null | null | include/QuadRendererBase.h | gmalysa/gui2d | 0675d396b3f1e28073b77903026c3c797cd445b9 | [
"BSD-3-Clause"
] | null | null | null | include/QuadRendererBase.h | gmalysa/gui2d | 0675d396b3f1e28073b77903026c3c797cd445b9 | [
"BSD-3-Clause"
] | null | null | null | #ifndef _QUAD_RENDERER_BASE_H_
#define _QUAD_RENDERER_BASE_H_
/**
* @class gui2d::QuadRendererBase
* This is a templated base class for rendering subclasses of iQuadRenderable that
* attempts to unify as much as possible and use CRTP-style programming to expose
* hooks to allow specific quad renderer types to make small adjustments to the
* overall rendering algorithm
*/
// Standard headers
#include <gl/glew.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_precision.hpp>
#include <stdint.h>
#include <set>
// Project definitions
#include "sks.h"
#include "Shader.h"
namespace gui2d {
/**
* @tparam T The derived class that extends this base class and contains implementations
* @tparam U The iQuadRenderable-descendent to be used for storage
*/
template <typename T, typename U>
class QuadRendererBase {
public:
typedef std::set<U*> RenderableSet; //! Set of quad renderable instances to draw
typedef typename RenderableSet::iterator RenderableIter; //! Iterator for the set of renderables
protected:
uint16_t _bufferSize; //! Size of arrays as allocated in memory
uint16_t _count; //! Number of quads that we are going to draw
bool _updateIndex; //! Flag indicating whether or not to re-push the index buffer
glm::i16vec3 *_vCoords; //! Coordinates are stored as x, y, z, but z is constant for a quad
GLushort *_index; //! Index buffers are used to reduce the memory requirements
GLuint _vao; //! OpenGL Vertex Array Object that is used for all quads
GLuint _vbo[2]; //! OpenGL Vertex Buffer Objects used to store index and vertex data
Shader *_shader; //! Shader that is used to draw
RenderableSet _drawItems; // List of quad renderables that we should draw each frame
public:
/**
* Initializes as much of the shared state as possible. Derived classes will need
* to initialize additional VBOs and bind all VBOs to shader locations
* @param s The shader to use to draw these quads
*/
QuadRendererBase(Shader *s) : _vCoords(0), _index(0), _shader(s), _bufferSize(0), _count(0),
_updateIndex(false), _vao(0) {
// Create buffers
glGenVertexArrays(1, &_vao);
glBindVertexArray(_vao);
glGenBuffers(2, _vbo);
// Bind the element buffer to vbo
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbo[1]);
glBindVertexArray(0);
}
/**
* Frees top level opengl resources and buffers that we control
*/
~QuadRendererBase(void) {
glBindVertexArray(_vao);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDeleteBuffers(2, _vbo);
glBindVertexArray(0);
glDeleteVertexArrays(1, &_vao);
if (_bufferSize > 0) {
free(_vCoords);
free(_index);
}
}
/**
* Adds the quad renderable to the drawing set
* @param r The Renderable to start drawing
*/
void show(U *r) {
std::pair<RenderableIter, bool> result = _drawItems.insert(r);
if (result.second) {
_count += r->getQuadCount();
ensureCapacity(_count);
}
}
/**
* Removes the quad renderable from the drawing set.
* @param r The Renderable to remove
*/
void hide(U *r) {
size_t count = _drawItems.erase(r);
if (count == 1)
_count -= r->getQuadCount();
}
/**
* Ensure that the coordinate arrays are large enough to handle a given number of
* entries all at once, to limit the number of memory operations that must be
* performed.
* @param quads The number of quads we need to be able to store
*/
void ensureCapacity(uint16_t quads) {
if (quads > _bufferSize) {
// Reallocate memory
_vCoords = static_cast<glm::i16vec3 *>(realloc(_vCoords, quads*4*sizeof(glm::i16vec3)));
_index = static_cast<GLushort *>(realloc(_index, quads*6*sizeof(GLushort)));
static_cast<T*>(this)->resizeBuffers(quads);
// Update indices for new values
for (uint16_t i = _bufferSize; i < quads; ++i) {
_index[6*i] = 4*i;
_index[6*i+1] = 4*i + 2;
_index[6*i+2] = 4*i + 3;
_index[6*i+3] = 4*i;
_index[6*i+4] = 4*i + 1;
_index[6*i+5] = 4*i + 2;
}
_bufferSize = quads;
_updateIndex = true;
}
}
/**
* To render, we iterate over the visible quads, update their information in our
* buffer if necessary, and then draw them.
*/
void render(void) {
bool updateVBO = false;
uint16_t offset = 0;
RenderableIter iter;
// Activate our shader program before doing anything else
_shader->use();
glBindVertexArray(_vao);
// Iterate over our tracked renderables and ask them for state updates
for (iter = _drawItems.begin(); iter != _drawItems.end(); ++iter) {
updateVBO = static_cast<T*>(this)->renderItem(iter, offset) || updateVBO;
offset += (*iter)->getQuadCount();
}
// Update GPU memory as appropriate
if (updateVBO) {
glBindBuffer(GL_ARRAY_BUFFER, _vbo[0]);
glBufferData(GL_ARRAY_BUFFER, _count*sizeof(glm::i16vec3)*4, _vCoords, GL_DYNAMIC_DRAW);
static_cast<T*>(this)->updateBuffers();
}
// Index buffers are reloaded separately
if (_updateIndex) {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vbo[2]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, _count*sizeof(GLushort)*6, _index, GL_DYNAMIC_DRAW);
}
// Draw the elements indexed if we have any visible
if (_count > 0) {
static_cast<T*>(this)->drawElements();
}
glBindVertexArray(0);
glUseProgram(0);
}
};
};
#endif
| 30.446927 | 98 | 0.678532 | [
"render",
"object"
] |
e74a4a8bcfbddf535aaede92d3cff91653d65c8e | 22,660 | c | C | xboot/src/external/cairo-1.12.14/cairo-png.c | LoongPenguin/Linux_210 | d941ed620798fb9c96b5d06764fb1dcb68057513 | [
"Apache-2.0"
] | 2 | 2016-05-26T06:54:21.000Z | 2021-05-09T18:05:50.000Z | addons/cairo/src/cairo-png.c | alvatar/sphere-fusion | f0bd78be9bbd42955677f3b8d73ccce167f7e486 | [
"Zlib"
] | null | null | null | addons/cairo/src/cairo-png.c | alvatar/sphere-fusion | f0bd78be9bbd42955677f3b8d73ccce167f7e486 | [
"Zlib"
] | 1 | 2019-03-16T08:46:46.000Z | 2019-03-16T08:46:46.000Z | /* cairo - a vector graphics library with display and print output
*
* Copyright © 2003 University of Southern California
*
* This library is free software; you can redistribute it and/or
* modify it either under the terms of the GNU Lesser General Public
* License version 2.1 as published by the Free Software Foundation
* (the "LGPL") or, at your option, under the terms of the Mozilla
* Public License Version 1.1 (the "MPL"). If you do not alter this
* notice, a recipient may use your version of this file under either
* the MPL or the LGPL.
*
* You should have received a copy of the LGPL along with this library
* in the file COPYING-LGPL-2.1; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
* You should have received a copy of the MPL along with this library
* in the file COPYING-MPL-1.1
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
* OF ANY KIND, either express or implied. See the LGPL or the MPL for
* the specific language governing rights and limitations.
*
* The Original Code is the cairo graphics library.
*
* The Initial Developer of the Original Code is University of Southern
* California.
*
* Contributor(s):
* Carl D. Worth <cworth@cworth.org>
* Kristian Høgsberg <krh@redhat.com>
* Chris Wilson <chris@chris-wilson.co.uk>
*/
#include "cairoint.h"
#include "cairo-error-private.h"
#include "cairo-image-surface-private.h"
#include "cairo-output-stream-private.h"
#include <stdio.h>
#include <errno.h>
#include <png.h>
/**
* SECTION:cairo-png
* @Title: PNG Support
* @Short_Description: Reading and writing PNG images
* @See_Also: #cairo_surface_t
*
* The PNG functions allow reading PNG images into image surfaces, and writing
* any surface to a PNG file.
*
* It is a toy API. It only offers very simple support for reading and
* writing PNG files, which is sufficient for testing and
* demonstration purposes. Applications which need more control over
* the generated PNG file should access the pixel data directly, using
* cairo_image_surface_get_data() or a backend-specific access
* function, and process it with another library, e.g. gdk-pixbuf or
* libpng.
**/
/**
* CAIRO_HAS_PNG_FUNCTIONS:
*
* Defined if the PNG functions are available.
* This macro can be used to conditionally compile code using the cairo
* PNG functions.
*
* Since: 1.0
**/
struct png_read_closure_t {
cairo_read_func_t read_func;
void *closure;
cairo_output_stream_t *png_data;
};
/* Unpremultiplies data and converts native endian ARGB => RGBA bytes */
static void
unpremultiply_data (png_structp png, png_row_infop row_info, png_bytep data)
{
unsigned int i;
for (i = 0; i < row_info->rowbytes; i += 4) {
uint8_t *b = &data[i];
uint32_t pixel;
uint8_t alpha;
memcpy (&pixel, b, sizeof (uint32_t));
alpha = (pixel & 0xff000000) >> 24;
if (alpha == 0) {
b[0] = b[1] = b[2] = b[3] = 0;
} else {
b[0] = (((pixel & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
b[1] = (((pixel & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha;
b[2] = (((pixel & 0x0000ff) >> 0) * 255 + alpha / 2) / alpha;
b[3] = alpha;
}
}
}
/* Converts native endian xRGB => RGBx bytes */
static void
convert_data_to_bytes (png_structp png, png_row_infop row_info, png_bytep data)
{
unsigned int i;
for (i = 0; i < row_info->rowbytes; i += 4) {
uint8_t *b = &data[i];
uint32_t pixel;
memcpy (&pixel, b, sizeof (uint32_t));
b[0] = (pixel & 0xff0000) >> 16;
b[1] = (pixel & 0x00ff00) >> 8;
b[2] = (pixel & 0x0000ff) >> 0;
b[3] = 0;
}
}
/* Use a couple of simple error callbacks that do not print anything to
* stderr and rely on the user to check for errors via the #cairo_status_t
* return.
*/
static void
png_simple_error_callback (png_structp png,
png_const_charp error_msg)
{
cairo_status_t *error = png_get_error_ptr (png);
/* default to the most likely error */
if (*error == CAIRO_STATUS_SUCCESS)
*error = _cairo_error (CAIRO_STATUS_NO_MEMORY);
#ifdef PNG_SETJMP_SUPPORTED
longjmp (png_jmpbuf (png), 1);
#endif
/* if we get here, then we have to choice but to abort ... */
}
static void
png_simple_warning_callback (png_structp png,
png_const_charp error_msg)
{
cairo_status_t *error = png_get_error_ptr (png);
/* default to the most likely error */
if (*error == CAIRO_STATUS_SUCCESS)
*error = _cairo_error (CAIRO_STATUS_NO_MEMORY);
/* png does not expect to abort and will try to tidy up after a warning */
}
/* Starting with libpng-1.2.30, we must explicitly specify an output_flush_fn.
* Otherwise, we will segfault if we are writing to a stream. */
static void
png_simple_output_flush_fn (png_structp png_ptr)
{
}
static cairo_status_t
write_png (cairo_surface_t *surface,
png_rw_ptr write_func,
void *closure)
{
int i;
cairo_int_status_t status;
cairo_image_surface_t *image;
cairo_image_surface_t * volatile clone;
void *image_extra;
png_struct *png;
png_info *info;
png_byte **volatile rows = NULL;
png_color_16 white;
int png_color_type;
int bpc;
status = _cairo_surface_acquire_source_image (surface,
&image,
&image_extra);
if (status == CAIRO_INT_STATUS_UNSUPPORTED)
return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
else if (unlikely (status))
return status;
/* PNG complains about "Image width or height is zero in IHDR" */
if (image->width == 0 || image->height == 0) {
status = _cairo_error (CAIRO_STATUS_WRITE_ERROR);
goto BAIL1;
}
/* Handle the various fallback formats (e.g. low bit-depth XServers)
* by coercing them to a simpler format using pixman.
*/
clone = _cairo_image_surface_coerce (image);
status = clone->base.status;
if (unlikely (status))
goto BAIL1;
rows = _cairo_malloc_ab (clone->height, sizeof (png_byte*));
if (unlikely (rows == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto BAIL2;
}
for (i = 0; i < clone->height; i++)
rows[i] = (png_byte *) clone->data + i * clone->stride;
png = png_create_write_struct (PNG_LIBPNG_VER_STRING, &status,
png_simple_error_callback,
png_simple_warning_callback);
if (unlikely (png == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto BAIL3;
}
info = png_create_info_struct (png);
if (unlikely (info == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto BAIL4;
}
#ifdef PNG_SETJMP_SUPPORTED
if (setjmp (png_jmpbuf (png)))
goto BAIL4;
#endif
png_set_write_fn (png, closure, write_func, png_simple_output_flush_fn);
switch (clone->format) {
case CAIRO_FORMAT_ARGB32:
bpc = 8;
if (_cairo_image_analyze_transparency (clone) == CAIRO_IMAGE_IS_OPAQUE)
png_color_type = PNG_COLOR_TYPE_RGB;
else
png_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
break;
case CAIRO_FORMAT_RGB30:
bpc = 10;
png_color_type = PNG_COLOR_TYPE_RGB;
break;
case CAIRO_FORMAT_RGB24:
bpc = 8;
png_color_type = PNG_COLOR_TYPE_RGB;
break;
case CAIRO_FORMAT_A8:
bpc = 8;
png_color_type = PNG_COLOR_TYPE_GRAY;
break;
case CAIRO_FORMAT_A1:
bpc = 1;
png_color_type = PNG_COLOR_TYPE_GRAY;
#ifndef WORDS_BIGENDIAN
png_set_packswap (png);
#endif
break;
case CAIRO_FORMAT_INVALID:
case CAIRO_FORMAT_RGB16_565:
default:
status = _cairo_error (CAIRO_STATUS_INVALID_FORMAT);
goto BAIL4;
}
png_set_IHDR (png, info,
clone->width,
clone->height, bpc,
png_color_type,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
white.gray = (1 << bpc) - 1;
white.red = white.blue = white.green = white.gray;
png_set_bKGD (png, info, &white);
if (0) { /* XXX extract meta-data from surface (i.e. creation date) */
png_time pt;
png_convert_from_time_t (&pt, time (NULL));
png_set_tIME (png, info, &pt);
}
/* We have to call png_write_info() before setting up the write
* transformation, since it stores data internally in 'png'
* that is needed for the write transformation functions to work.
*/
png_write_info (png, info);
if (png_color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
png_set_write_user_transform_fn (png, unpremultiply_data);
} else if (png_color_type == PNG_COLOR_TYPE_RGB) {
png_set_write_user_transform_fn (png, convert_data_to_bytes);
png_set_filler (png, 0, PNG_FILLER_AFTER);
}
png_write_image (png, rows);
png_write_end (png, info);
BAIL4:
png_destroy_write_struct (&png, &info);
BAIL3:
free (rows);
BAIL2:
cairo_surface_destroy (&clone->base);
BAIL1:
_cairo_surface_release_source_image (surface, image, image_extra);
return status;
}
static void
stdio_write_func (png_structp png, png_bytep data, png_size_t size)
{
FILE *fp;
fp = png_get_io_ptr (png);
while (size) {
size_t ret = fwrite (data, 1, size, fp);
size -= ret;
data += ret;
if (size && ferror (fp)) {
cairo_status_t *error = png_get_error_ptr (png);
if (*error == CAIRO_STATUS_SUCCESS)
*error = _cairo_error (CAIRO_STATUS_WRITE_ERROR);
png_error (png, NULL);
}
}
}
/**
* cairo_surface_write_to_png:
* @surface: a #cairo_surface_t with pixel contents
* @filename: the name of a file to write to
*
* Writes the contents of @surface to a new file @filename as a PNG
* image.
*
* Return value: %CAIRO_STATUS_SUCCESS if the PNG file was written
* successfully. Otherwise, %CAIRO_STATUS_NO_MEMORY if memory could not
* be allocated for the operation or
* %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface does not have
* pixel contents, or %CAIRO_STATUS_WRITE_ERROR if an I/O error occurs
* while attempting to write the file.
*
* Since: 1.0
**/
cairo_status_t
cairo_surface_write_to_png (cairo_surface_t *surface,
const char *filename)
{
FILE *fp;
cairo_status_t status;
if (surface->status)
return surface->status;
if (surface->finished)
return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
fp = fopen (filename, "wb");
if (fp == NULL) {
switch (errno) {
case ENOMEM:
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
default:
return _cairo_error (CAIRO_STATUS_WRITE_ERROR);
}
}
status = write_png (surface, stdio_write_func, fp);
if (fclose (fp) && status == CAIRO_STATUS_SUCCESS)
status = _cairo_error (CAIRO_STATUS_WRITE_ERROR);
return status;
}
struct png_write_closure_t {
cairo_write_func_t write_func;
void *closure;
};
static void
stream_write_func (png_structp png, png_bytep data, png_size_t size)
{
cairo_status_t status;
struct png_write_closure_t *png_closure;
png_closure = png_get_io_ptr (png);
status = png_closure->write_func (png_closure->closure, data, size);
if (unlikely (status)) {
cairo_status_t *error = png_get_error_ptr (png);
if (*error == CAIRO_STATUS_SUCCESS)
*error = status;
png_error (png, NULL);
}
}
/**
* cairo_surface_write_to_png_stream:
* @surface: a #cairo_surface_t with pixel contents
* @write_func: a #cairo_write_func_t
* @closure: closure data for the write function
*
* Writes the image surface to the write function.
*
* Return value: %CAIRO_STATUS_SUCCESS if the PNG file was written
* successfully. Otherwise, %CAIRO_STATUS_NO_MEMORY is returned if
* memory could not be allocated for the operation,
* %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface does not have
* pixel contents.
*
* Since: 1.0
**/
cairo_status_t
cairo_surface_write_to_png_stream (cairo_surface_t *surface,
cairo_write_func_t write_func,
void *closure)
{
struct png_write_closure_t png_closure;
if (surface->status)
return surface->status;
if (surface->finished)
return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
png_closure.write_func = write_func;
png_closure.closure = closure;
return write_png (surface, stream_write_func, &png_closure);
}
slim_hidden_def (cairo_surface_write_to_png_stream);
static inline int
multiply_alpha (int alpha, int color)
{
int temp = (alpha * color) + 0x80;
return ((temp + (temp >> 8)) >> 8);
}
/* Premultiplies data and converts RGBA bytes => native endian */
static void
premultiply_data (png_structp png,
png_row_infop row_info,
png_bytep data)
{
unsigned int i;
for (i = 0; i < row_info->rowbytes; i += 4) {
uint8_t *base = &data[i];
uint8_t alpha = base[3];
uint32_t p;
if (alpha == 0) {
p = 0;
} else {
uint8_t red = base[0];
uint8_t green = base[1];
uint8_t blue = base[2];
if (alpha != 0xff) {
red = multiply_alpha (alpha, red);
green = multiply_alpha (alpha, green);
blue = multiply_alpha (alpha, blue);
}
p = (alpha << 24) | (red << 16) | (green << 8) | (blue << 0);
}
memcpy (base, &p, sizeof (uint32_t));
}
}
/* Converts RGBx bytes to native endian xRGB */
static void
convert_bytes_to_data (png_structp png, png_row_infop row_info, png_bytep data)
{
unsigned int i;
for (i = 0; i < row_info->rowbytes; i += 4) {
uint8_t *base = &data[i];
uint8_t red = base[0];
uint8_t green = base[1];
uint8_t blue = base[2];
uint32_t pixel;
pixel = (0xff << 24) | (red << 16) | (green << 8) | (blue << 0);
memcpy (base, &pixel, sizeof (uint32_t));
}
}
static cairo_status_t
stdio_read_func (void *closure, unsigned char *data, unsigned int size)
{
FILE *file = closure;
while (size) {
size_t ret;
ret = fread (data, 1, size, file);
size -= ret;
data += ret;
if (size && (feof (file) || ferror (file)))
return _cairo_error (CAIRO_STATUS_READ_ERROR);
}
return CAIRO_STATUS_SUCCESS;
}
static void
stream_read_func (png_structp png, png_bytep data, png_size_t size)
{
cairo_status_t status;
struct png_read_closure_t *png_closure;
png_closure = png_get_io_ptr (png);
status = png_closure->read_func (png_closure->closure, data, size);
if (unlikely (status)) {
cairo_status_t *error = png_get_error_ptr (png);
if (*error == CAIRO_STATUS_SUCCESS)
*error = status;
png_error (png, NULL);
}
_cairo_output_stream_write (png_closure->png_data, data, size);
}
static cairo_surface_t *
read_png (struct png_read_closure_t *png_closure)
{
cairo_surface_t *surface;
png_struct *png = NULL;
png_info *info;
png_byte *data = NULL;
png_byte **row_pointers = NULL;
png_uint_32 png_width, png_height;
int depth, color_type, interlace, stride;
unsigned int i;
cairo_format_t format;
cairo_status_t status;
unsigned char *mime_data;
unsigned long mime_data_length;
png_closure->png_data = _cairo_memory_stream_create ();
/* XXX: Perhaps we'll want some other error handlers? */
png = png_create_read_struct (PNG_LIBPNG_VER_STRING,
&status,
png_simple_error_callback,
png_simple_warning_callback);
if (unlikely (png == NULL)) {
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
goto BAIL;
}
info = png_create_info_struct (png);
if (unlikely (info == NULL)) {
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
goto BAIL;
}
png_set_read_fn (png, png_closure, stream_read_func);
status = CAIRO_STATUS_SUCCESS;
#ifdef PNG_SETJMP_SUPPORTED
if (setjmp (png_jmpbuf (png))) {
surface = _cairo_surface_create_in_error (status);
goto BAIL;
}
#endif
png_read_info (png, info);
png_get_IHDR (png, info,
&png_width, &png_height, &depth,
&color_type, &interlace, NULL, NULL);
if (unlikely (status)) { /* catch any early warnings */
surface = _cairo_surface_create_in_error (status);
goto BAIL;
}
/* convert palette/gray image to rgb */
if (color_type == PNG_COLOR_TYPE_PALETTE)
png_set_palette_to_rgb (png);
/* expand gray bit depth if needed */
if (color_type == PNG_COLOR_TYPE_GRAY) {
#if PNG_LIBPNG_VER >= 10209
png_set_expand_gray_1_2_4_to_8 (png);
#else
png_set_gray_1_2_4_to_8 (png);
#endif
}
/* transform transparency to alpha */
if (png_get_valid (png, info, PNG_INFO_tRNS))
png_set_tRNS_to_alpha (png);
if (depth == 16)
png_set_strip_16 (png);
if (depth < 8)
png_set_packing (png);
/* convert grayscale to RGB */
if (color_type == PNG_COLOR_TYPE_GRAY ||
color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
{
png_set_gray_to_rgb (png);
}
if (interlace != PNG_INTERLACE_NONE)
png_set_interlace_handling (png);
png_set_filler (png, 0xff, PNG_FILLER_AFTER);
/* recheck header after setting EXPAND options */
png_read_update_info (png, info);
png_get_IHDR (png, info,
&png_width, &png_height, &depth,
&color_type, &interlace, NULL, NULL);
if (depth != 8 ||
! (color_type == PNG_COLOR_TYPE_RGB ||
color_type == PNG_COLOR_TYPE_RGB_ALPHA))
{
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_READ_ERROR));
goto BAIL;
}
switch (color_type) {
default:
ASSERT_NOT_REACHED;
/* fall-through just in case ;-) */
case PNG_COLOR_TYPE_RGB_ALPHA:
format = CAIRO_FORMAT_ARGB32;
png_set_read_user_transform_fn (png, premultiply_data);
break;
case PNG_COLOR_TYPE_RGB:
format = CAIRO_FORMAT_RGB24;
png_set_read_user_transform_fn (png, convert_bytes_to_data);
break;
}
stride = cairo_format_stride_for_width (format, png_width);
if (stride < 0) {
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_STRIDE));
goto BAIL;
}
data = _cairo_malloc_ab (png_height, stride);
if (unlikely (data == NULL)) {
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
goto BAIL;
}
row_pointers = _cairo_malloc_ab (png_height, sizeof (char *));
if (unlikely (row_pointers == NULL)) {
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
goto BAIL;
}
for (i = 0; i < png_height; i++)
row_pointers[i] = &data[i * stride];
png_read_image (png, row_pointers);
png_read_end (png, info);
if (unlikely (status)) { /* catch any late warnings - probably hit an error already */
surface = _cairo_surface_create_in_error (status);
goto BAIL;
}
surface = cairo_image_surface_create_for_data (data, format,
png_width, png_height,
stride);
if (surface->status)
goto BAIL;
_cairo_image_surface_assume_ownership_of_data ((cairo_image_surface_t*)surface);
data = NULL;
_cairo_debug_check_image_surface_is_defined (surface);
status = _cairo_memory_stream_destroy (png_closure->png_data,
&mime_data,
&mime_data_length);
png_closure->png_data = NULL;
if (unlikely (status)) {
cairo_surface_destroy (surface);
surface = _cairo_surface_create_in_error (status);
goto BAIL;
}
status = cairo_surface_set_mime_data (surface,
CAIRO_MIME_TYPE_PNG,
mime_data,
mime_data_length,
free,
mime_data);
if (unlikely (status)) {
free (mime_data);
cairo_surface_destroy (surface);
surface = _cairo_surface_create_in_error (status);
goto BAIL;
}
BAIL:
free (row_pointers);
free (data);
if (png != NULL)
png_destroy_read_struct (&png, &info, NULL);
if (png_closure->png_data != NULL) {
cairo_status_t status_ignored;
status_ignored = _cairo_output_stream_destroy (png_closure->png_data);
}
return surface;
}
/**
* cairo_image_surface_create_from_png:
* @filename: name of PNG file to load
*
* Creates a new image surface and initializes the contents to the
* given PNG file.
*
* Return value: a new #cairo_surface_t initialized with the contents
* of the PNG file, or a "nil" surface if any error occurred. A nil
* surface can be checked for with cairo_surface_status(surface) which
* may return one of the following values:
*
* %CAIRO_STATUS_NO_MEMORY
* %CAIRO_STATUS_FILE_NOT_FOUND
* %CAIRO_STATUS_READ_ERROR
*
* Alternatively, you can allow errors to propagate through the drawing
* operations and check the status on the context upon completion
* using cairo_status().
*
* Since: 1.0
**/
cairo_surface_t *
cairo_image_surface_create_from_png (const char *filename)
{
struct png_read_closure_t png_closure;
cairo_surface_t *surface;
png_closure.closure = fopen (filename, "rb");
if (png_closure.closure == NULL) {
cairo_status_t status;
switch (errno) {
case ENOMEM:
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
break;
case ENOENT:
status = _cairo_error (CAIRO_STATUS_FILE_NOT_FOUND);
break;
default:
status = _cairo_error (CAIRO_STATUS_READ_ERROR);
break;
}
return _cairo_surface_create_in_error (status);
}
png_closure.read_func = stdio_read_func;
surface = read_png (&png_closure);
fclose (png_closure.closure);
return surface;
}
/**
* cairo_image_surface_create_from_png_stream:
* @read_func: function called to read the data of the file
* @closure: data to pass to @read_func.
*
* Creates a new image surface from PNG data read incrementally
* via the @read_func function.
*
* Return value: a new #cairo_surface_t initialized with the contents
* of the PNG file or a "nil" surface if the data read is not a valid PNG image
* or memory could not be allocated for the operation. A nil
* surface can be checked for with cairo_surface_status(surface) which
* may return one of the following values:
*
* %CAIRO_STATUS_NO_MEMORY
* %CAIRO_STATUS_READ_ERROR
*
* Alternatively, you can allow errors to propagate through the drawing
* operations and check the status on the context upon completion
* using cairo_status().
*
* Since: 1.0
**/
cairo_surface_t *
cairo_image_surface_create_from_png_stream (cairo_read_func_t read_func,
void *closure)
{
struct png_read_closure_t png_closure;
png_closure.read_func = read_func;
png_closure.closure = closure;
return read_png (&png_closure);
}
| 27.634146 | 90 | 0.688261 | [
"vector",
"transform"
] |
e74d68c904afa4d19bf0126e9ac9e542eb22cf12 | 5,964 | h | C | Modules/Filtering/ChangeDetection/include/otbKullbackLeiblerSupervizedDistanceImageFilter.h | lfyater/Orfeo | eb3d4d56089065b99641d8ae7338d2ed0358d28a | [
"Apache-2.0"
] | 2 | 2019-02-13T14:48:19.000Z | 2019-12-03T02:54:28.000Z | Modules/Filtering/ChangeDetection/include/otbKullbackLeiblerSupervizedDistanceImageFilter.h | lfyater/Orfeo | eb3d4d56089065b99641d8ae7338d2ed0358d28a | [
"Apache-2.0"
] | 3 | 2015-10-14T10:11:38.000Z | 2015-10-15T08:26:23.000Z | Modules/Filtering/ChangeDetection/include/otbKullbackLeiblerSupervizedDistanceImageFilter.h | lfyater/Orfeo | eb3d4d56089065b99641d8ae7338d2ed0358d28a | [
"Apache-2.0"
] | 2 | 2019-01-17T10:36:14.000Z | 2019-12-03T02:54:36.000Z | /*
* Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
* Copyright (C) 2007-2012 Institut Mines Telecom / Telecom Bretagne
*
* This file is part of Orfeo Toolbox
*
* https://www.orfeo-toolbox.org/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef otbKullbackLeiblerSupervizedDistanceImageFilter_h
#define otbKullbackLeiblerSupervizedDistanceImageFilter_h
#include "otbKullbackLeiblerDistanceImageFilter.h"
#include "otbROIdataConversion.h"
namespace otb
{
/** \class KullbackLeiblerSupervizedDistanceImageFilter
* \brief Implements KullbackLeibler distance over Edgeworth approximation,
* between a Neighborhood and a predefined Region of Interest.
*
* This filter is parametrized over the types of the two
* input images and the type of the output image.
*
* Numeric conversions (castings) are done by the C++ defaults.
*
* The filter will walk over all the pixels in the two input
* images, and for each one of them it will do the following:
*
* - cast the input 1 pixel value to \c double
* - compute the first four cumulants of the ROI
* - cast the input 2 pixel value to \c double
* - compute the first four cumulants of the pixel values
* - compute the value of the Edgeorth approximation of the KL distance
* - cast the \c double value resulting to the pixel type of the output image
* - store the casted value into the output image.
*
* The filter expect all images to have the same dimension
* (e.g. all 2D, or all 3D, or all ND)
*
* See article of Lin Saito et Levine
* "Edgeworth Approximation of the Kullback-Leibler Distance Towards Problems in Image Analysis"
* and
* "Edgeworth Expansions of the Kullback-Leibler Information" (submitted to JASA, nov 25, 1999)
* http://www.math.ucdavis.edu/~saito/publications
*
* \sa CumulantsForEdgeworth
*
* \ingroup OTBChangeDetection
*/
namespace Functor
{
/** \class KullbackLeiblerSupervizedDistance
* \brief Functor for KullbackLeiblerSupervizedDistanceImageFilter. Please refer to KullbackLeiblerSupervizedDistanceImageFilter.
*
*
* \ingroup OTBChangeDetection
*/
template <class TInput1, class TInput2, class TInputROIImage, class TOutput>
class KullbackLeiblerSupervizedDistance
{
public:
KullbackLeiblerSupervizedDistance ();
virtual ~KullbackLeiblerSupervizedDistance ();
/** performs the preprocess calculation on the training area */
void Evaluate(const typename TInput1::ImageType * img1,
const typename TInput2::ImageType * img2,
const TInputROIImage * imgROI);
/** The functor by itself */
TOutput operator ()(const TInput1& it1, const TInput2& it2);
protected:
typedef ROIdataConversion<
typename TInput1::ImageType, TInputROIImage> ROIConversionType1;
typedef itk::ConstNeighborhoodIterator<
typename ROIConversionType1::OutputImageType> ROIInputType1;
typedef ROIdataConversion<
typename TInput2::ImageType, TInputROIImage> ROIConversionType2;
typedef itk::ConstNeighborhoodIterator<
typename ROIConversionType2::OutputImageType> ROIInputType2;
CumulantsForEdgeworth<ROIInputType1> * m_CumROI1;
CumulantsForEdgeworth<ROIInputType2> * m_CumROI2;
private:
KullbackLeiblerSupervizedDistance (const KullbackLeiblerSupervizedDistance&);
};
} // Functor
template <class TInputImage1, class TInputImage2, class TInputROIImage, class TOutputImage>
class ITK_EXPORT KullbackLeiblerSupervizedDistanceImageFilter :
public otb::BinaryFunctorNeighborhoodImageFilter<
TInputImage1, TInputImage2, TOutputImage,
Functor::KullbackLeiblerSupervizedDistance<
typename itk::ConstNeighborhoodIterator<TInputImage1>,
typename itk::ConstNeighborhoodIterator<TInputImage2>,
TInputROIImage,
typename TOutputImage::PixelType> >
{
public:
/** Standard class typedefs. */
typedef KullbackLeiblerSupervizedDistanceImageFilter Self;
typedef typename otb::BinaryFunctorNeighborhoodImageFilter<
TInputImage1, TInputImage2, TOutputImage,
Functor::KullbackLeiblerSupervizedDistance<
typename itk::ConstNeighborhoodIterator<TInputImage1>,
typename itk::ConstNeighborhoodIterator<TInputImage2>,
TInputROIImage,
typename TOutputImage::PixelType>
> Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Vectors that hold the training area */
typedef typename TInputImage1::PixelType MeasurementType1;
typedef typename TInputImage2::PixelType MeasurementType2;
typedef std::vector<MeasurementType1> TrainingMeasureType1;
typedef std::vector<MeasurementType2> TrainingMeasureType2;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Method for creation of the training area and the computation
* of some reference cumulants */
void SetTrainingArea(const TInputROIImage * trainingImage);
protected:
void BeforeThreadedGenerateData(void) ITK_OVERRIDE;
KullbackLeiblerSupervizedDistanceImageFilter()
{
this->SetNumberOfRequiredInputs(3);
}
~KullbackLeiblerSupervizedDistanceImageFilter() ITK_OVERRIDE {}
private:
KullbackLeiblerSupervizedDistanceImageFilter(const Self &); //purposely not implemented
void operator =(const Self&); //purposely not implemented
};
} // namespace otb
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbKullbackLeiblerSupervizedDistanceImageFilter.txx"
#endif
#endif
| 35.082353 | 129 | 0.765258 | [
"object",
"vector",
"3d"
] |
e75098c425cd23c5742544ddb3d95a891fecea5b | 1,303 | h | C | CondFormats/CTPPSReadoutObjects/interface/LHCOpticalFunctionsSet.h | NTrevisani/cmssw | a212a27526f34eb9507cf8b875c93896e6544781 | [
"Apache-2.0"
] | 2 | 2020-01-27T15:21:37.000Z | 2020-05-11T11:13:18.000Z | CondFormats/CTPPSReadoutObjects/interface/LHCOpticalFunctionsSet.h | NTrevisani/cmssw | a212a27526f34eb9507cf8b875c93896e6544781 | [
"Apache-2.0"
] | 7 | 2016-07-17T02:34:54.000Z | 2019-08-13T07:58:37.000Z | CondFormats/CTPPSReadoutObjects/interface/LHCOpticalFunctionsSet.h | NTrevisani/cmssw | a212a27526f34eb9507cf8b875c93896e6544781 | [
"Apache-2.0"
] | 3 | 2017-06-07T15:22:28.000Z | 2019-02-28T20:48:30.000Z | // Original Author: Jan Kašpar
#ifndef CondFormats_CTPPSReadoutObjects_LHCOpticalFunctionsSet_h
#define CondFormats_CTPPSReadoutObjects_LHCOpticalFunctionsSet_h
#include "CondFormats/Serialization/interface/Serializable.h"
#include <vector>
#include <string>
#include <memory>
/// Set of optical functions corresponding to one scoring plane along LHC.
class LHCOpticalFunctionsSet {
public:
/// indices for m_fcn_values and m_splines data members
enum { evx, eLx, e14, exd, evpx, eLpx, e24, expd, e32, evy, eLy, eyd, e42, evpy, eLpy, eypd, nFunctions };
LHCOpticalFunctionsSet() = default;
/// fills m_*_values fields from a ROOT file
LHCOpticalFunctionsSet(const std::string& fileName, const std::string& directoryName, double z);
~LHCOpticalFunctionsSet() = default;
/// returns the position of the scoring plane (LHC/TOTEM convention)
double getScoringPlaneZ() const { return m_z; }
const std::vector<double>& getXiValues() const { return m_xi_values; }
const std::vector<std::vector<double>>& getFcnValues() const { return m_fcn_values; }
protected:
/// position of the scoring plane, in LHC/TOTEM convention, cm
double m_z;
std::vector<double> m_xi_values;
std::vector<std::vector<double>> m_fcn_values; ///< length unit cm
COND_SERIALIZABLE;
};
#endif
| 31.02381 | 108 | 0.752111 | [
"vector"
] |
e7519fcc7b303279435ee2ed9432e3ea5481347c | 2,215 | h | C | src/eds/http/writerstage.h | panyam/halley | 1bc8e9fe890d585c8ca524d6070591af656e206b | [
"Apache-2.0"
] | null | null | null | src/eds/http/writerstage.h | panyam/halley | 1bc8e9fe890d585c8ca524d6070591af656e206b | [
"Apache-2.0"
] | null | null | null | src/eds/http/writerstage.h | panyam/halley | 1bc8e9fe890d585c8ca524d6070591af656e206b | [
"Apache-2.0"
] | null | null | null | //*****************************************************************************
/*!
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*****************************************************************************
*
* \file writerstage.h
*
* \brief A stage that writes the request to the socket. The modules
* dont/shouldnt care about this. When there is no longer a module to
* send to, the http handler stage will automatically send the data to
* this stage.
*
* \version
* - S Panyam 14/07/2009
* Created
*
*****************************************************************************/
#ifndef _SHTTP_WRITER_STAGE_H_
#define _SHTTP_WRITER_STAGE_H_
#include "eds/writerstage.h"
class SBodyPart;
class SHttpWriterState;
// Takes care of transfer encoding - Strips out Content-Length in chunked
// mode
class SHttpWriterStage : public SWriterStage
{
public:
// Allowed events in this stage
typedef enum
{
EVT_WRITE_BODY_PART = 1, // from 1 since parent uses 0
} EventType;
public:
// Creates a http request writer
SHttpWriterStage(const SString &name = "HttpWriter", int numThreads = DEFAULT_NUM_THREADS);
// Destroys the stage
virtual ~SHttpWriterStage() { }
//! Creates the stage specific object
virtual void * CreateStageData();
//! Destroys the stage specific object
virtual void DestroyStageData(void *pStateData);
//! Re orders and sends out http body parts to the socket
virtual void HandleEvent(const SEvent &event);
//! Send an event to send out a body part on the wire
virtual bool SendEvent_WriteBodyPart(SConnection *pConnection, SBodyPart *pBodyPart);
};
#endif
| 31.197183 | 95 | 0.633409 | [
"object"
] |
e75c84c974883322716bdf48106e2c5a5b00e3f1 | 477 | h | C | BaseTableViewDemo/STableView/STableViewCell.h | 02002love/baseTableView | 867b4a63fb5796a2a17f2952ed350f0a42b49adb | [
"MIT"
] | null | null | null | BaseTableViewDemo/STableView/STableViewCell.h | 02002love/baseTableView | 867b4a63fb5796a2a17f2952ed350f0a42b49adb | [
"MIT"
] | null | null | null | BaseTableViewDemo/STableView/STableViewCell.h | 02002love/baseTableView | 867b4a63fb5796a2a17f2952ed350f0a42b49adb | [
"MIT"
] | null | null | null | //
// STableViewCell.h
// BaseTableViewDemo
//
// Created by 宋金委 on 2018/11/27.
// Copyright © 2018 宋金委. All rights reserved.
//
#import <UIKit/UIKit.h>
#import "SModel.h"
NS_ASSUME_NONNULL_BEGIN
@interface STableViewCell : UITableViewCell
/**
初始化 cell
@param tableView 所在的 tableView
@return 实例
*/
+ (instancetype)initCellInTable:(UITableView *)tableView;
/**
填充 cell
@param model 实体
*/
- (void)fillCellWithModel:(SModel *)model;
@end
NS_ASSUME_NONNULL_END
| 14.029412 | 57 | 0.712788 | [
"model"
] |
e75d4be6e3ca4c4b4e5a1f3fe5402d567a0b894e | 4,490 | c | C | uuid_files/main/UuidA.c | chris-y/uuid_lib | 328296e76d547cfdab045bc91964a8a3ca9853ac | [
"MIT"
] | 1 | 2019-07-08T18:01:32.000Z | 2019-07-08T18:01:32.000Z | uuid_files/main/UuidA.c | chris-y/uuid_lib | 328296e76d547cfdab045bc91964a8a3ca9853ac | [
"MIT"
] | null | null | null | uuid_files/main/UuidA.c | chris-y/uuid_lib | 328296e76d547cfdab045bc91964a8a3ca9853ac | [
"MIT"
] | null | null | null | /* :ts=4
* $VER: UuidA.c $Revision$ (07-Oct-2018)
*
* This file is part of uuid.
*
* Copyright (c) 2018 Unsatisfactory Software
* All Rights Reserved.
*
* $Id$
*
* $Log$
*
*
*/
#include <exec/exec.h>
#include <proto/exec.h>
#include <proto/utility.h>
#include <dos/dos.h>
#include <libraries/uuid.h>
#include <proto/uuid.h>
#include <stdarg.h>
#include <stdio.h>
#include "uuid_v1.h"
#include "uuid_v4.h"
#include "uuid_v5.h"
#include "uuid_preset.h"
#include "uuid_string.h"
/****** uuid/main/UuidA ******************************************
*
* NAME
* UuidA -- Ceate a UUID object
* Uuid -- Vararg stub
*
* SYNOPSIS
* void * UuidA(const struct TagItem * taglist);
* void * Uuid(...);
*
* FUNCTION
* Creates a UUID as per RFC4122
*
* INPUTS
* taglist - see below
*
* TAGS
* UUID_Version (ULONG)
* Version of UUID to create.
* Currently supported versions are 1, 4 and 5.
* Defaults to 1.
*
* UUID_Namespace (void *)
* A UUID object to use as a namspace.
* This is only used when creating v5 UUIDs, and
* is REQUIRED to create a v5 UUID.
*
* UUID_Name (char *)
* A string to use as a name within a namespace.
* This is only used when creating v5 UUIDs, and
* is REQUIRED to create a v5 UUID.
*
* UUID_Preset (ULONG)
* A predefined UUID to return. These are usually
* used as namespaces when creating v5 UUIDs.
* If UUID_Preset is provided, no other tags should
* be specified.
* Choices are:
* UUID_NULL - NULL UUID
* UUID_NS_DNS - DNS namespace
* UUID_NS_URL - URL namespace
* UUID_NS_OID - OID namespace
* UUID_NS_X500 - X500 namespace
*
* UUID_String (char *)
* A UUID string to convert to a UUID object.
* This is the opposite of UuidToText()
* If UUID_String is provided, no other tags should
* be specified.
*
* RESULT
* A UUID object which must be freed with FreeUuid(),
* or NULL on error.
*
* EXAMPLE
* Create and print a v4 UUID:
*
* void *uuid = IUuid->Uuid(UUID_Version, 4, TAG_DONE);
* if(uuid != NULL) {
* char uuid_s[37];
* IUuid->UuidToText(uuid, uuid_s);
* printf("%s\n", uuid_s);
* IUuid->FreeUuid(uuid);
* }
*
* NOTES
* If tags UUID_Preset or UUID_String are provided
* along with other tags, the behaviour is undefined.
*
* This library can currently generate a maximum of
* ten v1 UUIDs per microsecond. If this limit is
* reached, NULL will be returned. Be prepared to
* handle this!
*
* BUGS
*
* SEE ALSO
* FreeUuid(), UuidToText()
*
*****************************************************************************
*
*/
void *UuidA(const struct TagItem * taglist)
{
struct TagItem *ti;
ULONG ver = 1;
ULONG preset = 0;
uuid_t *namespace = NULL;
char *name = NULL;
char *uuid_str = NULL;
bool ret = false;
if((ti = IUtility->FindTagItem(UUID_Version, taglist)))
ver = (ULONG)ti->ti_Data;
if((ti = IUtility->FindTagItem(UUID_Preset, taglist)))
preset = (ULONG)ti->ti_Data;
if((ti = IUtility->FindTagItem(UUID_String, taglist)))
uuid_str = (char *)ti->ti_Data;
if((ti = IUtility->FindTagItem(UUID_Namespace, taglist)))
namespace = (uuid_t *)ti->ti_Data;
if((ti = IUtility->FindTagItem(UUID_Name, taglist))) {
name = (char *)ti->ti_Data;
#ifdef DEBUG
IExec->DebugPrintF("%s\n", name);
#endif
}
if((ver == 5) && ((name == NULL) || (namespace == NULL)))
return NULL;
uuid_t *uuid = IExec->AllocVecTags(sizeof(uuid_t),
AVT_Type, MEMF_PRIVATE,
TAG_DONE);
if(uuid == NULL) return NULL;
if(preset != 0) {
ret = uuid_preset(uuid, preset);
} else if (uuid_str != NULL) {
ret = uuid_string(uuid, uuid_str);
} else if(ver == 1) {
ret = uuidv1(uuid);
} else if(ver == 5) {
ret = uuidv5(uuid, namespace, name);
} else if(ver == 4) {
ret = uuidv4(uuid);
}
if(ret == true) {
return uuid;
} else {
IExec->FreeVec(uuid);
return NULL;
}
}
void * VARARGS68K _uuid_Uuid(struct UuidIFace *Self,
...);
void * _uuid_Uuid(struct UuidIFace *Self,
...)
{
va_list ap;
struct TagItem *tags;
va_startlinear(ap, Self);
tags = va_getlinearva(ap, struct TagItem *);
return Self->UuidA(
tags);
}
void * _uuid_UuidA(struct UuidIFace *Self,
const struct TagItem * taglist)
{
return UuidA(taglist);
}
| 22.908163 | 77 | 0.593987 | [
"object"
] |
e76ce4edbfcf1f148a29430b9fb3094e81e55c8f | 3,855 | h | C | CPPDataStructure/src/btree.h | evanxg852000/rockstartdev | cdcff119d35891cf69593f1e924153d29833c03f | [
"Apache-2.0"
] | 1 | 2020-08-27T22:24:47.000Z | 2020-08-27T22:24:47.000Z | CPPDataStructure/src/btree.h | evanxg852000/rockstartdev | cdcff119d35891cf69593f1e924153d29833c03f | [
"Apache-2.0"
] | null | null | null | CPPDataStructure/src/btree.h | evanxg852000/rockstartdev | cdcff119d35891cf69593f1e924153d29833c03f | [
"Apache-2.0"
] | null | null | null | #include <algorithm>
#include <vector>
template<typename T>
class BinaryTree {
private:
struct Node{
T data;
std::shared_ptr<Node> left;
std::shared_ptr<Node> right;
std::shared_ptr<Node> parent;
Node(T data){
this->data = data;
this->left = nullptr;
this->right = nullptr;
this->parent = nullptr;
}
};
public:
std::shared_ptr<Node> root;
int size;
BinaryTree() :root{nullptr}, size{0} {
}
void insert(T data){
auto node = std::make_shared<Node>(data);
if(this->root == nullptr){
this->root = node;
this->size += 1;
return;
}
auto walker = this->root;
while(walker != nullptr){
if(walker.get()->data > data){ //follow left
if(walker.get()->left == nullptr){
walker.get()->left = node;
node.get()->parent = walker;
this->size += 1;
return;
}
walker = walker.get()->left;
}
if(walker.get()->data < data) { // follow right
if(walker.get()->right == nullptr){
walker.get()->right = node;
node.get()->parent = walker;
this->size += 1;
return;
}
walker = walker.get()->right;
}
if(walker.get()->data == data)
return; //already exist
}
}
void remove(T data){
auto walker = this->root;
//find the node
while(walker != nullptr){
if(walker.get()->data == data)
break;
if(walker.get()->data > data) { //follow left
walker = walker.get()->left;
continue;
}
if(walker.get()->data < data) { //follow right
walker = walker.get()->right;
continue;
}
}
if(walker == nullptr) // data was not found
return;
// left node
if(walker.get()->left == nullptr && walker.get()->right == nullptr){
auto parent = walker.get()->parent;
walker.get()->parent = nullptr;
if(parent.get()->left.get()->data == data)
parent.get()->left = nullptr;
if(parent.get()->right.get()->data == data)
parent.get()->right = nullptr;
return;
}
//one child left
if(walker.get()->left != nullptr && walker.get()->right == nullptr){
walker.get()->data = walker.get()->left.get()->data;
walker.get()->left.get()->parent = nullptr;
walker.get()->left = nullptr;
return;
}
//one child right
if(walker.get()->left == nullptr && walker.get()->right != nullptr){
walker.get()->data = walker.get()->right.get()->data;
walker.get()->right.get()->parent = nullptr;
walker.get()->right = nullptr;
return;
}
//two children
auto target = walker.get()->right;
while(target.get()->left != nullptr){
target = target.get()->left;
}
target.get()->data = walker.get()->data;
//TODO need to do this recursivelly
}
bool find(T data){
auto walker = this->root;
while(walker != nullptr){
if(walker.get()->data == data){
return true;
}
if(walker.get()->data > data) { //follow left
walker = walker.get()->left;
continue;
}
if(walker.get()->data < data) { //follow right
walker = walker.get()->right;
continue;
}
}
return false;
}
T max(){
if(this->size == 0){
throw std::out_of_range("out of range exception");
}
auto walker = this->root;
while(walker != nullptr && walker.get()->right != nullptr){
walker = walker.get()->right;
}
return walker.get()->data;
}
T min(){
if(this->size == 0){
throw std::out_of_range("out of range exception");
}
auto walker = this->root;
while(walker != nullptr && walker.get()->left != nullptr){
walker = walker.get()->left;
}
return walker.get()->data;
}
std::vector<T> inOrderItems(){
std::vector<T> rst;
_inOrder(this->root, rst);
return std::move(rst);
}
void _inOrder(std::shared_ptr<Node> root, std::vector<T> &rst){
if(root == nullptr)
return;
_inOrder(root.get()->left, rst);
rst.push_back(root.get()->data);
_inOrder(root.get()->right, rst);
}
int getSize(){
return this->size;
}
};
| 21.181319 | 70 | 0.589105 | [
"vector"
] |
e7722fb73873f717bfa17b70886e44e1d2dc1276 | 773 | h | C | src/builtin/console.h | Vuzi/vuziks | a6d67f5519889dfb3f5230411f8c35b412e10f75 | [
"MIT"
] | 1 | 2016-07-19T23:27:23.000Z | 2016-07-19T23:27:23.000Z | src/builtin/console.h | Vuzi/vuziks | a6d67f5519889dfb3f5230411f8c35b412e10f75 | [
"MIT"
] | null | null | null | src/builtin/console.h | Vuzi/vuziks | a6d67f5519889dfb3f5230411f8c35b412e10f75 | [
"MIT"
] | null | null | null | #ifndef _H_CONSOLE
#define _H_CONSOLE
#include "built-in.h"
#include "../variable.h"
#include "../unit.h"
#include "strings.h"
#include "../str/str.h"
// Bug GCC Windows..
#define CONSOLE_HASH 229462175725400ULL
typedef struct s_Object Object;
typedef struct s_Exec_context Exec_context;
// Prototypes
return_code console_print(Object* o, Linked_list *args, Variable* eval_value, int as_constructor);
return_code console_println(Object* o, Linked_list *args, Variable* eval_value, int as_constructor);
return_code console_readln(Object* o, Linked_list *args, Variable* eval_value, int as_constructor);
return_code console_readint(Object* o, Linked_list *args, Variable* eval_value, int as_constructor);
Object* console_init(Exec_context* ec_obj);
#endif // _H_CONSOLE
| 32.208333 | 100 | 0.78784 | [
"object"
] |
e7797a2803ce856baeb3af55836cda3521180bb7 | 14,970 | h | C | aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneClient.h | AmineChatt1A/aws-sdk-cpp | 3e979d7bc272f77ac179b4849f7386027201c1a2 | [
"Apache-2.0"
] | null | null | null | aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneClient.h | AmineChatt1A/aws-sdk-cpp | 3e979d7bc272f77ac179b4849f7386027201c1a2 | [
"Apache-2.0"
] | null | null | null | aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneClient.h | AmineChatt1A/aws-sdk-cpp | 3e979d7bc272f77ac179b4849f7386027201c1a2 | [
"Apache-2.0"
] | 1 | 2021-10-01T15:29:44.000Z | 2021-10-01T15:29:44.000Z | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#pragma once
#include <aws/iot-data/IoTDataPlane_EXPORTS.h>
#include <aws/iot-data/IoTDataPlaneErrors.h>
#include <aws/core/client/AWSError.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/iot-data/model/DeleteThingShadowResult.h>
#include <aws/iot-data/model/GetThingShadowResult.h>
#include <aws/iot-data/model/UpdateThingShadowResult.h>
#include <aws/core/NoResult.h>
#include <aws/core/client/AsyncCallerContext.h>
#include <aws/core/http/HttpTypes.h>
#include <future>
#include <functional>
namespace Aws
{
namespace Http
{
class HttpClient;
class HttpClientFactory;
} // namespace Http
namespace Utils
{
template< typename R, typename E> class Outcome;
namespace Threading
{
class Executor;
} // namespace Threading
namespace Json
{
class JsonValue;
} // namespace Json
} // namespace Utils
namespace Auth
{
class AWSCredentials;
class AWSCredentialsProvider;
} // namespace Auth
namespace Client
{
class RetryStrategy;
} // namespace Client
namespace IoTDataPlane
{
namespace Model
{
class DeleteThingShadowRequest;
class GetThingShadowRequest;
class PublishRequest;
class UpdateThingShadowRequest;
typedef Aws::Utils::Outcome<DeleteThingShadowResult, Aws::Client::AWSError<IoTDataPlaneErrors>> DeleteThingShadowOutcome;
typedef Aws::Utils::Outcome<GetThingShadowResult, Aws::Client::AWSError<IoTDataPlaneErrors>> GetThingShadowOutcome;
typedef Aws::Utils::Outcome<Aws::NoResult, Aws::Client::AWSError<IoTDataPlaneErrors>> PublishOutcome;
typedef Aws::Utils::Outcome<UpdateThingShadowResult, Aws::Client::AWSError<IoTDataPlaneErrors>> UpdateThingShadowOutcome;
typedef std::future<DeleteThingShadowOutcome> DeleteThingShadowOutcomeCallable;
typedef std::future<GetThingShadowOutcome> GetThingShadowOutcomeCallable;
typedef std::future<PublishOutcome> PublishOutcomeCallable;
typedef std::future<UpdateThingShadowOutcome> UpdateThingShadowOutcomeCallable;
} // namespace Model
class IoTDataPlaneClient;
typedef std::function<void(const IoTDataPlaneClient*, const Model::DeleteThingShadowRequest&, const Model::DeleteThingShadowOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteThingShadowResponseReceivedHandler;
typedef std::function<void(const IoTDataPlaneClient*, const Model::GetThingShadowRequest&, const Model::GetThingShadowOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetThingShadowResponseReceivedHandler;
typedef std::function<void(const IoTDataPlaneClient*, const Model::PublishRequest&, const Model::PublishOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PublishResponseReceivedHandler;
typedef std::function<void(const IoTDataPlaneClient*, const Model::UpdateThingShadowRequest&, const Model::UpdateThingShadowOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateThingShadowResponseReceivedHandler;
/**
* <fullname>AWS IoT</fullname> <p>AWS IoT-Data enables secure, bi-directional
* communication between Internet-connected things (such as sensors, actuators,
* embedded devices, or smart appliances) and the AWS cloud. It implements a broker
* for applications and things to publish messages over HTTP (Publish) and
* retrieve, update, and delete thing shadows. A thing shadow is a persistent
* representation of your things and their state in the AWS cloud.</p>
*/
class AWS_IOTDATAPLANE_API IoTDataPlaneClient : public Aws::Client::AWSJsonClient
{
public:
typedef Aws::Client::AWSJsonClient BASECLASS;
/**
* Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config
* is not specified, it will be initialized to default values.
*/
IoTDataPlaneClient(const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
/**
* Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config
* is not specified, it will be initialized to default values.
*/
IoTDataPlaneClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
/**
* Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied,
* the default http client factory will be used
*/
IoTDataPlaneClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
const Aws::Client::ClientConfiguration& clientConfiguration = Aws::Client::ClientConfiguration());
virtual ~IoTDataPlaneClient();
/**
* <p>Deletes the thing shadow for the specified thing.</p> <p>For more
* information, see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/API_DeleteThingShadow.html">DeleteThingShadow</a>
* in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/DeleteThingShadow">AWS
* API Reference</a></p>
*/
virtual Model::DeleteThingShadowOutcome DeleteThingShadow(const Model::DeleteThingShadowRequest& request) const;
/**
* <p>Deletes the thing shadow for the specified thing.</p> <p>For more
* information, see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/API_DeleteThingShadow.html">DeleteThingShadow</a>
* in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/DeleteThingShadow">AWS
* API Reference</a></p>
*
* returns a future to the operation so that it can be executed in parallel to other requests.
*/
virtual Model::DeleteThingShadowOutcomeCallable DeleteThingShadowCallable(const Model::DeleteThingShadowRequest& request) const;
/**
* <p>Deletes the thing shadow for the specified thing.</p> <p>For more
* information, see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/API_DeleteThingShadow.html">DeleteThingShadow</a>
* in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/DeleteThingShadow">AWS
* API Reference</a></p>
*
* Queues the request into a thread executor and triggers associated callback when operation has finished.
*/
virtual void DeleteThingShadowAsync(const Model::DeleteThingShadowRequest& request, const DeleteThingShadowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
/**
* <p>Gets the thing shadow for the specified thing.</p> <p>For more information,
* see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/API_GetThingShadow.html">GetThingShadow</a>
* in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/GetThingShadow">AWS
* API Reference</a></p>
*/
virtual Model::GetThingShadowOutcome GetThingShadow(const Model::GetThingShadowRequest& request) const;
/**
* <p>Gets the thing shadow for the specified thing.</p> <p>For more information,
* see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/API_GetThingShadow.html">GetThingShadow</a>
* in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/GetThingShadow">AWS
* API Reference</a></p>
*
* returns a future to the operation so that it can be executed in parallel to other requests.
*/
virtual Model::GetThingShadowOutcomeCallable GetThingShadowCallable(const Model::GetThingShadowRequest& request) const;
/**
* <p>Gets the thing shadow for the specified thing.</p> <p>For more information,
* see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/API_GetThingShadow.html">GetThingShadow</a>
* in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/GetThingShadow">AWS
* API Reference</a></p>
*
* Queues the request into a thread executor and triggers associated callback when operation has finished.
*/
virtual void GetThingShadowAsync(const Model::GetThingShadowRequest& request, const GetThingShadowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
/**
* <p>Publishes state information.</p> <p>For more information, see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/protocols.html#http">HTTP
* Protocol</a> in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3>
* <a href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/Publish">AWS
* API Reference</a></p>
*/
virtual Model::PublishOutcome Publish(const Model::PublishRequest& request) const;
/**
* <p>Publishes state information.</p> <p>For more information, see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/protocols.html#http">HTTP
* Protocol</a> in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3>
* <a href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/Publish">AWS
* API Reference</a></p>
*
* returns a future to the operation so that it can be executed in parallel to other requests.
*/
virtual Model::PublishOutcomeCallable PublishCallable(const Model::PublishRequest& request) const;
/**
* <p>Publishes state information.</p> <p>For more information, see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/protocols.html#http">HTTP
* Protocol</a> in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3>
* <a href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/Publish">AWS
* API Reference</a></p>
*
* Queues the request into a thread executor and triggers associated callback when operation has finished.
*/
virtual void PublishAsync(const Model::PublishRequest& request, const PublishResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
/**
* <p>Updates the thing shadow for the specified thing.</p> <p>For more
* information, see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/API_UpdateThingShadow.html">UpdateThingShadow</a>
* in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/UpdateThingShadow">AWS
* API Reference</a></p>
*/
virtual Model::UpdateThingShadowOutcome UpdateThingShadow(const Model::UpdateThingShadowRequest& request) const;
/**
* <p>Updates the thing shadow for the specified thing.</p> <p>For more
* information, see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/API_UpdateThingShadow.html">UpdateThingShadow</a>
* in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/UpdateThingShadow">AWS
* API Reference</a></p>
*
* returns a future to the operation so that it can be executed in parallel to other requests.
*/
virtual Model::UpdateThingShadowOutcomeCallable UpdateThingShadowCallable(const Model::UpdateThingShadowRequest& request) const;
/**
* <p>Updates the thing shadow for the specified thing.</p> <p>For more
* information, see <a
* href="http://docs.aws.amazon.com/iot/latest/developerguide/API_UpdateThingShadow.html">UpdateThingShadow</a>
* in the <i>AWS IoT Developer Guide</i>.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/iot-data-2015-05-28/UpdateThingShadow">AWS
* API Reference</a></p>
*
* Queues the request into a thread executor and triggers associated callback when operation has finished.
*/
virtual void UpdateThingShadowAsync(const Model::UpdateThingShadowRequest& request, const UpdateThingShadowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const;
private:
void init(const Aws::Client::ClientConfiguration& clientConfiguration);
/**Async helpers**/
void DeleteThingShadowAsyncHelper(const Model::DeleteThingShadowRequest& request, const DeleteThingShadowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
void GetThingShadowAsyncHelper(const Model::GetThingShadowRequest& request, const GetThingShadowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
void PublishAsyncHelper(const Model::PublishRequest& request, const PublishResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
void UpdateThingShadowAsyncHelper(const Model::UpdateThingShadowRequest& request, const UpdateThingShadowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const;
Aws::String m_uri;
std::shared_ptr<Aws::Utils::Threading::Executor> m_executor;
};
} // namespace IoTDataPlane
} // namespace Aws
| 53.464286 | 244 | 0.702605 | [
"model"
] |
e779fca00b419aac033eeb79b71c077050f66e8f | 20,533 | c | C | usr/src/cmd/fm/fmstat/common/fmstat.c | AsahiOS/gate | 283d47da4e17a5871d9d575e7ffb81e8f6c52e51 | [
"MIT"
] | null | null | null | usr/src/cmd/fm/fmstat/common/fmstat.c | AsahiOS/gate | 283d47da4e17a5871d9d575e7ffb81e8f6c52e51 | [
"MIT"
] | null | null | null | usr/src/cmd/fm/fmstat/common/fmstat.c | AsahiOS/gate | 283d47da4e17a5871d9d575e7ffb81e8f6c52e51 | [
"MIT"
] | 1 | 2020-12-30T00:04:16.000Z | 2020-12-30T00:04:16.000Z | /*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright (c) 2018, Joyent, Inc.
*/
#include <fm/fmd_adm.h>
#include <strings.h>
#include <limits.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <errno.h>
#include <poll.h>
#include <locale.h>
#include "statcommon.h"
#define FMSTAT_EXIT_SUCCESS 0
#define FMSTAT_EXIT_ERROR 1
#define FMSTAT_EXIT_USAGE 2
static const struct stats {
fmd_stat_t module;
fmd_stat_t authority;
fmd_stat_t state;
fmd_stat_t loadtime;
fmd_stat_t snaptime;
fmd_stat_t received;
fmd_stat_t discarded;
fmd_stat_t retried;
fmd_stat_t replayed;
fmd_stat_t lost;
fmd_stat_t dispatched;
fmd_stat_t dequeued;
fmd_stat_t prdequeued;
fmd_stat_t accepted;
fmd_stat_t memtotal;
fmd_stat_t buftotal;
fmd_stat_t caseopen;
fmd_stat_t casesolved;
fmd_stat_t wcnt;
fmd_stat_t wtime;
fmd_stat_t wlentime;
fmd_stat_t wlastupdate;
fmd_stat_t dtime;
fmd_stat_t dlastupdate;
} stats_template = {
{ "module", FMD_TYPE_STRING },
{ "authority", FMD_TYPE_STRING },
{ "state", FMD_TYPE_STRING },
{ "loadtime", FMD_TYPE_TIME },
{ "snaptime", FMD_TYPE_TIME },
{ "received", FMD_TYPE_UINT64 },
{ "discarded", FMD_TYPE_UINT64 },
{ "retried", FMD_TYPE_UINT64 },
{ "replayed", FMD_TYPE_UINT64 },
{ "lost", FMD_TYPE_UINT64 },
{ "dispatched", FMD_TYPE_UINT64 },
{ "dequeued", FMD_TYPE_UINT64 },
{ "prdequeued", FMD_TYPE_UINT64 },
{ "accepted", FMD_TYPE_UINT64 },
{ "memtotal", FMD_TYPE_SIZE },
{ "buftotal", FMD_TYPE_SIZE },
{ "caseopen", FMD_TYPE_UINT64 },
{ "casesolved", FMD_TYPE_UINT64 },
{ "wcnt", FMD_TYPE_UINT32 },
{ "wtime", FMD_TYPE_TIME },
{ "wlentime", FMD_TYPE_TIME },
{ "wlastupdate", FMD_TYPE_TIME },
{ "dtime", FMD_TYPE_TIME },
{ "dlastupdate", FMD_TYPE_TIME },
};
static const char *g_pname;
static fmd_adm_t *g_adm;
static struct modstats {
char *m_name;
struct modstats *m_next;
struct stats m_stbuf[2];
int m_stidx;
int m_id;
struct stats *m_old;
struct stats *m_new;
double m_wait;
double m_svc;
double m_pct_b;
double m_pct_w;
} *g_mods;
static uint_t timestamp_fmt = NODATE;
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it isn't */
#endif
static void
vwarn(const char *format, va_list ap)
{
int err = errno;
(void) fprintf(stderr, "%s: ", g_pname);
if (format != NULL)
(void) vfprintf(stderr, format, ap);
errno = err; /* restore errno for fmd_adm_errmsg() */
if (format == NULL)
(void) fprintf(stderr, "%s\n", fmd_adm_errmsg(g_adm));
else if (strchr(format, '\n') == NULL)
(void) fprintf(stderr, ": %s\n", fmd_adm_errmsg(g_adm));
}
/*PRINTFLIKE1*/
void
warn(const char *format, ...)
{
va_list ap;
va_start(ap, format);
vwarn(format, ap);
va_end(ap);
}
/*PRINTFLIKE1*/
void
die(const char *format, ...)
{
va_list ap;
va_start(ap, format);
vwarn(format, ap);
va_end(ap);
fmd_adm_close(g_adm);
exit(FMSTAT_EXIT_ERROR);
}
static char *
time2str(char *buf, size_t len, uint64_t time)
{
static const struct unit {
const char *u_name;
hrtime_t u_mul;
} units[] = {
{ "d", NANOSEC * (hrtime_t)(24 * 60 * 60) },
{ "h", NANOSEC * (hrtime_t)(60 * 60) },
{ "m", NANOSEC * (hrtime_t)60 },
{ "s", NANOSEC / SEC },
{ "ms", NANOSEC / MILLISEC },
{ "us", NANOSEC / MICROSEC },
{ "ns", NANOSEC / NANOSEC },
};
const struct unit *up;
for (up = units; time % up->u_mul != 0; up++)
continue; /* find largest unit of which 'time' is a multiple */
(void) snprintf(buf, len, "%llu%s", time / up->u_mul, up->u_name);
return (buf);
}
static char *
size2str(char *buf, size_t len, uint64_t size)
{
static const char units[] = "bKMGTPE";
const uint64_t scale = 1024;
const char *up = units;
uint64_t osize = 0;
/*
* Convert the input size to a round number of the appropriately
* scaled units (saved in 'size') and a remainder (saved in 'osize').
*/
while (size >= scale && up < (units + sizeof (units) - 2)) {
up++;
osize = size;
size = (size + (scale / 2)) / scale;
}
/*
* Format the result using at most one decimal place and the unit
* depending upon the amount of remainder (same as df -h algorithm).
*/
if (osize != 0 && (osize / scale) < 10)
(void) snprintf(buf, len, "%.1f%c", (float)osize / scale, *up);
else if (size != 0)
(void) snprintf(buf, len, "%llu%c", size, *up);
else
(void) snprintf(buf, len, "0");
return (buf);
}
static uint64_t
u64delta(uint64_t old, uint64_t new)
{
return (new >= old ? (new - old) : ((UINT64_MAX - old) + new + 1));
}
static struct modstats *
modstat_create(const char *name, id_t id)
{
struct modstats *mp = malloc(sizeof (struct modstats));
if (mp == NULL)
return (NULL);
bzero(mp, sizeof (struct modstats));
if (name != NULL && (mp->m_name = strdup(name)) == NULL) {
free(mp);
return (NULL);
}
mp->m_id = id;
mp->m_next = g_mods;
g_mods = mp;
return (mp);
}
/*
* Given a statistics buffer containing event queue statistics, compute the
* common queue statistics for the given module and store the results in 'mp'.
* We set m_new and m_old for the caller, and store the compute values of
* m_svc, m_wait, m_pct_w, and m_pct_b there as well. The caller must not free
* 'ams' until after using the results as m_new may contain pointers to it.
*/
static void
modstat_compute(struct modstats *mp, fmd_adm_stats_t *ams)
{
static fmd_stat_t *t_beg = (fmd_stat_t *)(&stats_template + 0);
static fmd_stat_t *t_end = (fmd_stat_t *)(&stats_template + 1);
struct stats *old, *new;
fmd_stat_t *tsp, *nsp, *sp;
double elapsed, avg_w, avg_d;
uint64_t delta;
old = mp->m_old = &mp->m_stbuf[mp->m_stidx];
mp->m_stidx = 1 - mp->m_stidx;
new = mp->m_new = &mp->m_stbuf[mp->m_stidx];
/*
* The statistics can come in any order; we compare each one to the
* template of statistics of interest, find the matching ones, and copy
* their values into the appropriate slot of the 'new' stats.
*/
for (nsp = ams->ams_buf; nsp < ams->ams_buf + ams->ams_len; nsp++) {
for (tsp = t_beg; tsp < t_end; tsp++) {
const char *p = strrchr(nsp->fmds_name, '.');
/*
* The fmd queue stats can either be named fmd.<name>
* or fmd.xprt.%u.<name> depending on whether we're
* looking at the module queue or the transport queue.
* So we match using the patterns fmd.* and *.<name>
* and store only the value of <name> in stats_template.
*/
if (p == NULL || strcmp(p + 1, tsp->fmds_name) != 0 ||
strncmp(nsp->fmds_name, "fmd.", 4) != 0)
continue; /* continue until we match the stat */
if (tsp->fmds_type != nsp->fmds_type) {
warn("%s has unexpected type (%u != %u)\n",
nsp->fmds_name, tsp->fmds_type,
nsp->fmds_type);
} else {
sp = (fmd_stat_t *)new + (tsp - t_beg);
sp->fmds_value = nsp->fmds_value;
}
}
}
/*
* Compute the elapsed time by taking the delta between 'snaptime', or
* or between snaptime and loadtime if there is no previous snapshot.
* If delta is zero, set it to 1sec so we don't divide by zero later.
*/
delta = u64delta(old->snaptime.fmds_value.ui64 ?
old->snaptime.fmds_value.ui64 : old->loadtime.fmds_value.ui64,
new->snaptime.fmds_value.ui64);
elapsed = delta ? (double)delta : (double)NANOSEC;
/*
* Compute average wait queue len by taking the delta in the wait queue
* len * time products (wlentime stat) and dividing by the elapsed time.
*/
delta = u64delta(old->wlentime.fmds_value.ui64,
new->wlentime.fmds_value.ui64);
if (delta != 0)
mp->m_wait = (double)delta / elapsed;
else
mp->m_wait = 0.0;
/*
* Compute average wait time by taking the delta in the wait queue time
* (wtime) and dividing by the delta in the number of dispatches.
*/
delta = u64delta(old->dispatched.fmds_value.ui64,
new->dispatched.fmds_value.ui64);
if (delta != 0) {
avg_w = (double)u64delta(old->wtime.fmds_value.ui64,
new->wtime.fmds_value.ui64) / (double)delta;
} else
avg_w = 0.0;
/*
* Compute average dispatch time by taking the delta in the dispatch
* time (dtime) and dividing by the delta in the number of dequeues.
*/
delta = u64delta(old->dequeued.fmds_value.ui64,
new->dequeued.fmds_value.ui64);
if (delta != 0) {
avg_d = (double)u64delta(old->dtime.fmds_value.ui64,
new->dtime.fmds_value.ui64) / (double)delta;
} else
avg_d = 0.0;
/*
* Finally compute the average overall service time by adding together
* the average wait and dispatch times and converting to milliseconds.
*/
mp->m_svc = ((avg_w + avg_d) * (double)MILLISEC) / (double)NANOSEC;
/*
* Compute the %wait and %busy times by taking the delta in wait and
* busy times, dividing by the elapsed time, and multiplying by 100.
*/
delta = u64delta(old->wtime.fmds_value.ui64,
new->wtime.fmds_value.ui64);
if (delta != 0)
mp->m_pct_w = ((double)delta / elapsed) * 100.0;
else
mp->m_pct_w = 0.0;
delta = u64delta(old->dtime.fmds_value.ui64,
new->dtime.fmds_value.ui64);
if (delta != 0)
mp->m_pct_b = ((double)delta / elapsed) * 100.0;
else
mp->m_pct_b = 0.0;
}
/*ARGSUSED*/
static void
stat_one_xprt(id_t id, void *ignored)
{
fmd_adm_stats_t ams;
struct modstats *mp;
if (fmd_adm_xprt_stats(g_adm, id, &ams) != 0) {
warn("failed to retrieve statistics for transport %d", (int)id);
return;
}
for (mp = g_mods; mp != NULL; mp = mp->m_next) {
if (mp->m_id == id)
break;
}
if (mp == NULL && (mp = modstat_create(NULL, id)) == NULL) {
warn("failed to allocate memory for transport %d", (int)id);
(void) fmd_adm_stats_free(g_adm, &ams);
return;
}
modstat_compute(mp, &ams);
(void) printf("%3d %5s %7llu %7llu %7llu %7llu "
"%4.1f %6.1f %3.0f %3.0f %s\n", (int)id,
mp->m_new->state.fmds_value.str,
u64delta(mp->m_old->prdequeued.fmds_value.ui64,
mp->m_new->prdequeued.fmds_value.ui64),
u64delta(mp->m_old->received.fmds_value.ui64,
mp->m_new->received.fmds_value.ui64),
u64delta(mp->m_old->discarded.fmds_value.ui64,
mp->m_new->discarded.fmds_value.ui64),
u64delta(mp->m_old->lost.fmds_value.ui64,
mp->m_new->lost.fmds_value.ui64),
mp->m_wait, mp->m_svc, mp->m_pct_w, mp->m_pct_b,
mp->m_new->module.fmds_value.str);
(void) fmd_adm_stats_free(g_adm, &ams);
}
static void
stat_xprt(void)
{
(void) printf("%3s %5s %7s %7s %7s %7s %4s %6s %3s %3s %s\n",
"id", "state", "ev_send", "ev_recv", "ev_drop", "ev_lost",
"wait", "svc_t", "%w", "%b", "module");
if (fmd_adm_xprt_iter(g_adm, stat_one_xprt, NULL) != 0)
die("failed to retrieve list of transports");
}
static void
stat_one_xprt_auth(id_t id, void *arg)
{
const char *module = arg;
fmd_adm_stats_t ams;
struct modstats *mp;
if (fmd_adm_xprt_stats(g_adm, id, &ams) != 0) {
warn("failed to retrieve statistics for transport %d", (int)id);
return;
}
for (mp = g_mods; mp != NULL; mp = mp->m_next) {
if (mp->m_id == id)
break;
}
if (mp == NULL && (mp = modstat_create(NULL, id)) == NULL) {
warn("failed to allocate memory for transport %d", (int)id);
(void) fmd_adm_stats_free(g_adm, &ams);
return;
}
modstat_compute(mp, &ams);
if (module == NULL ||
strcmp(module, mp->m_new->module.fmds_value.str) == 0) {
(void) printf("%3d %5s %-18s %s\n", (int)id,
mp->m_new->state.fmds_value.str,
mp->m_new->module.fmds_value.str,
mp->m_new->authority.fmds_value.str ?
mp->m_new->authority.fmds_value.str : "-");
}
(void) fmd_adm_stats_free(g_adm, &ams);
}
static void
stat_xprt_auth(const char *module)
{
(void) printf("%3s %5s %-18s %s\n",
"id", "state", "module", "authority");
if (fmd_adm_xprt_iter(g_adm, stat_one_xprt_auth, (void *)module) != 0)
die("failed to retrieve list of transports");
}
/*ARGSUSED*/
static int
stat_one_fmd(const fmd_adm_modinfo_t *ami, void *ignored)
{
char memsz[8], bufsz[8];
fmd_adm_stats_t ams;
struct modstats *mp;
if (fmd_adm_module_stats(g_adm, ami->ami_name, &ams) != 0) {
warn("failed to retrieve statistics for %s", ami->ami_name);
return (0); /* continue on to the next module */
}
for (mp = g_mods; mp != NULL; mp = mp->m_next) {
if (strcmp(mp->m_name, ami->ami_name) == 0)
break;
}
if (mp == NULL && (mp = modstat_create(ami->ami_name, 0)) == NULL) {
warn("failed to allocate memory for %s", ami->ami_name);
(void) fmd_adm_stats_free(g_adm, &ams);
return (0);
}
modstat_compute(mp, &ams);
(void) printf("%-18s %7llu %7llu %4.1f %6.1f %3.0f %3.0f "
"%5llu %5llu %6s %6s\n", ami->ami_name,
u64delta(mp->m_old->prdequeued.fmds_value.ui64,
mp->m_new->prdequeued.fmds_value.ui64),
u64delta(mp->m_old->accepted.fmds_value.ui64,
mp->m_new->accepted.fmds_value.ui64),
mp->m_wait, mp->m_svc, mp->m_pct_w, mp->m_pct_b,
mp->m_new->caseopen.fmds_value.ui64,
mp->m_new->casesolved.fmds_value.ui64,
size2str(memsz, sizeof (memsz),
mp->m_new->memtotal.fmds_value.ui64),
size2str(bufsz, sizeof (bufsz),
mp->m_new->buftotal.fmds_value.ui64));
(void) fmd_adm_stats_free(g_adm, &ams);
return (0);
}
static void
stat_fmd(void)
{
(void) printf("%-18s %7s %7s %4s %6s %3s %3s %5s %5s %6s %6s\n",
"module", "ev_recv", "ev_acpt", "wait", "svc_t", "%w", "%b",
"open", "solve", "memsz", "bufsz");
if (fmd_adm_module_iter(g_adm, stat_one_fmd, NULL) != 0)
die("failed to retrieve list of modules");
}
static void
stat_mod(const char *name, int aflag, int zflag)
{
fmd_adm_stats_t ams;
fmd_stat_t *sp;
char buf[64];
if (fmd_adm_stats_read(g_adm, name, &ams) != 0) {
die("failed to retrieve statistics for %s",
name ? name : "fmd(1M)");
}
(void) printf("%20s %-16s %s\n", "NAME", "VALUE", "DESCRIPTION");
for (sp = ams.ams_buf; sp < ams.ams_buf + ams.ams_len; sp++) {
if (aflag == 0 && strncmp(sp->fmds_name, "fmd.", 4) == 0)
continue; /* skip fmd-internal stats unless -a used */
if (zflag) {
switch (sp->fmds_type) {
case FMD_TYPE_INT32:
case FMD_TYPE_UINT32:
if (sp->fmds_value.ui32 == 0)
continue;
break;
case FMD_TYPE_INT64:
case FMD_TYPE_UINT64:
case FMD_TYPE_TIME:
case FMD_TYPE_SIZE:
if (sp->fmds_value.ui64 == 0)
continue;
break;
case FMD_TYPE_STRING:
if (sp->fmds_value.str == NULL ||
sp->fmds_value.str[0] == '\0')
continue;
break;
}
}
(void) printf("%20s ", sp->fmds_name);
switch (sp->fmds_type) {
case FMD_TYPE_BOOL:
(void) printf("%-16s",
sp->fmds_value.bool ? "true" : "false");
break;
case FMD_TYPE_INT32:
(void) printf("%-16d", sp->fmds_value.i32);
break;
case FMD_TYPE_UINT32:
(void) printf("%-16u", sp->fmds_value.ui32);
break;
case FMD_TYPE_INT64:
(void) printf("%-16lld", sp->fmds_value.i64);
break;
case FMD_TYPE_UINT64:
(void) printf("%-16llu", sp->fmds_value.ui64);
break;
case FMD_TYPE_STRING:
(void) printf("%-16s", sp->fmds_value.str ?
sp->fmds_value.str : "<<null>>");
break;
case FMD_TYPE_TIME:
(void) printf("%-16s",
time2str(buf, sizeof (buf), sp->fmds_value.ui64));
break;
case FMD_TYPE_SIZE:
(void) printf("%-16s",
size2str(buf, sizeof (buf), sp->fmds_value.ui64));
break;
default:
(void) snprintf(buf, sizeof (buf),
"<<type=%u>>\n", sp->fmds_type);
(void) printf("%-16s", buf);
}
(void) printf(" %s\n", sp->fmds_desc);
}
(void) fmd_adm_stats_free(g_adm, &ams);
}
/*ARGSUSED*/
static int
stat_one_serd(const fmd_adm_serdinfo_t *asi, void *ignored)
{
char buf1[32], buf2[32], n[32];
(void) snprintf(n, sizeof (n), ">%llu", asi->asi_n);
(void) printf("%-36s %3s %5s %3u %24s %s\n",
asi->asi_name, n, time2str(buf1, sizeof (buf1), asi->asi_t),
asi->asi_count, time2str(buf2, sizeof (buf2), asi->asi_delta),
(asi->asi_flags & FMD_ADM_SERD_FIRED) ? "fire" : "pend");
return (0);
}
static void
stat_mod_serd(const char *name)
{
(void) printf("%-36s %3s %5s %3s %24s %4s\n",
"NAME", ">N", "T", "CNT", "DELTA", "STAT");
if (fmd_adm_serd_iter(g_adm, name, stat_one_serd, NULL) != 0)
die("failed to retrieve serd engines for %s", name);
}
static int
getint(const char *name, const char *s)
{
long val;
char *p;
errno = 0;
val = strtol(s, &p, 10);
if (errno != 0 || p == s || *p != '\0' || val < 0 || val > INT_MAX) {
(void) fprintf(stderr, "%s: invalid %s argument -- %s\n",
g_pname, name, s);
exit(FMSTAT_EXIT_USAGE);
}
return ((int)val);
}
static uint32_t
getu32(const char *name, const char *s)
{
u_longlong_t val;
char *p;
errno = 0;
val = strtoull(s, &p, 0);
if (errno != 0 || p == s || *p != '\0' || val > UINT32_MAX) {
(void) fprintf(stderr, "%s: invalid %s argument -- %s\n",
g_pname, name, s);
exit(FMSTAT_EXIT_USAGE);
}
return ((uint32_t)val);
}
static int
usage(FILE *fp)
{
(void) fprintf(fp, "Usage: %s [-astTz] [-m module] "
"[-P prog] [-d d|u] [interval [count]]\n\n", g_pname);
(void) fprintf(fp,
"\t-a show all statistics, including those kept by fmd\n"
"\t-d display a timestamp in date (d) or unix time_t (u)\n"
"\t-m show module-specific statistics\n"
"\t-P connect to alternate fmd program\n"
"\t-s show module-specific serd engines\n"
"\t-t show transport-specific statistics\n"
"\t-T show transport modules and authorities\n"
"\t-z suppress zero-valued statistics\n");
return (FMSTAT_EXIT_USAGE);
}
int
main(int argc, char *argv[])
{
int opt_a = 0, opt_s = 0, opt_t = 0, opt_T = 0, opt_z = 0;
const char *opt_m = NULL;
int msec = 0, iter = 1;
uint32_t program;
char *p;
int c;
if ((p = strrchr(argv[0], '/')) == NULL)
g_pname = argv[0];
else
g_pname = p + 1;
if ((p = getenv("FMD_PROGRAM")) != NULL)
program = getu32("$FMD_PROGRAM", p);
else
program = FMD_ADM_PROGRAM;
(void) setlocale(LC_ALL, "");
(void) textdomain(TEXT_DOMAIN);
while ((c = getopt(argc, argv, "ad:m:P:stTz")) != EOF) {
switch (c) {
case 'a':
opt_a++;
break;
case 'd':
if (optarg) {
if (*optarg == 'u')
timestamp_fmt = UDATE;
else if (*optarg == 'd')
timestamp_fmt = DDATE;
else
return (usage(stderr));
} else {
return (usage(stderr));
}
break;
case 'm':
opt_m = optarg;
break;
case 'P':
program = getu32("program", optarg);
break;
case 's':
opt_s++;
break;
case 't':
opt_t++;
break;
case 'T':
opt_T++;
break;
case 'z':
opt_z++;
break;
default:
return (usage(stderr));
}
}
if (optind < argc) {
msec = getint("interval", argv[optind++]) * MILLISEC;
iter = -1;
}
if (optind < argc)
iter = getint("count", argv[optind++]);
if (optind < argc)
return (usage(stderr));
if (opt_t != 0 && (opt_m != NULL || opt_s != 0)) {
(void) fprintf(stderr,
"%s: -t cannot be used with -m or -s\n", g_pname);
return (FMSTAT_EXIT_USAGE);
}
if (opt_t != 0 && opt_T != 0) {
(void) fprintf(stderr,
"%s: -t and -T are mutually exclusive options\n", g_pname);
return (FMSTAT_EXIT_USAGE);
}
if (opt_m == NULL && opt_s != 0) {
(void) fprintf(stderr,
"%s: -s requires -m <module>\n", g_pname);
return (FMSTAT_EXIT_USAGE);
}
if ((g_adm = fmd_adm_open(NULL, program, FMD_ADM_VERSION)) == NULL)
die(NULL); /* fmd_adm_errmsg() has enough info */
while (iter < 0 || iter-- > 0) {
if (timestamp_fmt != NODATE)
print_timestamp(timestamp_fmt);
if (opt_s)
stat_mod_serd(opt_m);
else if (opt_T)
stat_xprt_auth(opt_m);
else if (opt_a || opt_m)
stat_mod(opt_m, opt_a, opt_z);
else if (opt_t)
stat_xprt();
else
stat_fmd();
if (iter != 0) {
(void) poll(NULL, 0, msec);
(void) putchar('\n');
}
}
fmd_adm_close(g_adm);
return (FMSTAT_EXIT_SUCCESS);
}
| 25.132191 | 79 | 0.641358 | [
"3d"
] |
e77afaf5f2c748e6a3cfa2e062db6e3122650df0 | 1,744 | h | C | include/main/hurricane/topology/ITopology.h | lihuaweishiyigehaoren/hurricane | 71118616dd08b7b2b46ecacd34b8bb642ac4ea9e | [
"Apache-2.0"
] | 3 | 2019-07-26T10:46:30.000Z | 2021-07-10T07:38:00.000Z | include/main/hurricane/topology/ITopology.h | lihuaweishiyigehaoren/hurricane | 71118616dd08b7b2b46ecacd34b8bb642ac4ea9e | [
"Apache-2.0"
] | null | null | null | include/main/hurricane/topology/ITopology.h | lihuaweishiyigehaoren/hurricane | 71118616dd08b7b2b46ecacd34b8bb642ac4ea9e | [
"Apache-2.0"
] | 1 | 2019-04-29T12:53:54.000Z | 2019-04-29T12:53:54.000Z | /**
* licensed to the apache software foundation (asf) under one
* or more contributor license agreements. see the notice file
* distributed with this work for additional information
* regarding copyright ownership. the asf licenses this file
* to you under the apache license, version 2.0 (the
* "license"); you may not use this file except in compliance
* with the license. you may obtain a copy of the license at
*
* http://www.apache.org/licenses/license-2.0
*
* unless required by applicable law or agreed to in writing, software
* distributed under the license is distributed on an "as is" basis,
* without warranties or conditions of any kind, either express or implied.
* see the license for the specific language governing permissions and
* limitations under the license.
*/
#pragma once
#include "hurricane/base/Values.h"
#include <string>
#include <memory>
#include <map>
namespace hurricane {
namespace spout {
class ISpout;
}
namespace bolt {
class IBolt;
}
namespace topology {
class ITopology {
public:
~ITopology () {}
virtual void SetSpouts(std::map<std::string, std::shared_ptr<spout::ISpout>> spouts) = 0;
virtual void SetBolts(std::map<std::string, std::shared_ptr<bolt::IBolt>> bolts) = 0;
virtual void SetNetwork(std::map<std::string, std::vector<std::string>> network) = 0;
virtual void EmitFrom(const std::string& src, const base::Values& values) = 0;
virtual const std::map<std::string, std::shared_ptr<spout::ISpout>>& GetSpouts() const = 0;
virtual const std::map<std::string, std::shared_ptr<bolt::IBolt>>& GetBolts() const = 0;
virtual const std::map<std::string, std::vector<std::string>>& GetNetwork() const = 0;
virtual void Start() = 0;
};
}
}
| 30.068966 | 93 | 0.715023 | [
"vector"
] |
e7800e96c5cedf11461f2facea600022b95aac95 | 8,287 | h | C | Freescale documentation/Inverter_ALL/src/MC56F8023/peripheral/pit.h | cpipero/solarinverter | 37ad18020201129f215c3372e9f6d6c8939ef2b3 | [
"CC0-1.0"
] | null | null | null | Freescale documentation/Inverter_ALL/src/MC56F8023/peripheral/pit.h | cpipero/solarinverter | 37ad18020201129f215c3372e9f6d6c8939ef2b3 | [
"CC0-1.0"
] | 2 | 2015-03-17T01:19:30.000Z | 2015-03-17T01:22:24.000Z | Freescale documentation/Inverter_ALL/src/MC56F8023/peripheral/pit.h | cpipero/solarinverter | 37ad18020201129f215c3372e9f6d6c8939ef2b3 | [
"CC0-1.0"
] | null | null | null | /*******************************************************************************
*
* Freescale Semiconductor Inc.
* (c) Copyright 2004-2009 Freescale Semiconductor, Inc.
* (c) Copyright 2001-2004 Motorola, Inc.
* ALL RIGHTS RESERVED.
*
********************************************************************************
*
* File Name: pit.h
*
* $Date: May-4-2009$
*
* $Version: 2.3.10.0$
*
* Description: Header file for the PIT driver
*
* HSCMP_VERSION_1 .. 56F802x/3x devices, see MC56F802x3xRM.pdf
* 56F800x devices, see MC56F80006RM.pdf
*
*******************************************************************************/
#ifndef __PIT_H
#define __PIT_H
/* qs.h is a master header file, which must be included */
#if !defined(__ARCH_H) || !defined(__PERIPH_H) || !defined(__APPCONFIG_H)
#error Please include qs.h before pit.h
#endif
#ifdef __cplusplus
extern "C" {
#endif
/******************************************************************************
*
* General Interface Description
*
*
* The Programmable Interval Timer (PIT) module contains a 16-bit up counter,
* a modulo register and a control register. The modulo and control registers
* are read/writable. The counter is read only.
*
* The modulo register is loaded with a value to count to and the prescaler is
* set to determine the counting rate. When enabled, the counter counts up to
* the modulo value and sets a flag (and an interrupt request if enabled),
* resets to $0000, and resumes counting.
*
******************************************************************************/
/************************************************************
* PIT module identifiers
*************************************************************/
#ifdef PIT_BASE
#define PIT (&ArchIO.Pit)
#endif
#ifdef PIT0_BASE
#define PIT_0 (&ArchIO.Pit0)
#endif
#ifdef PIT1_BASE
#define PIT_1 (&ArchIO.Pit1)
#endif
#ifdef PIT2_BASE
#define PIT_2 (&ArchIO.Pit2)
#endif
/*************************************************************
* arch.h should define device-specific information about PIT
**************************************************************/
#if !defined(PIT_VERSION)
#error PIT not properly described in arch.h
#endif
/****************************************************
* Configurable items, i.e. defines for appconfig.h
*****************************************************
#define PIT_CTRL_INIT
#define PIT_MOD_INIT
#define INTERRUPT_VECTOR_ADDR_yy userISR //specify interrupt handler routine : e.g. pit0ISR
#define INT_PRIORITY_LEVEL_yy INTC_xxx // interrupt level : (INTC_DISABLED, INTC_LEVEL0,
// INTC_LEVEL1 or INTC_LEVEL2)
where:
yy is interrupt vector number
e.g. On 56F8037
55 - PIT_0 rollover interrupt
*/
/*****************************************************************
* ioctl() commands
*
* Word16 ioctl( PIT_n, Command_name, Parameter );
*
******************************************************************
COMMAND NAME PARAMETERS, COMMENTS
--------------------------------------------------------*/
#define PIT_INIT /* NULL */
#define PIT_COUNTER /* PIT_ENABLE/PIT_DISABLE, enable/disable counter */
#define PIT_SLAVE_MODE /* PIT_ENABLE/PIT_DISABLE, enable/disable slave mode */
#define PIT_ROLLOVER_INT /* PIT_ENABLE/PIT_DISABLE, enable/disable PIT interrupt */
#define PIT_CLEAR_ROLLOVER_INT /* NULL, Clear PIT interrupt flag */
#define PIT_SET_PRESCALER /* PIT_PRESCALER_xxx, set PIT prescaler */
#define PIT_WRITE_MODULO_REG /* UWord16, sets modulo value */
#define PIT_READ_MODULO_REG /* NULL, returns modulo value */
#define PIT_READ_COUNTER_REG /* NULL, returns UWord16 counter value */
/***********************************************************************************************************
** PIT PARAMETERS DEFINITION **
***********************************************************************************************************/
#define PIT_ENABLE 1
#define PIT_DISABLE 0
/* PIT_SET_PRESCALER arguments */
#define PIT_PRESCALER_1 PIT_CTRL_PRESCALER_DIV1
#define PIT_PRESCALER_2 PIT_CTRL_PRESCALER_DIV2
#define PIT_PRESCALER_4 PIT_CTRL_PRESCALER_DIV4
#define PIT_PRESCALER_8 PIT_CTRL_PRESCALER_DIV8
#define PIT_PRESCALER_16 PIT_CTRL_PRESCALER_DIV16
#define PIT_PRESCALER_32 PIT_CTRL_PRESCALER_DIV32
#define PIT_PRESCALER_64 PIT_CTRL_PRESCALER_DIV64
#define PIT_PRESCALER_128 PIT_CTRL_PRESCALER_DIV128
#define PIT_PRESCALER_256 PIT_CTRL_PRESCALER_DIV256
#define PIT_PRESCALER_512 PIT_CTRL_PRESCALER_DIV512
#define PIT_PRESCALER_1024 PIT_CTRL_PRESCALER_DIV1024
#define PIT_PRESCALER_2048 PIT_CTRL_PRESCALER_DIV2048
#define PIT_PRESCALER_4096 PIT_CTRL_PRESCALER_DIV4096
#define PIT_PRESCALER_8192 PIT_CTRL_PRESCALER_DIV8192
#define PIT_PRESCALER_16384 PIT_CTRL_PRESCALER_DIV16384
#define PIT_PRESCALER_32768 PIT_CTRL_PRESCALER_DIV32768
/****************************************************************************
* register and bit names used in the ioctl functions below
*****************************************************************************/
/* CTRL register */
#define PIT_CTRL_SLAVE 0x8000
#define PIT_CTRL_PRESCALER_MASK 0x0078
#define PIT_CTRL_PRESCALER_DIV1 0x0000
#define PIT_CTRL_PRESCALER_DIV2 0x0008
#define PIT_CTRL_PRESCALER_DIV4 0x0010
#define PIT_CTRL_PRESCALER_DIV8 0x0018
#define PIT_CTRL_PRESCALER_DIV16 0x0020
#define PIT_CTRL_PRESCALER_DIV32 0x0028
#define PIT_CTRL_PRESCALER_DIV64 0x0030
#define PIT_CTRL_PRESCALER_DIV128 0x0038
#define PIT_CTRL_PRESCALER_DIV256 0x0040
#define PIT_CTRL_PRESCALER_DIV512 0x0048
#define PIT_CTRL_PRESCALER_DIV1024 0x0050
#define PIT_CTRL_PRESCALER_DIV2048 0x0058
#define PIT_CTRL_PRESCALER_DIV4096 0x0060
#define PIT_CTRL_PRESCALER_DIV8192 0x0068
#define PIT_CTRL_PRESCALER_DIV16384 0x0070
#define PIT_CTRL_PRESCALER_DIV32768 0x0078
#define PIT_CTRL_PRF 0x0004
#define PIT_CTRL_PRIE 0x0002
#define PIT_CTRL_CNT_EN 0x0001
/****************************************************************************
* PIT ioctl macro implementation
*****************************************************************************/
/* PIT init */
void pitInit(arch_sPIT *pPitBase);
#define ioctlPIT_INIT(pPitBase, param) pitInit(pPitBase)
/* PIT control register */
/* Enable/Disable PIT counter */
#define ioctlPIT_COUNTER(pPitBase, param) \
if (param) periphBitSet(PIT_CTRL_CNT_EN, &((pPitBase)->ctrl)); \
else periphBitClear(PIT_CTRL_CNT_EN, &((pPitBase)->ctrl))
/* Enable/Disable PIT slave mode */
#define ioctlPIT_SLAVE_MODE(pPitBase, param) \
if (param) periphBitSet(PIT_CTRL_SLAVE, &((pPitBase)->ctrl)); \
else periphBitClear(PIT_CTRL_SLAVE, &((pPitBase)->ctrl))
/* Enable/disable PIT interrupt */
#define ioctlPIT_ROLLOVER_INT(pPitBase, param) \
if(param) periphBitSet(PIT_CTRL_PRIE, &((pPitBase)->ctrl)); \
else periphBitClear(PIT_CTRL_PRIE, &((pPitBase)->ctrl))
/* Clear PIT interrupt */
#define ioctlPIT_CLEAR_ROLLOVER_INT(pPitBase, param) \
periphBitClear(PIT_CTRL_PRF, &((pPitBase)->ctrl))
/* Set PIT prescaler */
#define ioctlPIT_SET_PRESCALER(pPitBase, param) \
periphBitGrpSR(PIT_CTRL_PRESCALER_MASK, param, &((pPitBase)->ctrl))
/* PIT counter/modulo registers */
#define ioctlPIT_WRITE_MODULO_REG(pPitBase, param) \
periphMemWrite(param, &((pPitBase)->mod))
#define ioctlPIT_READ_MODULO_REG(pPitBase, param) \
periphMemRead(&((pPitBase)->mod))
#define ioctlPIT_READ_COUNTER_REG(pPitBase, param) \
periphMemRead(&((pPitBase)->cntr))
#ifdef __cplusplus
}
#endif
#endif
| 38.18894 | 109 | 0.563775 | [
"vector"
] |
e789d29df6ab8e963c92e13cb3eca13c88bc3201 | 2,510 | h | C | HTWK_SD_FILTER/SD_LaneDetection/AbstractHough.h | HTWKSmartDriving/aadc-2015 | 95ee77aa0f9ebbb541bbb1e3b99d3f044347d103 | [
"BSD-2-Clause"
] | 2 | 2017-11-29T00:15:26.000Z | 2017-11-29T01:45:54.000Z | HTWK_SD_FILTER/SD_LaneDetection/AbstractHough.h | HTWKSmartDriving/aadc-2015 | 95ee77aa0f9ebbb541bbb1e3b99d3f044347d103 | [
"BSD-2-Clause"
] | null | null | null | HTWK_SD_FILTER/SD_LaneDetection/AbstractHough.h | HTWKSmartDriving/aadc-2015 | 95ee77aa0f9ebbb541bbb1e3b99d3f044347d103 | [
"BSD-2-Clause"
] | 2 | 2017-11-28T23:47:27.000Z | 2019-07-19T08:04:50.000Z | /**
* Copyright (c) 2014-2015, HTWK SmartDriving
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* AUTHORS: Silvio Feig, Denny Hecht, Andreas Kluge, Lars Kollmann, Eike Florian Petersen, Artem Pokas
*
*/
#ifndef _HOUGH_H_
#define _HOUGH_H_
#include "SmartDrivingUtilities.h"
using namespace smartdriving;
namespace smartdriving
{
class AbstractHough
{
private:
int houghSpaceHeight;
int houghSpaceWidth;
double imageCenterX;
double imageCenterY;
public:
AbstractHough();
virtual ~AbstractHough();
public:
virtual void transform(void) = 0;
vector<SD_Line> getLines(const int &threshold);
void setImage(const cv::Mat&);
private:
bool isLocalMaximaFound(int&, int&, const int&);
const int getHoughSpaceIndex(const int&, const int&) const;
bool isPositionInImage(const pair<int, int>&, const int&, const int&) const;
int getYCoord(const int&, const int&, const int&);
int getXCoord(const int&, const int&, const int&);
protected:
unique_ptr<unsigned int[]> houghSpace;
cv::Mat image;
int imageWidth;
int imageHeight;
double houghSpaceHeightRelative;
void initHough(void);
double getDistance(const int&, const int&, const int&) const;
};
}
#endif /* HOUGH_H_ */ | 32.597403 | 102 | 0.748606 | [
"vector",
"transform"
] |
e78a77d1fc0a6ac3d430ef079b5afe8f57d4ea1e | 1,708 | h | C | Framework/Sources/Core/HLSNotifications.h | defagos/CoconutKit | 8534e14bec19e843ba564ff7a182717126904eba | [
"BSD-3-Clause"
] | 294 | 2015-01-01T12:52:03.000Z | 2022-02-06T10:10:16.000Z | Framework/Sources/Core/HLSNotifications.h | jennyb2911/CoconutKit | e2c19f27519726b3240773b5ef328a3d679a130c | [
"BSD-3-Clause"
] | 14 | 2015-03-17T20:25:27.000Z | 2019-08-07T07:14:18.000Z | Framework/Sources/Core/HLSNotifications.h | jennyb2911/CoconutKit | e2c19f27519726b3240773b5ef328a3d679a130c | [
"BSD-3-Clause"
] | 41 | 2015-01-04T15:31:57.000Z | 2021-01-18T06:07:42.000Z | //
// Copyright (c) Samuel Défago. All rights reserved.
//
// License information is available from the LICENSE file.
//
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
/**
* Manages application-wide notification mechanisms
*
* This class is not thread-safe
*/
@interface HLSNotificationManager : NSObject
/**
* Get the shared object managing application-wide notifications
*/
+ (HLSNotificationManager *)sharedNotificationManager;
/**
* Call this method to notify that a network task has started. This method can be called several times if several
* tasks are running simultaneously (an activity indicator is displayed in the status bar when at least one task
* is running)
*/
- (void)notifyBeginNetworkActivity;
/**
* Call this method to notify that a network task has ended. This method can be called several times if several
* tasks are running simultaneously (an activity indicator is displayed in the status bar when at least one task
* is running)
*/
- (void)notifyEndNetworkActivity;
@end
/**
* Extensions for writing less notification code in the most common cases
*/
@interface NSObject (HLSNotificationExtensions)
- (void)postCoalescingNotificationWithName:(NSString *)name userInfo:(nullable NSDictionary *)userInfo;
- (void)postCoalescingNotificationWithName:(NSString *)name;
@end
@interface NSNotificationCenter (HLSNotificationExtensions)
- (void)addObserver:(id)observer selector:(SEL)selector name:(nullable NSString *)name objectsInCollection:(nullable id<NSFastEnumeration>)collection;
- (void)removeObserver:(id)observer name:(nullable NSString *)name objectsInCollection:(nullable id<NSFastEnumeration>)collection;
@end
NS_ASSUME_NONNULL_END
| 29.964912 | 150 | 0.78103 | [
"object"
] |
e78b5a14812b265aec15ad480c11d97f9957b624 | 1,215 | h | C | src/saiga/cuda/interop.h | muetimueti/saiga | 32b54a8fc7b1251368e07e7d31c15ac90cee3b32 | [
"MIT"
] | null | null | null | src/saiga/cuda/interop.h | muetimueti/saiga | 32b54a8fc7b1251368e07e7d31c15ac90cee3b32 | [
"MIT"
] | null | null | null | src/saiga/cuda/interop.h | muetimueti/saiga | 32b54a8fc7b1251368e07e7d31c15ac90cee3b32 | [
"MIT"
] | null | null | null | /**
* Copyright (c) 2017 Darius Rückert
* Licensed under the MIT License.
* See LICENSE file for more information.
*/
#pragma once
#include "saiga/cuda/cudaHelper.h"
#include "saiga/opengl/opengl.h"
#include <iostream>
struct cudaGraphicsResource;
namespace Saiga
{
namespace CUDA
{
class SAIGA_CUDA_API Interop
{
private:
unsigned int gl_buffer;
cudaGraphicsResource* graphic_resource;
void* device_ptr;
size_t size;
bool mapped;
GLenum gl_target;
public:
Interop();
~Interop();
// Registers an OpenGL buffer object. Wrapper for cudaGraphicsGLRegisterBuffer
void registerBuffer(int glbuffer);
void unregisterBuffer();
// Maps graphic resource to be accessed by CUDA. Wrapper for cudaGraphicsMapResources
void map();
// Unmap graphics resources. Wrapper for cudaGraphicsUnmapResources
void unmap();
// Get an device pointer through which to access a mapped graphics resource. Wrapper for
// cudaGraphicsResourceGetMappedPointer
void* getDevicePtr();
size_t get_size() { return size; }
void initImage(unsigned int gl_buffer, GLenum gl_target);
void mapImage();
};
} // namespace CUDA
} // namespace Saiga
| 20.948276 | 92 | 0.714403 | [
"object"
] |
e79463aabea0b5258143577d5d231627aa4fbde9 | 6,404 | h | C | template_mp/src/public/engine/ivmodelrender.h | moeabm/VS2013 | dd29099567b286acac7bb542a06f085df78ea480 | [
"Unlicense"
] | null | null | null | template_mp/src/public/engine/ivmodelrender.h | moeabm/VS2013 | dd29099567b286acac7bb542a06f085df78ea480 | [
"Unlicense"
] | null | null | null | template_mp/src/public/engine/ivmodelrender.h | moeabm/VS2013 | dd29099567b286acac7bb542a06f085df78ea480 | [
"Unlicense"
] | null | null | null | //========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
#ifndef IVMODELRENDER_H
#define IVMODELRENDER_H
#ifdef _WIN32
#pragma once
#endif
#include "interface.h"
#include "mathlib/mathlib.h"
#include "istudiorender.h"
//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------
struct mstudioanimdesc_t;
struct mstudioseqdesc_t;
struct model_t;
class IClientRenderable;
class Vector;
struct studiohdr_t;
class IMaterial;
class CStudioHdr;
FORWARD_DECLARE_HANDLE( LightCacheHandle_t );
//-----------------------------------------------------------------------------
// Model rendering state
//-----------------------------------------------------------------------------
struct DrawModelState_t
{
studiohdr_t* m_pStudioHdr;
studiohwdata_t* m_pStudioHWData;
IClientRenderable* m_pRenderable;
const matrix3x4_t *m_pModelToWorld;
StudioDecalHandle_t m_decals;
int m_drawFlags;
int m_lod;
};
//-----------------------------------------------------------------------------
// Model Rendering + instance data
//-----------------------------------------------------------------------------
// change this when the new version is incompatable with the old
#define VENGINE_HUDMODEL_INTERFACE_VERSION "VEngineModel016"
typedef unsigned short ModelInstanceHandle_t;
enum
{
MODEL_INSTANCE_INVALID = (ModelInstanceHandle_t)~0
};
struct ModelRenderInfo_t
{
Vector origin;
QAngle angles;
IClientRenderable *pRenderable;
const model_t *pModel;
const matrix3x4_t *pModelToWorld;
const matrix3x4_t *pLightingOffset;
const Vector *pLightingOrigin;
int flags;
int entity_index;
int skin;
int body;
int hitboxset;
ModelInstanceHandle_t instance;
ModelRenderInfo_t()
{
pModelToWorld = NULL;
pLightingOffset = NULL;
pLightingOrigin = NULL;
}
};
struct StaticPropRenderInfo_t
{
const matrix3x4_t *pModelToWorld;
const model_t *pModel;
IClientRenderable *pRenderable;
Vector *pLightingOrigin;
short skin;
ModelInstanceHandle_t instance;
};
// UNDONE: Move this to hud export code, subsume previous functions
abstract_class IVModelRender
{
public:
virtual int DrawModel( int flags,
IClientRenderable *pRenderable,
ModelInstanceHandle_t instance,
int entity_index,
const model_t *model,
Vector const& origin,
QAngle const& angles,
int skin,
int body,
int hitboxset,
const matrix3x4_t *modelToWorld = NULL,
const matrix3x4_t *pLightingOffset = NULL ) = 0;
// This causes a material to be used when rendering the model instead
// of the materials the model was compiled with
virtual void ForcedMaterialOverride( IMaterial *newMaterial, OverrideType_t nOverrideType = OVERRIDE_NORMAL ) = 0;
virtual void SetViewTarget( const CStudioHdr *pStudioHdr, int nBodyIndex, const Vector& target ) = 0;
// Creates, destroys instance data to be associated with the model
virtual ModelInstanceHandle_t CreateInstance( IClientRenderable *pRenderable, LightCacheHandle_t *pCache = NULL ) = 0;
virtual void DestroyInstance( ModelInstanceHandle_t handle ) = 0;
// Associates a particular lighting condition with a model instance handle.
// FIXME: This feature currently only works for static props. To make it work for entities, etc.,
// we must clean up the lightcache handles as the model instances are removed.
// At the moment, since only the static prop manager uses this, it cleans up all LightCacheHandles
// at level shutdown.
virtual void SetStaticLighting( ModelInstanceHandle_t handle, LightCacheHandle_t* pHandle ) = 0;
virtual LightCacheHandle_t GetStaticLighting( ModelInstanceHandle_t handle ) = 0;
// moves an existing InstanceHandle to a nex Renderable to keep decals etc. Models must be the same
virtual bool ChangeInstance( ModelInstanceHandle_t handle, IClientRenderable *pRenderable ) = 0;
// Creates a decal on a model instance by doing a planar projection
// along the ray. The material is the decal material, the radius is the
// radius of the decal to create.
virtual void AddDecal( ModelInstanceHandle_t handle, Ray_t const& ray,
Vector const& decalUp, int decalIndex, int body, bool noPokeThru = false, int maxLODToDecal = ADDDECAL_TO_ALL_LODS ) = 0;
// Removes all the decals on a model instance
virtual void RemoveAllDecals( ModelInstanceHandle_t handle ) = 0;
// Remove all decals from all models
virtual void RemoveAllDecalsFromAllModels() = 0;
// Shadow rendering, DrawModelShadowSetup returns the address of the bone-to-world array, NULL in case of error
virtual matrix3x4_t* DrawModelShadowSetup( IClientRenderable *pRenderable, int body, int skin, DrawModelInfo_t *pInfo, matrix3x4_t *pCustomBoneToWorld = NULL ) = 0;
virtual void DrawModelShadow( IClientRenderable *pRenderable, const DrawModelInfo_t &info, matrix3x4_t *pCustomBoneToWorld = NULL ) = 0;
// This gets called when overbright, etc gets changed to recompute static prop lighting.
virtual bool RecomputeStaticLighting( ModelInstanceHandle_t handle ) = 0;
virtual void ReleaseAllStaticPropColorData( void ) = 0;
virtual void RestoreAllStaticPropColorData( void ) = 0;
// Extended version of drawmodel
virtual int DrawModelEx( ModelRenderInfo_t &pInfo ) = 0;
virtual int DrawModelExStaticProp( ModelRenderInfo_t &pInfo ) = 0;
virtual bool DrawModelSetup( ModelRenderInfo_t &pInfo, DrawModelState_t *pState, matrix3x4_t *pCustomBoneToWorld, matrix3x4_t** ppBoneToWorldOut ) = 0;
virtual void DrawModelExecute( const DrawModelState_t &state, const ModelRenderInfo_t &pInfo, matrix3x4_t *pCustomBoneToWorld = NULL ) = 0;
// Sets up lighting context for a point in space
virtual void SetupLighting( const Vector &vecCenter ) = 0;
// doesn't support any debug visualization modes or other model options, but draws static props in the
// fastest way possible
virtual int DrawStaticPropArrayFast( StaticPropRenderInfo_t *pProps, int count, bool bShadowDepth ) = 0;
// Allow client to override lighting state
virtual void SuppressEngineLighting( bool bSuppress ) = 0;
virtual void SetupColorMeshes( int nTotalVerts ) = 0;
};
#endif // IVMODELRENDER_H
| 35.381215 | 165 | 0.699407 | [
"vector",
"model"
] |
e79476ed8b0a9b556b3ca8a41d2e1c5cbfe17ff9 | 906 | h | C | views/window/window_resources.h | rwatson/chromium-capsicum | b03da8e897f897c6ad2cda03ceda217b760fd528 | [
"BSD-3-Clause"
] | 11 | 2015-03-20T04:08:08.000Z | 2021-11-15T15:51:36.000Z | views/window/window_resources.h | changbai1980/chromium | c4625eefca763df86471d798ee5a4a054b4716ae | [
"BSD-3-Clause"
] | null | null | null | views/window/window_resources.h | changbai1980/chromium | c4625eefca763df86471d798ee5a4a054b4716ae | [
"BSD-3-Clause"
] | null | null | null | // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef VIEWS_WINDOW_WINDOW_RESOURCES_H_
#define VIEWS_WINDOW_WINDOW_RESOURCES_H_
class SkBitmap;
namespace views {
typedef int FramePartBitmap;
///////////////////////////////////////////////////////////////////////////////
// WindowResources
//
// An interface implemented by an object providing bitmaps to render the
// contents of a window frame. The Window may swap in different
// implementations of this interface to render different modes. The definition
// of FramePartBitmap depends on the implementation.
//
class WindowResources {
public:
virtual ~WindowResources() { }
virtual SkBitmap* GetPartBitmap(FramePartBitmap part) const = 0;
};
} // namespace views
#endif // VIEWS_WINDOW_WINDOW_RESOURCES_H_
| 29.225806 | 79 | 0.707506 | [
"render",
"object"
] |
436ea1719ed63a19e716da0a38114d1e7c6c2564 | 3,011 | h | C | include/vsgImGui/RenderImGui.h | rolandhill/vsgImGui | 998ee3d1e4b329f15016462eb672f2182314f75d | [
"MIT"
] | 1 | 2021-03-14T12:05:13.000Z | 2021-03-14T12:05:13.000Z | include/vsgImGui/RenderImGui.h | rolandhill/vsgImGui | 998ee3d1e4b329f15016462eb672f2182314f75d | [
"MIT"
] | null | null | null | include/vsgImGui/RenderImGui.h | rolandhill/vsgImGui | 998ee3d1e4b329f15016462eb672f2182314f75d | [
"MIT"
] | null | null | null | #pragma once
/* <editor-fold desc="MIT License">
Copyright(c) 2021 Don Burns, Roland Hill and Robert Osfield.
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
</editor-fold> */
#include <functional>
#include <vsg/commands/ClearAttachments.h>
#include <vsg/viewer/Window.h>
#include <vsg/vk/DescriptorPool.h>
#include <vsgImGui/Export.h>
#include <vsgImGui/imgui.h>
namespace vsgImGui
{
class VSGIMGUI_DECLSPEC RenderImGui : public vsg::Inherit<vsg::Command, RenderImGui>
{
public:
RenderImGui(const vsg::ref_ptr<vsg::Window>& window, bool useClearAttachments = false);
template<typename... Args>
RenderImGui(const vsg::ref_ptr<vsg::Window>& window, Args&... args) :
RenderImGui(window, false)
{
(add(args), ...);
}
template<typename... Args>
RenderImGui(const vsg::ref_ptr<vsg::Window>& window, Args&... args, bool useClearAttachments) :
RenderImGui(window, useClearAttachments)
{
(add(args), ...);
}
using Component = std::function<bool()>;
using Components = std::list<Component>;
/// add a GUI rendering component that provides the ImGui calls to render the
/// required GUI elements.
void add(const Component& component);
Components& getComponents() { return _components; }
const Components& getComponents() const { return _components; }
bool renderComponents() const;
void record(vsg::CommandBuffer& commandBuffer) const override;
void _uploadFonts();
private:
virtual ~RenderImGui();
vsg::ref_ptr<vsg::Device> _device;
uint32_t _queueFamily;
vsg::ref_ptr<vsg::Queue> _queue;
vsg::ref_ptr<vsg::DescriptorPool> _descriptorPool;
Components _components;
vsg::ref_ptr<vsg::ClearAttachments> _clearAttachments;
void _init(const vsg::ref_ptr<vsg::Window>& window);
};
} // namespace vsgImGui
EVSG_type_name(vsgImGui::RenderImGui);
| 33.455556 | 103 | 0.698771 | [
"render"
] |
43730c9e31fd6ef3009c23cdd45d8a0320693b62 | 23,638 | h | C | chrome/browser/sync/glue/sync_backend_host.h | quisquous/chromium | b25660e05cddc9d0c3053b3514f07037acc69a10 | [
"BSD-3-Clause"
] | 2 | 2020-06-10T07:15:26.000Z | 2020-12-13T19:44:12.000Z | chrome/browser/sync/glue/sync_backend_host.h | quisquous/chromium | b25660e05cddc9d0c3053b3514f07037acc69a10 | [
"BSD-3-Clause"
] | null | null | null | chrome/browser/sync/glue/sync_backend_host.h | quisquous/chromium | b25660e05cddc9d0c3053b3514f07037acc69a10 | [
"BSD-3-Clause"
] | null | null | null | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
#define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
#include <string>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/threading/thread.h"
#include "chrome/browser/sync/glue/backend_data_type_configurer.h"
#include "chrome/browser/sync/glue/chrome_extensions_activity_monitor.h"
#include "google_apis/gaia/google_service_auth_error.h"
#include "googleurl/src/gurl.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/internal_api/public/configure_reason.h"
#include "sync/internal_api/public/engine/model_safe_worker.h"
#include "sync/internal_api/public/sessions/sync_session_snapshot.h"
#include "sync/internal_api/public/sync_encryption_handler.h"
#include "sync/internal_api/public/sync_manager.h"
#include "sync/internal_api/public/util/report_unrecoverable_error_function.h"
#include "sync/internal_api/public/util/unrecoverable_error_handler.h"
#include "sync/internal_api/public/util/weak_handle.h"
#include "sync/notifier/invalidation_handler.h"
#include "sync/notifier/invalidator_factory.h"
#include "sync/protocol/encryption.pb.h"
#include "sync/protocol/sync_protocol_error.h"
class MessageLoop;
class Profile;
namespace syncer {
class SyncManagerFactory;
}
namespace browser_sync {
class ChangeProcessor;
class ChromeSyncNotificationBridge;
struct Experiments;
class InvalidatorStorage;
class SyncBackendRegistrar;
class SyncPrefs;
// SyncFrontend is the interface used by SyncBackendHost to communicate with
// the entity that created it and, presumably, is interested in sync-related
// activity.
// NOTE: All methods will be invoked by a SyncBackendHost on the same thread
// used to create that SyncBackendHost.
class SyncFrontend : public syncer::InvalidationHandler {
public:
SyncFrontend() {}
// The backend has completed initialization and it is now ready to
// accept and process changes. If success is false, initialization
// wasn't able to be completed and should be retried.
//
// |js_backend| is what about:sync interacts with; it's different
// from the 'Backend' in 'OnBackendInitialized' (unfortunately). It
// is initialized only if |success| is true.
virtual void OnBackendInitialized(
const syncer::WeakHandle<syncer::JsBackend>& js_backend,
bool success) = 0;
// The backend queried the server recently and received some updates.
virtual void OnSyncCycleCompleted() = 0;
// Configure ran into some kind of error. But it is scheduled to be
// retried.
virtual void OnSyncConfigureRetry() = 0;
// The status of the connection to the sync server has changed.
virtual void OnConnectionStatusChange(
syncer::ConnectionStatus status) = 0;
// We are no longer permitted to communicate with the server. Sync should
// be disabled and state cleaned up at once.
virtual void OnStopSyncingPermanently() = 0;
// The syncer requires a passphrase to decrypt sensitive updates. This is
// called when the first sensitive data type is setup by the user and anytime
// the passphrase is changed by another synced client. |reason| denotes why
// the passphrase was required. |pending_keys| is a copy of the
// cryptographer's pending keys to be passed on to the frontend in order to
// be cached.
virtual void OnPassphraseRequired(
syncer::PassphraseRequiredReason reason,
const sync_pb::EncryptedData& pending_keys) = 0;
// Called when the passphrase provided by the user is
// accepted. After this is called, updates to sensitive nodes are
// encrypted using the accepted passphrase.
virtual void OnPassphraseAccepted() = 0;
// Called when the set of encrypted types or the encrypt everything
// flag has been changed. Note that encryption isn't complete until
// the OnEncryptionComplete() notification has been sent (see
// below).
//
// |encrypted_types| will always be a superset of
// syncer::Cryptographer::SensitiveTypes(). If |encrypt_everything| is
// true, |encrypted_types| will be the set of all known types.
//
// Until this function is called, observers can assume that the set
// of encrypted types is syncer::Cryptographer::SensitiveTypes() and that
// the encrypt everything flag is false.
virtual void OnEncryptedTypesChanged(
syncer::ModelTypeSet encrypted_types,
bool encrypt_everything) = 0;
// Called after we finish encrypting the current set of encrypted
// types.
virtual void OnEncryptionComplete() = 0;
// Called to perform migration of |types|.
virtual void OnMigrationNeededForTypes(syncer::ModelTypeSet types) = 0;
// Inform the Frontend that new datatypes are available for registration.
virtual void OnExperimentsChanged(
const syncer::Experiments& experiments) = 0;
// Called when the sync cycle returns there is an user actionable error.
virtual void OnActionableError(const syncer::SyncProtocolError& error) = 0;
protected:
// Don't delete through SyncFrontend interface.
virtual ~SyncFrontend() {
}
private:
DISALLOW_COPY_AND_ASSIGN(SyncFrontend);
};
// A UI-thread safe API into the sync backend that "hosts" the top-level
// syncapi element, the SyncManager, on its own thread. This class handles
// dispatch of potentially blocking calls to appropriate threads and ensures
// that the SyncFrontend is only accessed on the UI loop.
class SyncBackendHost : public BackendDataTypeConfigurer {
public:
typedef syncer::SyncStatus Status;
// Create a SyncBackendHost with a reference to the |frontend| that
// it serves and communicates to via the SyncFrontend interface (on
// the same thread it used to call the constructor). Must outlive
// |sync_prefs| and |invalidator_storage|.
SyncBackendHost(
const std::string& name,
Profile* profile,
const base::WeakPtr<SyncPrefs>& sync_prefs,
// TODO(tim): Temporary, remove when bug 124137 finished.
const base::WeakPtr<InvalidatorStorage>& invalidator_storage);
// For testing.
// TODO(skrul): Extract an interface so this is not needed.
explicit SyncBackendHost(Profile* profile);
virtual ~SyncBackendHost();
// Called on |frontend_loop_| to kick off asynchronous initialization.
// As a fallback when no cached auth information is available, try to
// bootstrap authentication using |lsid|, if it isn't empty.
// Optionally delete the Sync Data folder (if it's corrupt).
// |report_unrecoverable_error_function| can be NULL.
// Note: |unrecoverable_error_handler| may be invoked from any thread.
void Initialize(
SyncFrontend* frontend,
const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
const GURL& service_url,
const syncer::SyncCredentials& credentials,
bool delete_sync_data_folder,
syncer::SyncManagerFactory* sync_manager_factory,
syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
syncer::ReportUnrecoverableErrorFunction
report_unrecoverable_error_function);
// Called on |frontend_loop| to update SyncCredentials.
void UpdateCredentials(const syncer::SyncCredentials& credentials);
// Registers the underlying frontend for the given IDs to the underlying
// notifier. This lasts until StopSyncingForShutdown() is called.
void UpdateRegisteredInvalidationIds(const syncer::ObjectIdSet& ids);
// This starts the SyncerThread running a Syncer object to communicate with
// sync servers. Until this is called, no changes will leave or enter this
// browser from the cloud / sync servers.
// Called on |frontend_loop_|.
virtual void StartSyncingWithServer();
// Called on |frontend_loop_| to asynchronously set a new passphrase for
// encryption. Note that it is an error to call SetEncryptionPassphrase under
// the following circumstances:
// - An explicit passphrase has already been set
// - |is_explicit| is true and we have pending keys.
// When |is_explicit| is false, a couple of things could happen:
// - If there are pending keys, we try to decrypt them. If decryption works,
// this acts like a call to SetDecryptionPassphrase. If not, the GAIA
// passphrase passed in is cached so we can re-encrypt with it in future.
// - If there are no pending keys, data is encrypted with |passphrase| (this
// is a no-op if data was already encrypted with |passphrase|.)
void SetEncryptionPassphrase(const std::string& passphrase, bool is_explicit);
// Called on |frontend_loop_| to use the provided passphrase to asynchronously
// attempt decryption. Returns false immediately if the passphrase could not
// be used to decrypt a locally cached copy of encrypted keys; returns true
// otherwise. If new encrypted keys arrive during the asynchronous call,
// OnPassphraseRequired may be triggered at a later time. It is an error to
// call this when there are no pending keys.
bool SetDecryptionPassphrase(const std::string& passphrase)
WARN_UNUSED_RESULT;
// Called on |frontend_loop_| to kick off shutdown procedure. After this, no
// further sync activity will occur with the sync server and no further
// change applications will occur from changes already downloaded.
// Furthermore, no notifications will be sent to any invalidation handler.
virtual void StopSyncingForShutdown();
// Called on |frontend_loop_| to kick off shutdown.
// |sync_disabled| indicates if syncing is being disabled or not.
// See the implementation and Core::DoShutdown for details.
// Must be called *after* StopSyncingForShutdown.
void Shutdown(bool sync_disabled);
// Changes the set of data types that are currently being synced.
// The ready_task will be run when configuration is done with the
// set of all types that failed configuration (i.e., if its argument
// is non-empty, then an error was encountered).
virtual void ConfigureDataTypes(
syncer::ConfigureReason reason,
syncer::ModelTypeSet types_to_add,
syncer::ModelTypeSet types_to_remove,
const base::Callback<void(syncer::ModelTypeSet)>& ready_task,
const base::Callback<void()>& retry_callback) OVERRIDE;
// Turns on encryption of all present and future sync data.
virtual void EnableEncryptEverything();
// Activates change processing for the given data type. This must
// be called synchronously with the data type's model association so
// no changes are dropped between model association and change
// processor activation.
void ActivateDataType(
syncer::ModelType type, syncer::ModelSafeGroup group,
ChangeProcessor* change_processor);
// Deactivates change processing for the given data type.
void DeactivateDataType(syncer::ModelType type);
// Called on |frontend_loop_| to obtain a handle to the UserShare needed for
// creating transactions. Should not be called before we signal
// initialization is complete with OnBackendInitialized().
syncer::UserShare* GetUserShare() const;
// Called from any thread to obtain current status information in detailed or
// summarized form.
Status GetDetailedStatus();
syncer::sessions::SyncSessionSnapshot GetLastSessionSnapshot() const;
// Determines if the underlying sync engine has made any local changes to
// items that have not yet been synced with the server.
// ONLY CALL THIS IF OnInitializationComplete was called!
bool HasUnsyncedItems() const;
// Whether or not we are syncing encryption keys.
bool IsNigoriEnabled() const;
// Whether or not the Nigori node is encrypted using an explicit passphrase.
bool IsUsingExplicitPassphrase();
// True if the cryptographer has any keys available to attempt decryption.
// Could mean we've downloaded and loaded Nigori objects, or we bootstrapped
// using a token previously received.
bool IsCryptographerReady(const syncer::BaseTransaction* trans) const;
void GetModelSafeRoutingInfo(syncer::ModelSafeRoutingInfo* out) const;
protected:
// The types and functions below are protected so that test
// subclasses can use them.
//
// TODO(akalin): Figure out a better way for tests to hook into
// SyncBackendHost.
typedef base::Callback<scoped_ptr<syncer::HttpPostProviderFactory>(void)>
MakeHttpBridgeFactoryFn;
struct DoInitializeOptions {
DoInitializeOptions(
MessageLoop* sync_loop,
SyncBackendRegistrar* registrar,
const syncer::ModelSafeRoutingInfo& routing_info,
const std::vector<syncer::ModelSafeWorker*>& workers,
syncer::ExtensionsActivityMonitor* extensions_activity_monitor,
const syncer::WeakHandle<syncer::JsEventHandler>& event_handler,
const GURL& service_url,
MakeHttpBridgeFactoryFn make_http_bridge_factory_fn,
const syncer::SyncCredentials& credentials,
ChromeSyncNotificationBridge* chrome_sync_notification_bridge,
syncer::InvalidatorFactory* invalidator_factory,
syncer::SyncManagerFactory* sync_manager_factory,
bool delete_sync_data_folder,
const std::string& restored_key_for_bootstrapping,
const std::string& restored_keystore_key_for_bootstrapping,
syncer::InternalComponentsFactory* internal_components_factory,
syncer::UnrecoverableErrorHandler* unrecoverable_error_handler,
syncer::ReportUnrecoverableErrorFunction
report_unrecoverable_error_function);
~DoInitializeOptions();
MessageLoop* sync_loop;
SyncBackendRegistrar* registrar;
syncer::ModelSafeRoutingInfo routing_info;
std::vector<syncer::ModelSafeWorker*> workers;
syncer::ExtensionsActivityMonitor* extensions_activity_monitor;
syncer::WeakHandle<syncer::JsEventHandler> event_handler;
GURL service_url;
// Overridden by tests.
MakeHttpBridgeFactoryFn make_http_bridge_factory_fn;
syncer::SyncCredentials credentials;
ChromeSyncNotificationBridge* const chrome_sync_notification_bridge;
syncer::InvalidatorFactory* const invalidator_factory;
syncer::SyncManagerFactory* const sync_manager_factory;
std::string lsid;
bool delete_sync_data_folder;
std::string restored_key_for_bootstrapping;
std::string restored_keystore_key_for_bootstrapping;
syncer::InternalComponentsFactory* internal_components_factory;
syncer::UnrecoverableErrorHandler* unrecoverable_error_handler;
syncer::ReportUnrecoverableErrorFunction
report_unrecoverable_error_function;
};
// Allows tests to perform alternate core initialization work.
virtual void InitCore(const DoInitializeOptions& options);
// Request the syncer to reconfigure with the specfied params.
// Virtual for testing.
virtual void RequestConfigureSyncer(
syncer::ConfigureReason reason,
syncer::ModelTypeSet types_to_config,
const syncer::ModelSafeRoutingInfo& routing_info,
const base::Callback<void(syncer::ModelTypeSet)>& ready_task,
const base::Closure& retry_callback);
// Called when the syncer has finished performing a configuration.
void FinishConfigureDataTypesOnFrontendLoop(
const syncer::ModelTypeSet failed_configuration_types,
const base::Callback<void(syncer::ModelTypeSet)>& ready_task);
// Called when the SyncManager has been constructed and initialized.
virtual void HandleSyncManagerInitializationOnFrontendLoop(
const syncer::WeakHandle<syncer::JsBackend>& js_backend,
bool success,
syncer::ModelTypeSet restored_types);
SyncFrontend* frontend() { return frontend_; }
private:
// The real guts of SyncBackendHost, to keep the public client API clean.
class Core;
// An enum representing the steps to initializing the SyncBackendHost.
enum InitializationState {
NOT_ATTEMPTED,
CREATING_SYNC_MANAGER, // We're waiting for the first callback from the
// sync thread to inform us that the sync manager
// has been created.
NOT_INITIALIZED, // Initialization hasn't completed, but we've
// constructed a SyncManager.
DOWNLOADING_NIGORI, // The SyncManager is initialized, but
// we're fetching sync encryption information.
ASSOCIATING_NIGORI, // The SyncManager is initialized, and we
// have the sync encryption information, but we
// have to update the local encryption state.
INITIALIZED, // Initialization is complete.
};
// Checks if we have received a notice to turn on experimental datatypes
// (via the nigori node) and informs the frontend if that is the case.
// Note: it is illegal to call this before the backend is initialized.
void AddExperimentalTypes();
// Downloading of nigori failed and will be retried.
void OnNigoriDownloadRetry();
// InitializationComplete passes through the SyncBackendHost to forward
// on to |frontend_|, and so that tests can intercept here if they need to
// set up initial conditions.
void HandleInitializationCompletedOnFrontendLoop(
bool success);
// Called from Core::OnSyncCycleCompleted to handle updating frontend
// thread components.
void HandleSyncCycleCompletedOnFrontendLoop(
const syncer::sessions::SyncSessionSnapshot& snapshot);
// Called when the syncer failed to perform a configuration and will
// eventually retry. FinishingConfigurationOnFrontendLoop(..) will be called
// on successful completion.
void RetryConfigurationOnFrontendLoop(const base::Closure& retry_callback);
// Helpers to persist a token that can be used to bootstrap sync encryption
// across browser restart to avoid requiring the user to re-enter their
// passphrase. |token| must be valid UTF-8 as we use the PrefService for
// storage.
void PersistEncryptionBootstrapToken(
const std::string& token,
syncer::BootstrapTokenType token_type);
// For convenience, checks if initialization state is INITIALIZED.
bool initialized() const { return initialization_state_ == INITIALIZED; }
// Let the front end handle the actionable error event.
void HandleActionableErrorEventOnFrontendLoop(
const syncer::SyncProtocolError& sync_error);
// Checks if |passphrase| can be used to decrypt the cryptographer's pending
// keys that were cached during NotifyPassphraseRequired. Returns true if
// decryption was successful. Returns false otherwise. Must be called with a
// non-empty pending keys cache.
bool CheckPassphraseAgainstCachedPendingKeys(
const std::string& passphrase) const;
// Invoked when a passphrase is required to decrypt a set of Nigori keys,
// or for encrypting. |reason| denotes why the passphrase was required.
// |pending_keys| is a copy of the cryptographer's pending keys, that are
// cached by the frontend. If there are no pending keys, or if the passphrase
// required reason is REASON_ENCRYPTION, an empty EncryptedData object is
// passed.
void NotifyPassphraseRequired(syncer::PassphraseRequiredReason reason,
sync_pb::EncryptedData pending_keys);
// Invoked when the passphrase provided by the user has been accepted.
void NotifyPassphraseAccepted();
// Invoked when an updated token is available from the sync server.
void NotifyUpdatedToken(const std::string& token);
// Invoked when the set of encrypted types or the encrypt
// everything flag changes.
void NotifyEncryptedTypesChanged(
syncer::ModelTypeSet encrypted_types,
bool encrypt_everything);
// Invoked when sync finishes encrypting new datatypes.
void NotifyEncryptionComplete();
// Invoked when the passphrase state has changed. Caches the passphrase state
// for later use on the UI thread.
void HandlePassphraseTypeChangedOnFrontendLoop(
syncer::PassphraseType state);
void HandleStopSyncingPermanentlyOnFrontendLoop();
// Dispatched to from OnConnectionStatusChange to handle updating
// frontend UI components.
void HandleConnectionStatusChangeOnFrontendLoop(
syncer::ConnectionStatus status);
// Called when configuration of the Nigori node has completed as
// part of the initialization process.
void HandleNigoriConfigurationCompletedOnFrontendLoop(
syncer::ModelTypeSet failed_configuration_types);
// syncer::InvalidationHandler-like functions.
void HandleInvalidatorStateChangeOnFrontendLoop(
syncer::InvalidatorState state);
void HandleIncomingInvalidationOnFrontendLoop(
const syncer::ObjectIdStateMap& id_state_map,
syncer::IncomingInvalidationSource source);
// Handles stopping the core's SyncManager, accounting for whether
// initialization is done yet.
void StopSyncManagerForShutdown(const base::Closure& closure);
base::WeakPtrFactory<SyncBackendHost> weak_ptr_factory_;
// A thread where all the sync operations happen.
base::Thread sync_thread_;
// A reference to the MessageLoop used to construct |this|, so we know how
// to safely talk back to the SyncFrontend.
MessageLoop* const frontend_loop_;
Profile* const profile_;
// Name used for debugging (set from profile_->GetDebugName()).
const std::string name_;
// Our core, which communicates directly to the syncapi.
scoped_refptr<Core> core_;
InitializationState initialization_state_;
const base::WeakPtr<SyncPrefs> sync_prefs_;
// A bridge that converts Chrome notifications (on the UI thread)
// into invalidations (on the sync thread).
scoped_ptr<ChromeSyncNotificationBridge> chrome_sync_notification_bridge_;
syncer::InvalidatorFactory invalidator_factory_;
ChromeExtensionsActivityMonitor extensions_activity_monitor_;
scoped_ptr<SyncBackendRegistrar> registrar_;
// The frontend which we serve (and are owned by).
SyncFrontend* frontend_;
// We cache the cryptographer's pending keys whenever NotifyPassphraseRequired
// is called. This way, before the UI calls SetDecryptionPassphrase on the
// syncer, it can avoid the overhead of an asynchronous decryption call and
// give the user immediate feedback about the passphrase entered by first
// trying to decrypt the cached pending keys on the UI thread. Note that
// SetDecryptionPassphrase can still fail after the cached pending keys are
// successfully decrypted if the pending keys have changed since the time they
// were cached.
sync_pb::EncryptedData cached_pending_keys_;
// The state of the passphrase required to decrypt the bag of encryption keys
// in the nigori node. Updated whenever a new nigori node arrives or the user
// manually changes their passphrase state. Cached so we can synchronously
// check it from the UI thread.
syncer::PassphraseType cached_passphrase_type_;
// UI-thread cache of the last SyncSessionSnapshot received from syncapi.
syncer::sessions::SyncSessionSnapshot last_snapshot_;
// Temporary holder for the javascript backend. Set by
// HandleSyncManagerInitializationOnFrontendLoop, and consumed when we pass
// it via OnBackendInitialized in the final state of
// HandleInitializationCompletedOnFrontendLoop.
syncer::WeakHandle<syncer::JsBackend> js_backend_;
DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
};
} // namespace browser_sync
#endif // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
| 43.452206 | 80 | 0.758482 | [
"object",
"vector",
"model"
] |
43735b5de972cc5df5f057a8b7c8ae6b797a2d43 | 1,997 | h | C | foas/include/alibabacloud/foas/model/GetInstanceResult.h | iamzken/aliyun-openapi-cpp-sdk | 3c991c9ca949b6003c8f498ce7a672ea88162bf1 | [
"Apache-2.0"
] | 89 | 2018-02-02T03:54:39.000Z | 2021-12-13T01:32:55.000Z | foas/include/alibabacloud/foas/model/GetInstanceResult.h | iamzken/aliyun-openapi-cpp-sdk | 3c991c9ca949b6003c8f498ce7a672ea88162bf1 | [
"Apache-2.0"
] | 89 | 2018-03-14T07:44:54.000Z | 2021-11-26T07:43:25.000Z | foas/include/alibabacloud/foas/model/GetInstanceResult.h | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 69 | 2018-01-22T09:45:52.000Z | 2022-03-28T07:58:38.000Z | /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_FOAS_MODEL_GETINSTANCERESULT_H_
#define ALIBABACLOUD_FOAS_MODEL_GETINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/foas/FoasExport.h>
namespace AlibabaCloud
{
namespace Foas
{
namespace Model
{
class ALIBABACLOUD_FOAS_EXPORT GetInstanceResult : public ServiceResult
{
public:
struct Instance
{
std::string lastErrorMessage;
std::string expectState;
std::string engineVersion;
long endTime;
std::string projectName;
std::string clusterId;
std::string planJson;
std::string jobName;
long startTime;
std::string properties;
std::string starter;
long inputDelay;
std::string code;
std::string actualState;
long lastErrorTime;
std::string engineJobHandler;
std::string jobType;
std::string lastOperator;
std::string packages;
std::string apiType;
long id;
long lastOperateTime;
std::string queueName;
};
GetInstanceResult();
explicit GetInstanceResult(const std::string &payload);
~GetInstanceResult();
Instance getInstance()const;
protected:
void parse(const std::string &payload);
private:
Instance instance_;
};
}
}
}
#endif // !ALIBABACLOUD_FOAS_MODEL_GETINSTANCERESULT_H_ | 25.935065 | 75 | 0.711567 | [
"vector",
"model"
] |
4378c2dc5f1d794f11acce6bffcb1e60496d1f57 | 340,346 | c | C | gsc/_asm.c | eje211/gambit | 417d32cf0d4a007cf0c4fdd56e50857b5bb591cb | [
"Apache-2.0"
] | null | null | null | gsc/_asm.c | eje211/gambit | 417d32cf0d4a007cf0c4fdd56e50857b5bb591cb | [
"Apache-2.0"
] | null | null | null | gsc/_asm.c | eje211/gambit | 417d32cf0d4a007cf0c4fdd56e50857b5bb591cb | [
"Apache-2.0"
] | null | null | null | #ifdef ___LINKER_INFO
; File: "_asm.c", produced by Gambit v4.9.1
(
409001
(C)
"_asm"
(("_asm"))
(
"UTF-8"
"_asm"
"be"
"code-block"
"deferred"
"label"
"listing"
)
(
"char-encoding"
)
(
"_asm#"
"_asm#asm-16-be"
"_asm#asm-16-le"
"_asm#asm-32"
"_asm#asm-32-be"
"_asm#asm-32-le"
"_asm#asm-64"
"_asm#asm-64-be"
"_asm#asm-64-le"
"_asm#asm-8"
"_asm#asm-assemble"
"_asm#asm-bits-16-and-up"
"_asm#asm-bits-32-and-up"
"_asm#asm-bits-8-and-up"
"_asm#asm-code-extend"
"_asm#asm-float->bits"
"_asm#asm-float->exact-exponential-format"
"_asm#asm-float->inexact-exponential-format"
"_asm#asm-inexact-+0"
"_asm#asm-inexact-+1"
"_asm#asm-inexact-+1/2"
"_asm#asm-inexact-+2"
"_asm#asm-init-code-block"
"_asm#asm-int-be"
"_asm#asm-int-le"
"_asm#asm-make-stream"
"_asm#asm-signed-lo16"
"_asm#asm-signed-lo32"
"_asm#asm-signed-lo64"
"_asm#asm-signed-lo8"
)
(
"_asm#asm-16"
"_asm#asm-UTF-8-string"
"_asm#asm-align"
"_asm#asm-assemble-to-file"
"_asm#asm-assemble-to-u8vector"
"_asm#asm-at-assembly"
"_asm#asm-bits-0-to-7"
"_asm#asm-copy-code-block"
"_asm#asm-display-listing"
"_asm#asm-f32"
"_asm#asm-f64"
"_asm#asm-inexact--2"
"_asm#asm-int"
"_asm#asm-label"
"_asm#asm-label-id"
"_asm#asm-label-name"
"_asm#asm-label-pos"
"_asm#asm-label?"
"_asm#asm-listing"
"_asm#asm-make-code-block"
"_asm#asm-make-label"
"_asm#asm-origin"
"_asm#asm-separated-list"
"_asm#asm-signed-lo"
"_asm#asm-signed16?"
"_asm#asm-signed32?"
"_asm#asm-signed8?"
"_asm#asm-unsigned-lo"
"_asm#asm-unsigned-lo16"
"_asm#asm-unsigned-lo32"
"_asm#asm-unsigned-lo64"
"_asm#asm-unsigned-lo8"
)
(
"*"
"+"
"-"
"/"
"<"
"<="
">="
"bitwise-and"
"c#compiler-internal-error"
"cadr"
"car"
"cddr"
"cdr"
"cons"
"current-output-port"
"display"
"eq?"
"error"
"exact->inexact"
"expt"
"fx*"
"fx+"
"fx-"
"fx<"
"fx="
"fx>"
"fx>="
"fxmodulo"
"fxquotient"
"inexact->exact"
"integer->char"
"list"
"make-u8vector"
"make-vector"
"map"
"modulo"
"negative?"
"newline"
"not"
"null?"
"number->string"
"number?"
"pair?"
"quotient"
"reverse"
"set-car!"
"set-cdr!"
"string-append"
"string-ref"
"string?"
"symbol->string"
"symbol?"
"truncate"
"u8vector-length"
"u8vector-ref"
"u8vector-set!"
"vector"
"vector-length"
"vector-ref"
"vector-set!"
"vector?"
"with-output-to-file"
"with-output-to-u8vector"
"write-char"
)
()
)
#else
#define ___VERSION 409001
#define ___MODULE_NAME "_asm"
#define ___LINKER_ID ___LNK___asm
#define ___MH_PROC ___H___asm
#define ___SCRIPT_LINE 0
#define ___SYMCOUNT 7
#define ___KEYCOUNT 1
#define ___GLOCOUNT 126
#define ___SUPCOUNT 62
#define ___CNSCOUNT 2
#define ___SUBCOUNT 22
#define ___LBLCOUNT 717
#define ___OFDCOUNT 5
#define ___MODDESCR ___REF_SUB(21)
#include "gambit.h"
___NEED_SYM(___S_UTF_2d_8)
___NEED_SYM(___S___asm)
___NEED_SYM(___S_be)
___NEED_SYM(___S_code_2d_block)
___NEED_SYM(___S_deferred)
___NEED_SYM(___S_label)
___NEED_SYM(___S_listing)
___NEED_KEY(___K_char_2d_encoding)
___NEED_GLO(___G__2a_)
___NEED_GLO(___G__2b_)
___NEED_GLO(___G__2d_)
___NEED_GLO(___G__2f_)
___NEED_GLO(___G__3c_)
___NEED_GLO(___G__3c__3d_)
___NEED_GLO(___G__3e__3d_)
___NEED_GLO(___G___asm_23_)
___NEED_GLO(___G___asm_23_asm_2d_16)
___NEED_GLO(___G___asm_23_asm_2d_16_2d_be)
___NEED_GLO(___G___asm_23_asm_2d_16_2d_le)
___NEED_GLO(___G___asm_23_asm_2d_32)
___NEED_GLO(___G___asm_23_asm_2d_32_2d_be)
___NEED_GLO(___G___asm_23_asm_2d_32_2d_le)
___NEED_GLO(___G___asm_23_asm_2d_64)
___NEED_GLO(___G___asm_23_asm_2d_64_2d_be)
___NEED_GLO(___G___asm_23_asm_2d_64_2d_le)
___NEED_GLO(___G___asm_23_asm_2d_8)
___NEED_GLO(___G___asm_23_asm_2d_UTF_2d_8_2d_string)
___NEED_GLO(___G___asm_23_asm_2d_align)
___NEED_GLO(___G___asm_23_asm_2d_assemble)
___NEED_GLO(___G___asm_23_asm_2d_assemble_2d_to_2d_file)
___NEED_GLO(___G___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___NEED_GLO(___G___asm_23_asm_2d_at_2d_assembly)
___NEED_GLO(___G___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
___NEED_GLO(___G___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___NEED_GLO(___G___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___NEED_GLO(___G___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___NEED_GLO(___G___asm_23_asm_2d_code_2d_extend)
___NEED_GLO(___G___asm_23_asm_2d_copy_2d_code_2d_block)
___NEED_GLO(___G___asm_23_asm_2d_display_2d_listing)
___NEED_GLO(___G___asm_23_asm_2d_f32)
___NEED_GLO(___G___asm_23_asm_2d_f64)
___NEED_GLO(___G___asm_23_asm_2d_float_2d__3e_bits)
___NEED_GLO(___G___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___NEED_GLO(___G___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___NEED_GLO(___G___asm_23_asm_2d_inexact_2d__2b_0)
___NEED_GLO(___G___asm_23_asm_2d_inexact_2d__2b_1)
___NEED_GLO(___G___asm_23_asm_2d_inexact_2d__2b_1_2f_2)
___NEED_GLO(___G___asm_23_asm_2d_inexact_2d__2b_2)
___NEED_GLO(___G___asm_23_asm_2d_inexact_2d__2d_2)
___NEED_GLO(___G___asm_23_asm_2d_init_2d_code_2d_block)
___NEED_GLO(___G___asm_23_asm_2d_int)
___NEED_GLO(___G___asm_23_asm_2d_int_2d_be)
___NEED_GLO(___G___asm_23_asm_2d_int_2d_le)
___NEED_GLO(___G___asm_23_asm_2d_label)
___NEED_GLO(___G___asm_23_asm_2d_label_2d_id)
___NEED_GLO(___G___asm_23_asm_2d_label_2d_name)
___NEED_GLO(___G___asm_23_asm_2d_label_2d_pos)
___NEED_GLO(___G___asm_23_asm_2d_label_3f_)
___NEED_GLO(___G___asm_23_asm_2d_listing)
___NEED_GLO(___G___asm_23_asm_2d_make_2d_code_2d_block)
___NEED_GLO(___G___asm_23_asm_2d_make_2d_label)
___NEED_GLO(___G___asm_23_asm_2d_make_2d_stream)
___NEED_GLO(___G___asm_23_asm_2d_origin)
___NEED_GLO(___G___asm_23_asm_2d_separated_2d_list)
___NEED_GLO(___G___asm_23_asm_2d_signed_2d_lo)
___NEED_GLO(___G___asm_23_asm_2d_signed_2d_lo16)
___NEED_GLO(___G___asm_23_asm_2d_signed_2d_lo32)
___NEED_GLO(___G___asm_23_asm_2d_signed_2d_lo64)
___NEED_GLO(___G___asm_23_asm_2d_signed_2d_lo8)
___NEED_GLO(___G___asm_23_asm_2d_signed16_3f_)
___NEED_GLO(___G___asm_23_asm_2d_signed32_3f_)
___NEED_GLO(___G___asm_23_asm_2d_signed8_3f_)
___NEED_GLO(___G___asm_23_asm_2d_unsigned_2d_lo)
___NEED_GLO(___G___asm_23_asm_2d_unsigned_2d_lo16)
___NEED_GLO(___G___asm_23_asm_2d_unsigned_2d_lo32)
___NEED_GLO(___G___asm_23_asm_2d_unsigned_2d_lo64)
___NEED_GLO(___G___asm_23_asm_2d_unsigned_2d_lo8)
___NEED_GLO(___G_bitwise_2d_and)
___NEED_GLO(___G_c_23_compiler_2d_internal_2d_error)
___NEED_GLO(___G_cadr)
___NEED_GLO(___G_car)
___NEED_GLO(___G_cddr)
___NEED_GLO(___G_cdr)
___NEED_GLO(___G_cons)
___NEED_GLO(___G_current_2d_output_2d_port)
___NEED_GLO(___G_display)
___NEED_GLO(___G_eq_3f_)
___NEED_GLO(___G_error)
___NEED_GLO(___G_exact_2d__3e_inexact)
___NEED_GLO(___G_expt)
___NEED_GLO(___G_fx_2a_)
___NEED_GLO(___G_fx_2b_)
___NEED_GLO(___G_fx_2d_)
___NEED_GLO(___G_fx_3c_)
___NEED_GLO(___G_fx_3d_)
___NEED_GLO(___G_fx_3e_)
___NEED_GLO(___G_fx_3e__3d_)
___NEED_GLO(___G_fxmodulo)
___NEED_GLO(___G_fxquotient)
___NEED_GLO(___G_inexact_2d__3e_exact)
___NEED_GLO(___G_integer_2d__3e_char)
___NEED_GLO(___G_list)
___NEED_GLO(___G_make_2d_u8vector)
___NEED_GLO(___G_make_2d_vector)
___NEED_GLO(___G_map)
___NEED_GLO(___G_modulo)
___NEED_GLO(___G_negative_3f_)
___NEED_GLO(___G_newline)
___NEED_GLO(___G_not)
___NEED_GLO(___G_null_3f_)
___NEED_GLO(___G_number_2d__3e_string)
___NEED_GLO(___G_number_3f_)
___NEED_GLO(___G_pair_3f_)
___NEED_GLO(___G_quotient)
___NEED_GLO(___G_reverse)
___NEED_GLO(___G_set_2d_car_21_)
___NEED_GLO(___G_set_2d_cdr_21_)
___NEED_GLO(___G_string_2d_append)
___NEED_GLO(___G_string_2d_ref)
___NEED_GLO(___G_string_3f_)
___NEED_GLO(___G_symbol_2d__3e_string)
___NEED_GLO(___G_symbol_3f_)
___NEED_GLO(___G_truncate)
___NEED_GLO(___G_u8vector_2d_length)
___NEED_GLO(___G_u8vector_2d_ref)
___NEED_GLO(___G_u8vector_2d_set_21_)
___NEED_GLO(___G_vector)
___NEED_GLO(___G_vector_2d_length)
___NEED_GLO(___G_vector_2d_ref)
___NEED_GLO(___G_vector_2d_set_21_)
___NEED_GLO(___G_vector_3f_)
___NEED_GLO(___G_with_2d_output_2d_to_2d_file)
___NEED_GLO(___G_with_2d_output_2d_to_2d_u8vector)
___NEED_GLO(___G_write_2d_char)
___BEGIN_SYM
___DEF_SYM(0,___S_UTF_2d_8,"UTF-8")
___DEF_SYM(1,___S___asm,"_asm")
___DEF_SYM(2,___S_be,"be")
___DEF_SYM(3,___S_code_2d_block,"code-block")
___DEF_SYM(4,___S_deferred,"deferred")
___DEF_SYM(5,___S_label,"label")
___DEF_SYM(6,___S_listing,"listing")
___END_SYM
#define ___SYM_UTF_2d_8 ___SYM(0,___S_UTF_2d_8)
#define ___SYM___asm ___SYM(1,___S___asm)
#define ___SYM_be ___SYM(2,___S_be)
#define ___SYM_code_2d_block ___SYM(3,___S_code_2d_block)
#define ___SYM_deferred ___SYM(4,___S_deferred)
#define ___SYM_label ___SYM(5,___S_label)
#define ___SYM_listing ___SYM(6,___S_listing)
___BEGIN_KEY
___DEF_KEY(0,___K_char_2d_encoding,"char-encoding")
___END_KEY
#define ___KEY_char_2d_encoding ___KEY(0,___K_char_2d_encoding)
___BEGIN_GLO
___DEF_GLO(0,"_asm#")
___DEF_GLO(1,"_asm#asm-16")
___DEF_GLO(2,"_asm#asm-16-be")
___DEF_GLO(3,"_asm#asm-16-le")
___DEF_GLO(4,"_asm#asm-32")
___DEF_GLO(5,"_asm#asm-32-be")
___DEF_GLO(6,"_asm#asm-32-le")
___DEF_GLO(7,"_asm#asm-64")
___DEF_GLO(8,"_asm#asm-64-be")
___DEF_GLO(9,"_asm#asm-64-le")
___DEF_GLO(10,"_asm#asm-8")
___DEF_GLO(11,"_asm#asm-UTF-8-string")
___DEF_GLO(12,"_asm#asm-align")
___DEF_GLO(13,"_asm#asm-assemble")
___DEF_GLO(14,"_asm#asm-assemble-to-file")
___DEF_GLO(15,"_asm#asm-assemble-to-u8vector")
___DEF_GLO(16,"_asm#asm-at-assembly")
___DEF_GLO(17,"_asm#asm-bits-0-to-7")
___DEF_GLO(18,"_asm#asm-bits-16-and-up")
___DEF_GLO(19,"_asm#asm-bits-32-and-up")
___DEF_GLO(20,"_asm#asm-bits-8-and-up")
___DEF_GLO(21,"_asm#asm-code-extend")
___DEF_GLO(22,"_asm#asm-copy-code-block")
___DEF_GLO(23,"_asm#asm-display-listing")
___DEF_GLO(24,"_asm#asm-f32")
___DEF_GLO(25,"_asm#asm-f64")
___DEF_GLO(26,"_asm#asm-float->bits")
___DEF_GLO(27,"_asm#asm-float->exact-exponential-format")
___DEF_GLO(28,"_asm#asm-float->inexact-exponential-format")
___DEF_GLO(29,"_asm#asm-inexact-+0")
___DEF_GLO(30,"_asm#asm-inexact-+1")
___DEF_GLO(31,"_asm#asm-inexact-+1/2")
___DEF_GLO(32,"_asm#asm-inexact-+2")
___DEF_GLO(33,"_asm#asm-inexact--2")
___DEF_GLO(34,"_asm#asm-init-code-block")
___DEF_GLO(35,"_asm#asm-int")
___DEF_GLO(36,"_asm#asm-int-be")
___DEF_GLO(37,"_asm#asm-int-le")
___DEF_GLO(38,"_asm#asm-label")
___DEF_GLO(39,"_asm#asm-label-id")
___DEF_GLO(40,"_asm#asm-label-name")
___DEF_GLO(41,"_asm#asm-label-pos")
___DEF_GLO(42,"_asm#asm-label?")
___DEF_GLO(43,"_asm#asm-listing")
___DEF_GLO(44,"_asm#asm-make-code-block")
___DEF_GLO(45,"_asm#asm-make-label")
___DEF_GLO(46,"_asm#asm-make-stream")
___DEF_GLO(47,"_asm#asm-origin")
___DEF_GLO(48,"_asm#asm-separated-list")
___DEF_GLO(49,"_asm#asm-signed-lo")
___DEF_GLO(50,"_asm#asm-signed-lo16")
___DEF_GLO(51,"_asm#asm-signed-lo32")
___DEF_GLO(52,"_asm#asm-signed-lo64")
___DEF_GLO(53,"_asm#asm-signed-lo8")
___DEF_GLO(54,"_asm#asm-signed16?")
___DEF_GLO(55,"_asm#asm-signed32?")
___DEF_GLO(56,"_asm#asm-signed8?")
___DEF_GLO(57,"_asm#asm-unsigned-lo")
___DEF_GLO(58,"_asm#asm-unsigned-lo16")
___DEF_GLO(59,"_asm#asm-unsigned-lo32")
___DEF_GLO(60,"_asm#asm-unsigned-lo64")
___DEF_GLO(61,"_asm#asm-unsigned-lo8")
___DEF_GLO(62,"*")
___DEF_GLO(63,"+")
___DEF_GLO(64,"-")
___DEF_GLO(65,"/")
___DEF_GLO(66,"<")
___DEF_GLO(67,"<=")
___DEF_GLO(68,">=")
___DEF_GLO(69,"bitwise-and")
___DEF_GLO(70,"c#compiler-internal-error")
___DEF_GLO(71,"cadr")
___DEF_GLO(72,"car")
___DEF_GLO(73,"cddr")
___DEF_GLO(74,"cdr")
___DEF_GLO(75,"cons")
___DEF_GLO(76,"current-output-port")
___DEF_GLO(77,"display")
___DEF_GLO(78,"eq?")
___DEF_GLO(79,"error")
___DEF_GLO(80,"exact->inexact")
___DEF_GLO(81,"expt")
___DEF_GLO(82,"fx*")
___DEF_GLO(83,"fx+")
___DEF_GLO(84,"fx-")
___DEF_GLO(85,"fx<")
___DEF_GLO(86,"fx=")
___DEF_GLO(87,"fx>")
___DEF_GLO(88,"fx>=")
___DEF_GLO(89,"fxmodulo")
___DEF_GLO(90,"fxquotient")
___DEF_GLO(91,"inexact->exact")
___DEF_GLO(92,"integer->char")
___DEF_GLO(93,"list")
___DEF_GLO(94,"make-u8vector")
___DEF_GLO(95,"make-vector")
___DEF_GLO(96,"map")
___DEF_GLO(97,"modulo")
___DEF_GLO(98,"negative?")
___DEF_GLO(99,"newline")
___DEF_GLO(100,"not")
___DEF_GLO(101,"null?")
___DEF_GLO(102,"number->string")
___DEF_GLO(103,"number?")
___DEF_GLO(104,"pair?")
___DEF_GLO(105,"quotient")
___DEF_GLO(106,"reverse")
___DEF_GLO(107,"set-car!")
___DEF_GLO(108,"set-cdr!")
___DEF_GLO(109,"string-append")
___DEF_GLO(110,"string-ref")
___DEF_GLO(111,"string?")
___DEF_GLO(112,"symbol->string")
___DEF_GLO(113,"symbol?")
___DEF_GLO(114,"truncate")
___DEF_GLO(115,"u8vector-length")
___DEF_GLO(116,"u8vector-ref")
___DEF_GLO(117,"u8vector-set!")
___DEF_GLO(118,"vector")
___DEF_GLO(119,"vector-length")
___DEF_GLO(120,"vector-ref")
___DEF_GLO(121,"vector-set!")
___DEF_GLO(122,"vector?")
___DEF_GLO(123,"with-output-to-file")
___DEF_GLO(124,"with-output-to-u8vector")
___DEF_GLO(125,"write-char")
___END_GLO
#define ___GLO___asm_23_ ___GLO(0,___G___asm_23_)
#define ___PRM___asm_23_ ___PRM(0,___G___asm_23_)
#define ___GLO___asm_23_asm_2d_16 ___GLO(1,___G___asm_23_asm_2d_16)
#define ___PRM___asm_23_asm_2d_16 ___PRM(1,___G___asm_23_asm_2d_16)
#define ___GLO___asm_23_asm_2d_16_2d_be ___GLO(2,___G___asm_23_asm_2d_16_2d_be)
#define ___PRM___asm_23_asm_2d_16_2d_be ___PRM(2,___G___asm_23_asm_2d_16_2d_be)
#define ___GLO___asm_23_asm_2d_16_2d_le ___GLO(3,___G___asm_23_asm_2d_16_2d_le)
#define ___PRM___asm_23_asm_2d_16_2d_le ___PRM(3,___G___asm_23_asm_2d_16_2d_le)
#define ___GLO___asm_23_asm_2d_32 ___GLO(4,___G___asm_23_asm_2d_32)
#define ___PRM___asm_23_asm_2d_32 ___PRM(4,___G___asm_23_asm_2d_32)
#define ___GLO___asm_23_asm_2d_32_2d_be ___GLO(5,___G___asm_23_asm_2d_32_2d_be)
#define ___PRM___asm_23_asm_2d_32_2d_be ___PRM(5,___G___asm_23_asm_2d_32_2d_be)
#define ___GLO___asm_23_asm_2d_32_2d_le ___GLO(6,___G___asm_23_asm_2d_32_2d_le)
#define ___PRM___asm_23_asm_2d_32_2d_le ___PRM(6,___G___asm_23_asm_2d_32_2d_le)
#define ___GLO___asm_23_asm_2d_64 ___GLO(7,___G___asm_23_asm_2d_64)
#define ___PRM___asm_23_asm_2d_64 ___PRM(7,___G___asm_23_asm_2d_64)
#define ___GLO___asm_23_asm_2d_64_2d_be ___GLO(8,___G___asm_23_asm_2d_64_2d_be)
#define ___PRM___asm_23_asm_2d_64_2d_be ___PRM(8,___G___asm_23_asm_2d_64_2d_be)
#define ___GLO___asm_23_asm_2d_64_2d_le ___GLO(9,___G___asm_23_asm_2d_64_2d_le)
#define ___PRM___asm_23_asm_2d_64_2d_le ___PRM(9,___G___asm_23_asm_2d_64_2d_le)
#define ___GLO___asm_23_asm_2d_8 ___GLO(10,___G___asm_23_asm_2d_8)
#define ___PRM___asm_23_asm_2d_8 ___PRM(10,___G___asm_23_asm_2d_8)
#define ___GLO___asm_23_asm_2d_UTF_2d_8_2d_string ___GLO(11,___G___asm_23_asm_2d_UTF_2d_8_2d_string)
#define ___PRM___asm_23_asm_2d_UTF_2d_8_2d_string ___PRM(11,___G___asm_23_asm_2d_UTF_2d_8_2d_string)
#define ___GLO___asm_23_asm_2d_align ___GLO(12,___G___asm_23_asm_2d_align)
#define ___PRM___asm_23_asm_2d_align ___PRM(12,___G___asm_23_asm_2d_align)
#define ___GLO___asm_23_asm_2d_assemble ___GLO(13,___G___asm_23_asm_2d_assemble)
#define ___PRM___asm_23_asm_2d_assemble ___PRM(13,___G___asm_23_asm_2d_assemble)
#define ___GLO___asm_23_asm_2d_assemble_2d_to_2d_file ___GLO(14,___G___asm_23_asm_2d_assemble_2d_to_2d_file)
#define ___PRM___asm_23_asm_2d_assemble_2d_to_2d_file ___PRM(14,___G___asm_23_asm_2d_assemble_2d_to_2d_file)
#define ___GLO___asm_23_asm_2d_assemble_2d_to_2d_u8vector ___GLO(15,___G___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
#define ___PRM___asm_23_asm_2d_assemble_2d_to_2d_u8vector ___PRM(15,___G___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
#define ___GLO___asm_23_asm_2d_at_2d_assembly ___GLO(16,___G___asm_23_asm_2d_at_2d_assembly)
#define ___PRM___asm_23_asm_2d_at_2d_assembly ___PRM(16,___G___asm_23_asm_2d_at_2d_assembly)
#define ___GLO___asm_23_asm_2d_bits_2d_0_2d_to_2d_7 ___GLO(17,___G___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
#define ___PRM___asm_23_asm_2d_bits_2d_0_2d_to_2d_7 ___PRM(17,___G___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
#define ___GLO___asm_23_asm_2d_bits_2d_16_2d_and_2d_up ___GLO(18,___G___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
#define ___PRM___asm_23_asm_2d_bits_2d_16_2d_and_2d_up ___PRM(18,___G___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
#define ___GLO___asm_23_asm_2d_bits_2d_32_2d_and_2d_up ___GLO(19,___G___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
#define ___PRM___asm_23_asm_2d_bits_2d_32_2d_and_2d_up ___PRM(19,___G___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
#define ___GLO___asm_23_asm_2d_bits_2d_8_2d_and_2d_up ___GLO(20,___G___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
#define ___PRM___asm_23_asm_2d_bits_2d_8_2d_and_2d_up ___PRM(20,___G___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
#define ___GLO___asm_23_asm_2d_code_2d_extend ___GLO(21,___G___asm_23_asm_2d_code_2d_extend)
#define ___PRM___asm_23_asm_2d_code_2d_extend ___PRM(21,___G___asm_23_asm_2d_code_2d_extend)
#define ___GLO___asm_23_asm_2d_copy_2d_code_2d_block ___GLO(22,___G___asm_23_asm_2d_copy_2d_code_2d_block)
#define ___PRM___asm_23_asm_2d_copy_2d_code_2d_block ___PRM(22,___G___asm_23_asm_2d_copy_2d_code_2d_block)
#define ___GLO___asm_23_asm_2d_display_2d_listing ___GLO(23,___G___asm_23_asm_2d_display_2d_listing)
#define ___PRM___asm_23_asm_2d_display_2d_listing ___PRM(23,___G___asm_23_asm_2d_display_2d_listing)
#define ___GLO___asm_23_asm_2d_f32 ___GLO(24,___G___asm_23_asm_2d_f32)
#define ___PRM___asm_23_asm_2d_f32 ___PRM(24,___G___asm_23_asm_2d_f32)
#define ___GLO___asm_23_asm_2d_f64 ___GLO(25,___G___asm_23_asm_2d_f64)
#define ___PRM___asm_23_asm_2d_f64 ___PRM(25,___G___asm_23_asm_2d_f64)
#define ___GLO___asm_23_asm_2d_float_2d__3e_bits ___GLO(26,___G___asm_23_asm_2d_float_2d__3e_bits)
#define ___PRM___asm_23_asm_2d_float_2d__3e_bits ___PRM(26,___G___asm_23_asm_2d_float_2d__3e_bits)
#define ___GLO___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format ___GLO(27,___G___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
#define ___PRM___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format ___PRM(27,___G___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
#define ___GLO___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format ___GLO(28,___G___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
#define ___PRM___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format ___PRM(28,___G___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
#define ___GLO___asm_23_asm_2d_inexact_2d__2b_0 ___GLO(29,___G___asm_23_asm_2d_inexact_2d__2b_0)
#define ___PRM___asm_23_asm_2d_inexact_2d__2b_0 ___PRM(29,___G___asm_23_asm_2d_inexact_2d__2b_0)
#define ___GLO___asm_23_asm_2d_inexact_2d__2b_1 ___GLO(30,___G___asm_23_asm_2d_inexact_2d__2b_1)
#define ___PRM___asm_23_asm_2d_inexact_2d__2b_1 ___PRM(30,___G___asm_23_asm_2d_inexact_2d__2b_1)
#define ___GLO___asm_23_asm_2d_inexact_2d__2b_1_2f_2 ___GLO(31,___G___asm_23_asm_2d_inexact_2d__2b_1_2f_2)
#define ___PRM___asm_23_asm_2d_inexact_2d__2b_1_2f_2 ___PRM(31,___G___asm_23_asm_2d_inexact_2d__2b_1_2f_2)
#define ___GLO___asm_23_asm_2d_inexact_2d__2b_2 ___GLO(32,___G___asm_23_asm_2d_inexact_2d__2b_2)
#define ___PRM___asm_23_asm_2d_inexact_2d__2b_2 ___PRM(32,___G___asm_23_asm_2d_inexact_2d__2b_2)
#define ___GLO___asm_23_asm_2d_inexact_2d__2d_2 ___GLO(33,___G___asm_23_asm_2d_inexact_2d__2d_2)
#define ___PRM___asm_23_asm_2d_inexact_2d__2d_2 ___PRM(33,___G___asm_23_asm_2d_inexact_2d__2d_2)
#define ___GLO___asm_23_asm_2d_init_2d_code_2d_block ___GLO(34,___G___asm_23_asm_2d_init_2d_code_2d_block)
#define ___PRM___asm_23_asm_2d_init_2d_code_2d_block ___PRM(34,___G___asm_23_asm_2d_init_2d_code_2d_block)
#define ___GLO___asm_23_asm_2d_int ___GLO(35,___G___asm_23_asm_2d_int)
#define ___PRM___asm_23_asm_2d_int ___PRM(35,___G___asm_23_asm_2d_int)
#define ___GLO___asm_23_asm_2d_int_2d_be ___GLO(36,___G___asm_23_asm_2d_int_2d_be)
#define ___PRM___asm_23_asm_2d_int_2d_be ___PRM(36,___G___asm_23_asm_2d_int_2d_be)
#define ___GLO___asm_23_asm_2d_int_2d_le ___GLO(37,___G___asm_23_asm_2d_int_2d_le)
#define ___PRM___asm_23_asm_2d_int_2d_le ___PRM(37,___G___asm_23_asm_2d_int_2d_le)
#define ___GLO___asm_23_asm_2d_label ___GLO(38,___G___asm_23_asm_2d_label)
#define ___PRM___asm_23_asm_2d_label ___PRM(38,___G___asm_23_asm_2d_label)
#define ___GLO___asm_23_asm_2d_label_2d_id ___GLO(39,___G___asm_23_asm_2d_label_2d_id)
#define ___PRM___asm_23_asm_2d_label_2d_id ___PRM(39,___G___asm_23_asm_2d_label_2d_id)
#define ___GLO___asm_23_asm_2d_label_2d_name ___GLO(40,___G___asm_23_asm_2d_label_2d_name)
#define ___PRM___asm_23_asm_2d_label_2d_name ___PRM(40,___G___asm_23_asm_2d_label_2d_name)
#define ___GLO___asm_23_asm_2d_label_2d_pos ___GLO(41,___G___asm_23_asm_2d_label_2d_pos)
#define ___PRM___asm_23_asm_2d_label_2d_pos ___PRM(41,___G___asm_23_asm_2d_label_2d_pos)
#define ___GLO___asm_23_asm_2d_label_3f_ ___GLO(42,___G___asm_23_asm_2d_label_3f_)
#define ___PRM___asm_23_asm_2d_label_3f_ ___PRM(42,___G___asm_23_asm_2d_label_3f_)
#define ___GLO___asm_23_asm_2d_listing ___GLO(43,___G___asm_23_asm_2d_listing)
#define ___PRM___asm_23_asm_2d_listing ___PRM(43,___G___asm_23_asm_2d_listing)
#define ___GLO___asm_23_asm_2d_make_2d_code_2d_block ___GLO(44,___G___asm_23_asm_2d_make_2d_code_2d_block)
#define ___PRM___asm_23_asm_2d_make_2d_code_2d_block ___PRM(44,___G___asm_23_asm_2d_make_2d_code_2d_block)
#define ___GLO___asm_23_asm_2d_make_2d_label ___GLO(45,___G___asm_23_asm_2d_make_2d_label)
#define ___PRM___asm_23_asm_2d_make_2d_label ___PRM(45,___G___asm_23_asm_2d_make_2d_label)
#define ___GLO___asm_23_asm_2d_make_2d_stream ___GLO(46,___G___asm_23_asm_2d_make_2d_stream)
#define ___PRM___asm_23_asm_2d_make_2d_stream ___PRM(46,___G___asm_23_asm_2d_make_2d_stream)
#define ___GLO___asm_23_asm_2d_origin ___GLO(47,___G___asm_23_asm_2d_origin)
#define ___PRM___asm_23_asm_2d_origin ___PRM(47,___G___asm_23_asm_2d_origin)
#define ___GLO___asm_23_asm_2d_separated_2d_list ___GLO(48,___G___asm_23_asm_2d_separated_2d_list)
#define ___PRM___asm_23_asm_2d_separated_2d_list ___PRM(48,___G___asm_23_asm_2d_separated_2d_list)
#define ___GLO___asm_23_asm_2d_signed_2d_lo ___GLO(49,___G___asm_23_asm_2d_signed_2d_lo)
#define ___PRM___asm_23_asm_2d_signed_2d_lo ___PRM(49,___G___asm_23_asm_2d_signed_2d_lo)
#define ___GLO___asm_23_asm_2d_signed_2d_lo16 ___GLO(50,___G___asm_23_asm_2d_signed_2d_lo16)
#define ___PRM___asm_23_asm_2d_signed_2d_lo16 ___PRM(50,___G___asm_23_asm_2d_signed_2d_lo16)
#define ___GLO___asm_23_asm_2d_signed_2d_lo32 ___GLO(51,___G___asm_23_asm_2d_signed_2d_lo32)
#define ___PRM___asm_23_asm_2d_signed_2d_lo32 ___PRM(51,___G___asm_23_asm_2d_signed_2d_lo32)
#define ___GLO___asm_23_asm_2d_signed_2d_lo64 ___GLO(52,___G___asm_23_asm_2d_signed_2d_lo64)
#define ___PRM___asm_23_asm_2d_signed_2d_lo64 ___PRM(52,___G___asm_23_asm_2d_signed_2d_lo64)
#define ___GLO___asm_23_asm_2d_signed_2d_lo8 ___GLO(53,___G___asm_23_asm_2d_signed_2d_lo8)
#define ___PRM___asm_23_asm_2d_signed_2d_lo8 ___PRM(53,___G___asm_23_asm_2d_signed_2d_lo8)
#define ___GLO___asm_23_asm_2d_signed16_3f_ ___GLO(54,___G___asm_23_asm_2d_signed16_3f_)
#define ___PRM___asm_23_asm_2d_signed16_3f_ ___PRM(54,___G___asm_23_asm_2d_signed16_3f_)
#define ___GLO___asm_23_asm_2d_signed32_3f_ ___GLO(55,___G___asm_23_asm_2d_signed32_3f_)
#define ___PRM___asm_23_asm_2d_signed32_3f_ ___PRM(55,___G___asm_23_asm_2d_signed32_3f_)
#define ___GLO___asm_23_asm_2d_signed8_3f_ ___GLO(56,___G___asm_23_asm_2d_signed8_3f_)
#define ___PRM___asm_23_asm_2d_signed8_3f_ ___PRM(56,___G___asm_23_asm_2d_signed8_3f_)
#define ___GLO___asm_23_asm_2d_unsigned_2d_lo ___GLO(57,___G___asm_23_asm_2d_unsigned_2d_lo)
#define ___PRM___asm_23_asm_2d_unsigned_2d_lo ___PRM(57,___G___asm_23_asm_2d_unsigned_2d_lo)
#define ___GLO___asm_23_asm_2d_unsigned_2d_lo16 ___GLO(58,___G___asm_23_asm_2d_unsigned_2d_lo16)
#define ___PRM___asm_23_asm_2d_unsigned_2d_lo16 ___PRM(58,___G___asm_23_asm_2d_unsigned_2d_lo16)
#define ___GLO___asm_23_asm_2d_unsigned_2d_lo32 ___GLO(59,___G___asm_23_asm_2d_unsigned_2d_lo32)
#define ___PRM___asm_23_asm_2d_unsigned_2d_lo32 ___PRM(59,___G___asm_23_asm_2d_unsigned_2d_lo32)
#define ___GLO___asm_23_asm_2d_unsigned_2d_lo64 ___GLO(60,___G___asm_23_asm_2d_unsigned_2d_lo64)
#define ___PRM___asm_23_asm_2d_unsigned_2d_lo64 ___PRM(60,___G___asm_23_asm_2d_unsigned_2d_lo64)
#define ___GLO___asm_23_asm_2d_unsigned_2d_lo8 ___GLO(61,___G___asm_23_asm_2d_unsigned_2d_lo8)
#define ___PRM___asm_23_asm_2d_unsigned_2d_lo8 ___PRM(61,___G___asm_23_asm_2d_unsigned_2d_lo8)
#define ___GLO__2a_ ___GLO(62,___G__2a_)
#define ___PRM__2a_ ___PRM(62,___G__2a_)
#define ___GLO__2b_ ___GLO(63,___G__2b_)
#define ___PRM__2b_ ___PRM(63,___G__2b_)
#define ___GLO__2d_ ___GLO(64,___G__2d_)
#define ___PRM__2d_ ___PRM(64,___G__2d_)
#define ___GLO__2f_ ___GLO(65,___G__2f_)
#define ___PRM__2f_ ___PRM(65,___G__2f_)
#define ___GLO__3c_ ___GLO(66,___G__3c_)
#define ___PRM__3c_ ___PRM(66,___G__3c_)
#define ___GLO__3c__3d_ ___GLO(67,___G__3c__3d_)
#define ___PRM__3c__3d_ ___PRM(67,___G__3c__3d_)
#define ___GLO__3e__3d_ ___GLO(68,___G__3e__3d_)
#define ___PRM__3e__3d_ ___PRM(68,___G__3e__3d_)
#define ___GLO_bitwise_2d_and ___GLO(69,___G_bitwise_2d_and)
#define ___PRM_bitwise_2d_and ___PRM(69,___G_bitwise_2d_and)
#define ___GLO_c_23_compiler_2d_internal_2d_error ___GLO(70,___G_c_23_compiler_2d_internal_2d_error)
#define ___PRM_c_23_compiler_2d_internal_2d_error ___PRM(70,___G_c_23_compiler_2d_internal_2d_error)
#define ___GLO_cadr ___GLO(71,___G_cadr)
#define ___PRM_cadr ___PRM(71,___G_cadr)
#define ___GLO_car ___GLO(72,___G_car)
#define ___PRM_car ___PRM(72,___G_car)
#define ___GLO_cddr ___GLO(73,___G_cddr)
#define ___PRM_cddr ___PRM(73,___G_cddr)
#define ___GLO_cdr ___GLO(74,___G_cdr)
#define ___PRM_cdr ___PRM(74,___G_cdr)
#define ___GLO_cons ___GLO(75,___G_cons)
#define ___PRM_cons ___PRM(75,___G_cons)
#define ___GLO_current_2d_output_2d_port ___GLO(76,___G_current_2d_output_2d_port)
#define ___PRM_current_2d_output_2d_port ___PRM(76,___G_current_2d_output_2d_port)
#define ___GLO_display ___GLO(77,___G_display)
#define ___PRM_display ___PRM(77,___G_display)
#define ___GLO_eq_3f_ ___GLO(78,___G_eq_3f_)
#define ___PRM_eq_3f_ ___PRM(78,___G_eq_3f_)
#define ___GLO_error ___GLO(79,___G_error)
#define ___PRM_error ___PRM(79,___G_error)
#define ___GLO_exact_2d__3e_inexact ___GLO(80,___G_exact_2d__3e_inexact)
#define ___PRM_exact_2d__3e_inexact ___PRM(80,___G_exact_2d__3e_inexact)
#define ___GLO_expt ___GLO(81,___G_expt)
#define ___PRM_expt ___PRM(81,___G_expt)
#define ___GLO_fx_2a_ ___GLO(82,___G_fx_2a_)
#define ___PRM_fx_2a_ ___PRM(82,___G_fx_2a_)
#define ___GLO_fx_2b_ ___GLO(83,___G_fx_2b_)
#define ___PRM_fx_2b_ ___PRM(83,___G_fx_2b_)
#define ___GLO_fx_2d_ ___GLO(84,___G_fx_2d_)
#define ___PRM_fx_2d_ ___PRM(84,___G_fx_2d_)
#define ___GLO_fx_3c_ ___GLO(85,___G_fx_3c_)
#define ___PRM_fx_3c_ ___PRM(85,___G_fx_3c_)
#define ___GLO_fx_3d_ ___GLO(86,___G_fx_3d_)
#define ___PRM_fx_3d_ ___PRM(86,___G_fx_3d_)
#define ___GLO_fx_3e_ ___GLO(87,___G_fx_3e_)
#define ___PRM_fx_3e_ ___PRM(87,___G_fx_3e_)
#define ___GLO_fx_3e__3d_ ___GLO(88,___G_fx_3e__3d_)
#define ___PRM_fx_3e__3d_ ___PRM(88,___G_fx_3e__3d_)
#define ___GLO_fxmodulo ___GLO(89,___G_fxmodulo)
#define ___PRM_fxmodulo ___PRM(89,___G_fxmodulo)
#define ___GLO_fxquotient ___GLO(90,___G_fxquotient)
#define ___PRM_fxquotient ___PRM(90,___G_fxquotient)
#define ___GLO_inexact_2d__3e_exact ___GLO(91,___G_inexact_2d__3e_exact)
#define ___PRM_inexact_2d__3e_exact ___PRM(91,___G_inexact_2d__3e_exact)
#define ___GLO_integer_2d__3e_char ___GLO(92,___G_integer_2d__3e_char)
#define ___PRM_integer_2d__3e_char ___PRM(92,___G_integer_2d__3e_char)
#define ___GLO_list ___GLO(93,___G_list)
#define ___PRM_list ___PRM(93,___G_list)
#define ___GLO_make_2d_u8vector ___GLO(94,___G_make_2d_u8vector)
#define ___PRM_make_2d_u8vector ___PRM(94,___G_make_2d_u8vector)
#define ___GLO_make_2d_vector ___GLO(95,___G_make_2d_vector)
#define ___PRM_make_2d_vector ___PRM(95,___G_make_2d_vector)
#define ___GLO_map ___GLO(96,___G_map)
#define ___PRM_map ___PRM(96,___G_map)
#define ___GLO_modulo ___GLO(97,___G_modulo)
#define ___PRM_modulo ___PRM(97,___G_modulo)
#define ___GLO_negative_3f_ ___GLO(98,___G_negative_3f_)
#define ___PRM_negative_3f_ ___PRM(98,___G_negative_3f_)
#define ___GLO_newline ___GLO(99,___G_newline)
#define ___PRM_newline ___PRM(99,___G_newline)
#define ___GLO_not ___GLO(100,___G_not)
#define ___PRM_not ___PRM(100,___G_not)
#define ___GLO_null_3f_ ___GLO(101,___G_null_3f_)
#define ___PRM_null_3f_ ___PRM(101,___G_null_3f_)
#define ___GLO_number_2d__3e_string ___GLO(102,___G_number_2d__3e_string)
#define ___PRM_number_2d__3e_string ___PRM(102,___G_number_2d__3e_string)
#define ___GLO_number_3f_ ___GLO(103,___G_number_3f_)
#define ___PRM_number_3f_ ___PRM(103,___G_number_3f_)
#define ___GLO_pair_3f_ ___GLO(104,___G_pair_3f_)
#define ___PRM_pair_3f_ ___PRM(104,___G_pair_3f_)
#define ___GLO_quotient ___GLO(105,___G_quotient)
#define ___PRM_quotient ___PRM(105,___G_quotient)
#define ___GLO_reverse ___GLO(106,___G_reverse)
#define ___PRM_reverse ___PRM(106,___G_reverse)
#define ___GLO_set_2d_car_21_ ___GLO(107,___G_set_2d_car_21_)
#define ___PRM_set_2d_car_21_ ___PRM(107,___G_set_2d_car_21_)
#define ___GLO_set_2d_cdr_21_ ___GLO(108,___G_set_2d_cdr_21_)
#define ___PRM_set_2d_cdr_21_ ___PRM(108,___G_set_2d_cdr_21_)
#define ___GLO_string_2d_append ___GLO(109,___G_string_2d_append)
#define ___PRM_string_2d_append ___PRM(109,___G_string_2d_append)
#define ___GLO_string_2d_ref ___GLO(110,___G_string_2d_ref)
#define ___PRM_string_2d_ref ___PRM(110,___G_string_2d_ref)
#define ___GLO_string_3f_ ___GLO(111,___G_string_3f_)
#define ___PRM_string_3f_ ___PRM(111,___G_string_3f_)
#define ___GLO_symbol_2d__3e_string ___GLO(112,___G_symbol_2d__3e_string)
#define ___PRM_symbol_2d__3e_string ___PRM(112,___G_symbol_2d__3e_string)
#define ___GLO_symbol_3f_ ___GLO(113,___G_symbol_3f_)
#define ___PRM_symbol_3f_ ___PRM(113,___G_symbol_3f_)
#define ___GLO_truncate ___GLO(114,___G_truncate)
#define ___PRM_truncate ___PRM(114,___G_truncate)
#define ___GLO_u8vector_2d_length ___GLO(115,___G_u8vector_2d_length)
#define ___PRM_u8vector_2d_length ___PRM(115,___G_u8vector_2d_length)
#define ___GLO_u8vector_2d_ref ___GLO(116,___G_u8vector_2d_ref)
#define ___PRM_u8vector_2d_ref ___PRM(116,___G_u8vector_2d_ref)
#define ___GLO_u8vector_2d_set_21_ ___GLO(117,___G_u8vector_2d_set_21_)
#define ___PRM_u8vector_2d_set_21_ ___PRM(117,___G_u8vector_2d_set_21_)
#define ___GLO_vector ___GLO(118,___G_vector)
#define ___PRM_vector ___PRM(118,___G_vector)
#define ___GLO_vector_2d_length ___GLO(119,___G_vector_2d_length)
#define ___PRM_vector_2d_length ___PRM(119,___G_vector_2d_length)
#define ___GLO_vector_2d_ref ___GLO(120,___G_vector_2d_ref)
#define ___PRM_vector_2d_ref ___PRM(120,___G_vector_2d_ref)
#define ___GLO_vector_2d_set_21_ ___GLO(121,___G_vector_2d_set_21_)
#define ___PRM_vector_2d_set_21_ ___PRM(121,___G_vector_2d_set_21_)
#define ___GLO_vector_3f_ ___GLO(122,___G_vector_3f_)
#define ___PRM_vector_3f_ ___PRM(122,___G_vector_3f_)
#define ___GLO_with_2d_output_2d_to_2d_file ___GLO(123,___G_with_2d_output_2d_to_2d_file)
#define ___PRM_with_2d_output_2d_to_2d_file ___PRM(123,___G_with_2d_output_2d_to_2d_file)
#define ___GLO_with_2d_output_2d_to_2d_u8vector ___GLO(124,___G_with_2d_output_2d_to_2d_u8vector)
#define ___PRM_with_2d_output_2d_to_2d_u8vector ___PRM(124,___G_with_2d_output_2d_to_2d_u8vector)
#define ___GLO_write_2d_char ___GLO(125,___G_write_2d_char)
#define ___PRM_write_2d_char ___PRM(125,___G_write_2d_char)
___BEGIN_CNS
___DEF_CNS(___REF_KEY(0,___K_char_2d_encoding),___REF_CNS(1))
,___DEF_CNS(___REF_SYM(0,___S_UTF_2d_8),___REF_NUL)
___END_CNS
___DEF_SUB_STR(___X0,33UL)
___STR8(97,115,109,45,108,97,98,101)
___STR8(108,44,32,108,97,98,101,108)
___STR8(32,109,117,108,116,105,112,108)
___STR8(121,32,100,101,102,105,110,101)
___STR1(100)
___DEF_SUB_STR(___X1,54UL)
___STR8(97,115,109,45,108,97,98,101)
___STR8(108,45,110,97,109,101,44,32)
___STR8(116,104,105,115,32,116,121,112)
___STR8(101,32,111,102,32,108,97,98)
___STR8(101,108,32,105,100,32,105,115)
___STR8(32,110,111,116,32,115,117,112)
___STR6(112,111,114,116,101,100)
___DEF_SUB_STR(___X2,1UL)
___STR1(95)
___DEF_SUB_STR(___X3,30UL)
___STR8(97,115,109,45,108,97,98,101)
___STR8(108,45,112,111,115,44,32,117)
___STR8(110,100,101,102,105,110,101,100)
___STR6(32,108,97,98,101,108)
___DEF_SUB_STR(___X4,27UL)
___STR8(97,115,109,45,111,114,105,103)
___STR8(105,110,44,32,99,97,110,39)
___STR8(116,32,109,111,118,101,32,98)
___STR3(97,99,107)
___DEF_SUB_STR(___X5,1UL)
___STR1(32)
___DEF_SUB_STR(___X6,16UL)
___STR8(48,49,50,51,52,53,54,55)
___STR8(56,57,97,98,99,100,101,102)
___STR0
___DEF_SUB_STR(___X7,1UL)
___STR1(32)
___DEF_SUB_STR(___X8,46UL)
___STR8(97,115,109,45,100,105,115,112)
___STR8(108,97,121,45,108,105,115,116)
___STR8(105,110,103,44,32,99,111,100)
___STR8(101,32,115,116,114,101,97,109)
___STR8(32,110,111,116,32,97,115,115)
___STR6(101,109,98,108,101,100)
___DEF_SUB_STR(___X9,36UL)
___STR8(97,115,109,45,97,115,115,101)
___STR8(109,98,108,101,44,32,105,110)
___STR8(99,111,110,115,105,115,116,101)
___STR8(110,99,121,32,100,101,116,101)
___STR4(99,116,101,100)
___DEF_SUB_STR(___X10,41UL)
___STR8(97,115,109,45,119,114,105,116)
___STR8(101,45,99,111,100,101,44,32)
___STR8(99,111,100,101,32,115,116,114)
___STR8(101,97,109,32,110,111,116,32)
___STR8(97,115,115,101,109,98,108,101)
___STR1(100)
___DEF_SUB_STR(___X11,41UL)
___STR8(97,115,109,45,119,114,105,116)
___STR8(101,45,99,111,100,101,44,32)
___STR8(99,111,100,101,32,115,116,114)
___STR8(101,97,109,32,110,111,116,32)
___STR8(97,115,115,101,109,98,108,101)
___STR1(100)
___DEF_SUB_BIGFIX(___X12,1UL)
___BIGFIX1(-1-0x7FFFFFFFL)
___DEF_SUB_BIGFIX(___X13,1UL)
___BIGFIX1(0x7fffffffL)
___DEF_SUB_BIGFIX(___X14,2UL)
___BIGFIX2(-1-0x7FFFFFFFL,0x0L)
___BIGFIX0
___DEF_SUB_BIGFIX(___X15,2UL)
___BIGFIX2(-0x1L,0x0L)
___BIGFIX0
___DEF_SUB_BIG(___X16,3UL)
___BIG2(0x0L,-1-0x7FFFFFFFL)
___BIG1(0x0L)
___DEF_SUB_BIG(___X17,3UL)
___BIG2(-0x1L,-0x1L)
___BIG1(0x0L)
___DEF_SUB_STR(___X18,17UL)
___STR8(117,110,115,117,112,112,111,114)
___STR8(116,101,100,32,119,105,100,116)
___STR1(104)
___DEF_SUB_STR(___X19,17UL)
___STR8(117,110,115,117,112,112,111,114)
___STR8(116,101,100,32,119,105,100,116)
___STR1(104)
___DEF_SUB_BIGFIX(___X20,2UL)
___BIGFIX2(0x0L,0x1L)
___BIGFIX0
___DEF_SUB_VEC(___X21,5UL)
___VEC1(___REF_SYM(1,___S___asm))
___VEC1(___REF_PRC(1))
___VEC1(___REF_FIX(1))
___VEC1(___REF_NUL)
___VEC1(___REF_FAL)
___VEC0
___BEGIN_SUB
___DEF_SUB(___X0)
,___DEF_SUB(___X1)
,___DEF_SUB(___X2)
,___DEF_SUB(___X3)
,___DEF_SUB(___X4)
,___DEF_SUB(___X5)
,___DEF_SUB(___X6)
,___DEF_SUB(___X7)
,___DEF_SUB(___X8)
,___DEF_SUB(___X9)
,___DEF_SUB(___X10)
,___DEF_SUB(___X11)
,___DEF_SUB(___X12)
,___DEF_SUB(___X13)
,___DEF_SUB(___X14)
,___DEF_SUB(___X15)
,___DEF_SUB(___X16)
,___DEF_SUB(___X17)
,___DEF_SUB(___X18)
,___DEF_SUB(___X19)
,___DEF_SUB(___X20)
,___DEF_SUB(___X21)
___END_SUB
#undef ___MD_ALL
#define ___MD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___MR_ALL
#define ___MR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___MW_ALL
#define ___MW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_M_COD
___BEGIN_M_HLBL
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_)
___DEF_M_HLBL(___L1___asm_23_)
___DEF_M_HLBL(___L2___asm_23_)
___DEF_M_HLBL(___L3___asm_23_)
___DEF_M_HLBL(___L4___asm_23_)
___DEF_M_HLBL(___L5___asm_23_)
___DEF_M_HLBL(___L6___asm_23_)
___DEF_M_HLBL(___L7___asm_23_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_make_2d_code_2d_block)
___DEF_M_HLBL(___L1___asm_23_asm_2d_make_2d_code_2d_block)
___DEF_M_HLBL(___L2___asm_23_asm_2d_make_2d_code_2d_block)
___DEF_M_HLBL(___L3___asm_23_asm_2d_make_2d_code_2d_block)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_M_HLBL(___L1___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_M_HLBL(___L2___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_M_HLBL(___L3___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_M_HLBL(___L4___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_M_HLBL(___L5___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_M_HLBL(___L1___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_M_HLBL(___L2___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_M_HLBL(___L3___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_M_HLBL(___L4___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_M_HLBL(___L5___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_M_HLBL(___L6___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_M_HLBL(___L7___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_M_HLBL(___L8___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_8)
___DEF_M_HLBL(___L1___asm_23_asm_2d_8)
___DEF_M_HLBL(___L2___asm_23_asm_2d_8)
___DEF_M_HLBL(___L3___asm_23_asm_2d_8)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_16)
___DEF_M_HLBL(___L1___asm_23_asm_2d_16)
___DEF_M_HLBL(___L2___asm_23_asm_2d_16)
___DEF_M_HLBL(___L3___asm_23_asm_2d_16)
___DEF_M_HLBL(___L4___asm_23_asm_2d_16)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_16_2d_be)
___DEF_M_HLBL(___L1___asm_23_asm_2d_16_2d_be)
___DEF_M_HLBL(___L2___asm_23_asm_2d_16_2d_be)
___DEF_M_HLBL(___L3___asm_23_asm_2d_16_2d_be)
___DEF_M_HLBL(___L4___asm_23_asm_2d_16_2d_be)
___DEF_M_HLBL(___L5___asm_23_asm_2d_16_2d_be)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_16_2d_le)
___DEF_M_HLBL(___L1___asm_23_asm_2d_16_2d_le)
___DEF_M_HLBL(___L2___asm_23_asm_2d_16_2d_le)
___DEF_M_HLBL(___L3___asm_23_asm_2d_16_2d_le)
___DEF_M_HLBL(___L4___asm_23_asm_2d_16_2d_le)
___DEF_M_HLBL(___L5___asm_23_asm_2d_16_2d_le)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_32)
___DEF_M_HLBL(___L1___asm_23_asm_2d_32)
___DEF_M_HLBL(___L2___asm_23_asm_2d_32)
___DEF_M_HLBL(___L3___asm_23_asm_2d_32)
___DEF_M_HLBL(___L4___asm_23_asm_2d_32)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_32_2d_be)
___DEF_M_HLBL(___L1___asm_23_asm_2d_32_2d_be)
___DEF_M_HLBL(___L2___asm_23_asm_2d_32_2d_be)
___DEF_M_HLBL(___L3___asm_23_asm_2d_32_2d_be)
___DEF_M_HLBL(___L4___asm_23_asm_2d_32_2d_be)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_32_2d_le)
___DEF_M_HLBL(___L1___asm_23_asm_2d_32_2d_le)
___DEF_M_HLBL(___L2___asm_23_asm_2d_32_2d_le)
___DEF_M_HLBL(___L3___asm_23_asm_2d_32_2d_le)
___DEF_M_HLBL(___L4___asm_23_asm_2d_32_2d_le)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_64)
___DEF_M_HLBL(___L1___asm_23_asm_2d_64)
___DEF_M_HLBL(___L2___asm_23_asm_2d_64)
___DEF_M_HLBL(___L3___asm_23_asm_2d_64)
___DEF_M_HLBL(___L4___asm_23_asm_2d_64)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_64_2d_be)
___DEF_M_HLBL(___L1___asm_23_asm_2d_64_2d_be)
___DEF_M_HLBL(___L2___asm_23_asm_2d_64_2d_be)
___DEF_M_HLBL(___L3___asm_23_asm_2d_64_2d_be)
___DEF_M_HLBL(___L4___asm_23_asm_2d_64_2d_be)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_64_2d_le)
___DEF_M_HLBL(___L1___asm_23_asm_2d_64_2d_le)
___DEF_M_HLBL(___L2___asm_23_asm_2d_64_2d_le)
___DEF_M_HLBL(___L3___asm_23_asm_2d_64_2d_le)
___DEF_M_HLBL(___L4___asm_23_asm_2d_64_2d_le)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_int)
___DEF_M_HLBL(___L1___asm_23_asm_2d_int)
___DEF_M_HLBL(___L2___asm_23_asm_2d_int)
___DEF_M_HLBL(___L3___asm_23_asm_2d_int)
___DEF_M_HLBL(___L4___asm_23_asm_2d_int)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL(___L1___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL(___L2___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL(___L3___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL(___L4___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL(___L5___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL(___L6___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL(___L7___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL(___L8___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL(___L9___asm_23_asm_2d_int_2d_be)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL(___L1___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL(___L2___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL(___L3___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL(___L4___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL(___L5___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL(___L6___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL(___L7___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL(___L8___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL(___L9___asm_23_asm_2d_int_2d_le)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_f32)
___DEF_M_HLBL(___L1___asm_23_asm_2d_f32)
___DEF_M_HLBL(___L2___asm_23_asm_2d_f32)
___DEF_M_HLBL(___L3___asm_23_asm_2d_f32)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_f64)
___DEF_M_HLBL(___L1___asm_23_asm_2d_f64)
___DEF_M_HLBL(___L2___asm_23_asm_2d_f64)
___DEF_M_HLBL(___L3___asm_23_asm_2d_f64)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L1___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L2___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L3___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L4___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L5___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L6___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L7___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L8___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L9___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L10___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L11___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L12___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L13___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L14___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL(___L15___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_make_2d_label)
___DEF_M_HLBL(___L1___asm_23_asm_2d_make_2d_label)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_label_3f_)
___DEF_M_HLBL(___L1___asm_23_asm_2d_label_3f_)
___DEF_M_HLBL(___L2___asm_23_asm_2d_label_3f_)
___DEF_M_HLBL(___L3___asm_23_asm_2d_label_3f_)
___DEF_M_HLBL(___L4___asm_23_asm_2d_label_3f_)
___DEF_M_HLBL(___L5___asm_23_asm_2d_label_3f_)
___DEF_M_HLBL(___L6___asm_23_asm_2d_label_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_label)
___DEF_M_HLBL(___L1___asm_23_asm_2d_label)
___DEF_M_HLBL(___L2___asm_23_asm_2d_label)
___DEF_M_HLBL(___L3___asm_23_asm_2d_label)
___DEF_M_HLBL(___L4___asm_23_asm_2d_label)
___DEF_M_HLBL(___L5___asm_23_asm_2d_label)
___DEF_M_HLBL(___L6___asm_23_asm_2d_label)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_label_2d_id)
___DEF_M_HLBL(___L1___asm_23_asm_2d_label_2d_id)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL(___L1___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL(___L2___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL(___L3___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL(___L4___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL(___L5___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL(___L6___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL(___L7___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL(___L8___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL(___L9___asm_23_asm_2d_label_2d_name)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_label_2d_pos)
___DEF_M_HLBL(___L1___asm_23_asm_2d_label_2d_pos)
___DEF_M_HLBL(___L2___asm_23_asm_2d_label_2d_pos)
___DEF_M_HLBL(___L3___asm_23_asm_2d_label_2d_pos)
___DEF_M_HLBL(___L4___asm_23_asm_2d_label_2d_pos)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_align)
___DEF_M_HLBL(___L1___asm_23_asm_2d_align)
___DEF_M_HLBL(___L2___asm_23_asm_2d_align)
___DEF_M_HLBL(___L3___asm_23_asm_2d_align)
___DEF_M_HLBL(___L4___asm_23_asm_2d_align)
___DEF_M_HLBL(___L5___asm_23_asm_2d_align)
___DEF_M_HLBL(___L6___asm_23_asm_2d_align)
___DEF_M_HLBL(___L7___asm_23_asm_2d_align)
___DEF_M_HLBL(___L8___asm_23_asm_2d_align)
___DEF_M_HLBL(___L9___asm_23_asm_2d_align)
___DEF_M_HLBL(___L10___asm_23_asm_2d_align)
___DEF_M_HLBL(___L11___asm_23_asm_2d_align)
___DEF_M_HLBL(___L12___asm_23_asm_2d_align)
___DEF_M_HLBL(___L13___asm_23_asm_2d_align)
___DEF_M_HLBL(___L14___asm_23_asm_2d_align)
___DEF_M_HLBL(___L15___asm_23_asm_2d_align)
___DEF_M_HLBL(___L16___asm_23_asm_2d_align)
___DEF_M_HLBL(___L17___asm_23_asm_2d_align)
___DEF_M_HLBL(___L18___asm_23_asm_2d_align)
___DEF_M_HLBL(___L19___asm_23_asm_2d_align)
___DEF_M_HLBL(___L20___asm_23_asm_2d_align)
___DEF_M_HLBL(___L21___asm_23_asm_2d_align)
___DEF_M_HLBL(___L22___asm_23_asm_2d_align)
___DEF_M_HLBL(___L23___asm_23_asm_2d_align)
___DEF_M_HLBL(___L24___asm_23_asm_2d_align)
___DEF_M_HLBL(___L25___asm_23_asm_2d_align)
___DEF_M_HLBL(___L26___asm_23_asm_2d_align)
___DEF_M_HLBL(___L27___asm_23_asm_2d_align)
___DEF_M_HLBL(___L28___asm_23_asm_2d_align)
___DEF_M_HLBL(___L29___asm_23_asm_2d_align)
___DEF_M_HLBL(___L30___asm_23_asm_2d_align)
___DEF_M_HLBL(___L31___asm_23_asm_2d_align)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L1___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L2___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L3___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L4___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L5___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L6___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L7___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L8___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L9___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L10___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L11___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L12___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L13___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L14___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L15___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L16___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L17___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L18___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L19___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L20___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L21___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L22___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L23___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L24___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L25___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L26___asm_23_asm_2d_origin)
___DEF_M_HLBL(___L27___asm_23_asm_2d_origin)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_at_2d_assembly)
___DEF_M_HLBL(___L1___asm_23_asm_2d_at_2d_assembly)
___DEF_M_HLBL(___L2___asm_23_asm_2d_at_2d_assembly)
___DEF_M_HLBL(___L3___asm_23_asm_2d_at_2d_assembly)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_listing)
___DEF_M_HLBL(___L1___asm_23_asm_2d_listing)
___DEF_M_HLBL(___L2___asm_23_asm_2d_listing)
___DEF_M_HLBL(___L3___asm_23_asm_2d_listing)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL(___L1___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL(___L2___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL(___L3___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL(___L4___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL(___L5___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL(___L6___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL(___L7___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL(___L8___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL(___L9___asm_23_asm_2d_separated_2d_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L1___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L2___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L3___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L4___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L5___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L6___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L7___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L8___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L9___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L10___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L11___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L12___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L13___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L14___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L15___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L16___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L17___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L18___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L19___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L20___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L21___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L22___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L23___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L24___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L25___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L26___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L27___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L28___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L29___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L30___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L31___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L32___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L33___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L34___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L35___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L36___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L37___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L38___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L39___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L40___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L41___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L42___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L43___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L44___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L45___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L46___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L47___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L48___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L49___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L50___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L51___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L52___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L53___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L54___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L55___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L56___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L57___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L58___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L59___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L60___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L61___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L62___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L63___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L64___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L65___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L66___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L67___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L68___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L69___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L70___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L71___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L72___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L73___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L74___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L75___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L76___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL(___L77___asm_23_asm_2d_display_2d_listing)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L1___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L2___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L3___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L4___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L5___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L6___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L7___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L8___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L9___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L10___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L11___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L12___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L13___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L14___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L15___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L16___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L17___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L18___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L19___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L20___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L21___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L22___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L23___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L24___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L25___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L26___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L27___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L28___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L29___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L30___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L31___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L32___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L33___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L34___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L35___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L36___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L37___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L38___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L39___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L40___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L41___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L42___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L43___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L44___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L45___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L46___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L47___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L48___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L49___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L50___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L51___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L52___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L53___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L54___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L55___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L56___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L57___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L58___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L59___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L60___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L61___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L62___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L63___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L64___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L65___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L66___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L67___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L68___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L69___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L70___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L71___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L72___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L73___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L74___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L75___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L76___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L77___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L78___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L79___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L80___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L81___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L82___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L83___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L84___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L85___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L86___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L87___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L88___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L89___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L90___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L91___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L92___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L93___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L94___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L95___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L96___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L97___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L98___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L99___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L100___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L101___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L102___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L103___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L104___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L105___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L106___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L107___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L108___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L109___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L110___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L111___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L112___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L113___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L114___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L115___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L116___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L117___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L118___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L119___asm_23_asm_2d_assemble)
___DEF_M_HLBL(___L120___asm_23_asm_2d_assemble)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L1___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L2___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L3___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L4___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L5___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L6___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L7___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L8___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L9___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L10___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L11___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L12___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L13___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L14___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L15___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L16___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L17___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L18___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL(___L19___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L1___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L2___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L3___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L4___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L5___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L6___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L7___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L8___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L9___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L10___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L11___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L12___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L13___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L14___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L15___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L16___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L17___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L18___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L19___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL(___L20___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_make_2d_stream)
___DEF_M_HLBL(___L1___asm_23_asm_2d_make_2d_stream)
___DEF_M_HLBL(___L2___asm_23_asm_2d_make_2d_stream)
___DEF_M_HLBL(___L3___asm_23_asm_2d_make_2d_stream)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_code_2d_extend)
___DEF_M_HLBL(___L1___asm_23_asm_2d_code_2d_extend)
___DEF_M_HLBL(___L2___asm_23_asm_2d_code_2d_extend)
___DEF_M_HLBL(___L3___asm_23_asm_2d_code_2d_extend)
___DEF_M_HLBL(___L4___asm_23_asm_2d_code_2d_extend)
___DEF_M_HLBL(___L5___asm_23_asm_2d_code_2d_extend)
___DEF_M_HLBL(___L6___asm_23_asm_2d_code_2d_extend)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_signed8_3f_)
___DEF_M_HLBL(___L1___asm_23_asm_2d_signed8_3f_)
___DEF_M_HLBL(___L2___asm_23_asm_2d_signed8_3f_)
___DEF_M_HLBL(___L3___asm_23_asm_2d_signed8_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_signed16_3f_)
___DEF_M_HLBL(___L1___asm_23_asm_2d_signed16_3f_)
___DEF_M_HLBL(___L2___asm_23_asm_2d_signed16_3f_)
___DEF_M_HLBL(___L3___asm_23_asm_2d_signed16_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_signed32_3f_)
___DEF_M_HLBL(___L1___asm_23_asm_2d_signed32_3f_)
___DEF_M_HLBL(___L2___asm_23_asm_2d_signed32_3f_)
___DEF_M_HLBL(___L3___asm_23_asm_2d_signed32_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_signed_2d_lo8)
___DEF_M_HLBL(___L1___asm_23_asm_2d_signed_2d_lo8)
___DEF_M_HLBL(___L2___asm_23_asm_2d_signed_2d_lo8)
___DEF_M_HLBL(___L3___asm_23_asm_2d_signed_2d_lo8)
___DEF_M_HLBL(___L4___asm_23_asm_2d_signed_2d_lo8)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo8)
___DEF_M_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo8)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_signed_2d_lo16)
___DEF_M_HLBL(___L1___asm_23_asm_2d_signed_2d_lo16)
___DEF_M_HLBL(___L2___asm_23_asm_2d_signed_2d_lo16)
___DEF_M_HLBL(___L3___asm_23_asm_2d_signed_2d_lo16)
___DEF_M_HLBL(___L4___asm_23_asm_2d_signed_2d_lo16)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo16)
___DEF_M_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo16)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_signed_2d_lo32)
___DEF_M_HLBL(___L1___asm_23_asm_2d_signed_2d_lo32)
___DEF_M_HLBL(___L2___asm_23_asm_2d_signed_2d_lo32)
___DEF_M_HLBL(___L3___asm_23_asm_2d_signed_2d_lo32)
___DEF_M_HLBL(___L4___asm_23_asm_2d_signed_2d_lo32)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo32)
___DEF_M_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo32)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_signed_2d_lo64)
___DEF_M_HLBL(___L1___asm_23_asm_2d_signed_2d_lo64)
___DEF_M_HLBL(___L2___asm_23_asm_2d_signed_2d_lo64)
___DEF_M_HLBL(___L3___asm_23_asm_2d_signed_2d_lo64)
___DEF_M_HLBL(___L4___asm_23_asm_2d_signed_2d_lo64)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo64)
___DEF_M_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo64)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_signed_2d_lo)
___DEF_M_HLBL(___L1___asm_23_asm_2d_signed_2d_lo)
___DEF_M_HLBL(___L2___asm_23_asm_2d_signed_2d_lo)
___DEF_M_HLBL(___L3___asm_23_asm_2d_signed_2d_lo)
___DEF_M_HLBL(___L4___asm_23_asm_2d_signed_2d_lo)
___DEF_M_HLBL(___L5___asm_23_asm_2d_signed_2d_lo)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo)
___DEF_M_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo)
___DEF_M_HLBL(___L2___asm_23_asm_2d_unsigned_2d_lo)
___DEF_M_HLBL(___L3___asm_23_asm_2d_unsigned_2d_lo)
___DEF_M_HLBL(___L4___asm_23_asm_2d_unsigned_2d_lo)
___DEF_M_HLBL(___L5___asm_23_asm_2d_unsigned_2d_lo)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
___DEF_M_HLBL(___L1___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_M_HLBL(___L1___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_M_HLBL(___L2___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_M_HLBL(___L3___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_M_HLBL(___L4___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_M_HLBL(___L5___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_M_HLBL(___L6___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_M_HLBL(___L1___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_M_HLBL(___L2___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_M_HLBL(___L3___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_M_HLBL(___L4___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_M_HLBL(___L5___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_M_HLBL(___L6___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_M_HLBL(___L1___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_M_HLBL(___L2___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_M_HLBL(___L3___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_M_HLBL(___L4___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_M_HLBL(___L5___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_M_HLBL(___L6___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L1___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L2___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L3___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L4___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L5___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L6___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L7___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L8___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L9___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L10___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L11___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L12___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L13___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L14___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L15___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L16___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L17___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L18___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L19___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L20___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L21___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L22___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L23___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L24___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L25___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L26___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L27___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L28___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L29___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L30___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L31___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L32___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L33___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L34___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L35___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L36___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L37___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L38___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L39___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L40___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L41___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L42___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L43___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L44___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L45___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L46___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L47___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L48___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L49___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L50___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L51___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL(___L52___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L1___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L2___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L3___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L4___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L5___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L6___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L7___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L8___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L9___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L10___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L11___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L12___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L13___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L14___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L15___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L16___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L17___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L18___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L19___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L20___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L21___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL(___L22___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L1___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L2___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L3___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L4___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L5___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L6___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L7___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L8___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L9___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L10___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L11___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L12___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L13___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L14___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L15___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L16___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L17___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L18___asm_23_asm_2d_float_2d__3e_bits)
___DEF_M_HLBL(___L19___asm_23_asm_2d_float_2d__3e_bits)
___END_M_HLBL
___BEGIN_M_SW
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_
#undef ___PH_LBL0
#define ___PH_LBL0 1
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_)
___DEF_P_HLBL(___L1___asm_23_)
___DEF_P_HLBL(___L2___asm_23_)
___DEF_P_HLBL(___L3___asm_23_)
___DEF_P_HLBL(___L4___asm_23_)
___DEF_P_HLBL(___L5___asm_23_)
___DEF_P_HLBL(___L6___asm_23_)
___DEF_P_HLBL(___L7___asm_23_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(0,0,0,0)
___DEF_GLBL(___L___asm_23_)
___SET_STK(1,___R0)
___SET_R1(___FIX(2L))
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(1),80,___G_exact_2d__3e_inexact)
___DEF_SLBL(2,___L2___asm_23_)
___SET_GLO(32,___G___asm_23_asm_2d_inexact_2d__2b_2,___R1)
___SET_R1(___FIX(-2L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(1),80,___G_exact_2d__3e_inexact)
___DEF_SLBL(3,___L3___asm_23_)
___SET_GLO(33,___G___asm_23_asm_2d_inexact_2d__2d_2,___R1)
___SET_R1(___FIX(1L))
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(1),80,___G_exact_2d__3e_inexact)
___DEF_SLBL(4,___L4___asm_23_)
___SET_GLO(30,___G___asm_23_asm_2d_inexact_2d__2b_1,___R1)
___SET_R2(___FIX(2L))
___SET_R1(___FIX(1L))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(2),65,___G__2f_)
___DEF_SLBL(5,___L5___asm_23_)
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(1),80,___G_exact_2d__3e_inexact)
___DEF_SLBL(6,___L6___asm_23_)
___SET_GLO(31,___G___asm_23_asm_2d_inexact_2d__2b_1_2f_2,___R1)
___SET_R1(___FIX(0L))
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(1),80,___G_exact_2d__3e_inexact)
___DEF_SLBL(7,___L7___asm_23_)
___SET_GLO(29,___G___asm_23_asm_2d_inexact_2d__2b_0,___R1)
___SET_R1(___VOID)
___ADJFP(-4)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_make_2d_code_2d_block
#undef ___PH_LBL0
#define ___PH_LBL0 10
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_make_2d_code_2d_block)
___DEF_P_HLBL(___L1___asm_23_asm_2d_make_2d_code_2d_block)
___DEF_P_HLBL(___L2___asm_23_asm_2d_make_2d_code_2d_block)
___DEF_P_HLBL(___L3___asm_23_asm_2d_make_2d_code_2d_block)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_make_2d_code_2d_block)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_make_2d_code_2d_block)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___SYM_code_2d_block)
___SET_R1(___FIX(4L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_make_2d_code_2d_block)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),95,___G_make_2d_vector)
___DEF_SLBL(2,___L2___asm_23_asm_2d_make_2d_code_2d_block)
___SET_R3(___STK(-5))
___SET_R2(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_make_2d_code_2d_block)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(3),___PRC(15),___L___asm_23_asm_2d_init_2d_code_2d_block)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_init_2d_code_2d_block
#undef ___PH_LBL0
#define ___PH_LBL0 15
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_P_HLBL(___L1___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_P_HLBL(___L2___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_P_HLBL(___L3___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_P_HLBL(___L4___asm_23_asm_2d_init_2d_code_2d_block)
___DEF_P_HLBL(___L5___asm_23_asm_2d_init_2d_code_2d_block)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_init_2d_code_2d_block)
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,3,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_init_2d_code_2d_block)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R3)
___SET_R3(___R2)
___SET_R2(___FIX(1L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_init_2d_code_2d_block)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_init_2d_code_2d_block)
___SET_R3(___STK(-5))
___SET_R1(___STK(-6))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(3,___L3___asm_23_asm_2d_init_2d_code_2d_block)
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(0),___PRC(514),___L___asm_23_asm_2d_make_2d_stream)
___DEF_SLBL(4,___L4___asm_23_asm_2d_init_2d_code_2d_block)
___SET_R3(___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(5,___L5___asm_23_asm_2d_init_2d_code_2d_block)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_copy_2d_code_2d_block
#undef ___PH_LBL0
#define ___PH_LBL0 22
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_P_HLBL(___L1___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_P_HLBL(___L2___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_P_HLBL(___L3___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_P_HLBL(___L4___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_P_HLBL(___L5___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_P_HLBL(___L6___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_P_HLBL(___L7___asm_23_asm_2d_copy_2d_code_2d_block)
___DEF_P_HLBL(___L8___asm_23_asm_2d_copy_2d_code_2d_block)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_copy_2d_code_2d_block)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_copy_2d_code_2d_block)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___SYM_code_2d_block)
___SET_R1(___FIX(4L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_copy_2d_code_2d_block)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),95,___G_make_2d_vector)
___DEF_SLBL(2,___L2___asm_23_asm_2d_copy_2d_code_2d_block)
___SET_STK(-5,___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(3,___L3___asm_23_asm_2d_copy_2d_code_2d_block)
___SET_R3(___R1)
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(4,___L4___asm_23_asm_2d_copy_2d_code_2d_block)
___SET_R1(___STK(-6))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(5,___L5___asm_23_asm_2d_copy_2d_code_2d_block)
___SET_R3(___R1)
___SET_R1(___STK(-5))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(6,___L6___asm_23_asm_2d_copy_2d_code_2d_block)
___SET_R1(___STK(-6))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(7,___L7___asm_23_asm_2d_copy_2d_code_2d_block)
___SET_R3(___R1)
___SET_R1(___STK(-5))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(8))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(8,___L8___asm_23_asm_2d_copy_2d_code_2d_block)
___SET_R1(___STK(-5))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_8
#undef ___PH_LBL0
#define ___PH_LBL0 32
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_8)
___DEF_P_HLBL(___L1___asm_23_asm_2d_8)
___DEF_P_HLBL(___L2___asm_23_asm_2d_8)
___DEF_P_HLBL(___L3___asm_23_asm_2d_8)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_8)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_8)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___R2)
___SET_R2(___FIX(256L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_8)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),97,___G_modulo)
___DEF_SLBL(2,___L2___asm_23_asm_2d_8)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_8)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_16
#undef ___PH_LBL0
#define ___PH_LBL0 37
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_16)
___DEF_P_HLBL(___L1___asm_23_asm_2d_16)
___DEF_P_HLBL(___L2___asm_23_asm_2d_16)
___DEF_P_HLBL(___L3___asm_23_asm_2d_16)
___DEF_P_HLBL(___L4___asm_23_asm_2d_16)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_16)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_16)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___FIX(2L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_16)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(2,___L2___asm_23_asm_2d_16)
___IF(___NOT(___EQP(___R1,___SYM_be)))
___GOTO(___L5___asm_23_asm_2d_16)
___END_IF
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_16)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(43),___L___asm_23_asm_2d_16_2d_be)
___DEF_GLBL(___L5___asm_23_asm_2d_16)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_16)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(50),___L___asm_23_asm_2d_16_2d_le)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_16_2d_be
#undef ___PH_LBL0
#define ___PH_LBL0 43
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_16_2d_be)
___DEF_P_HLBL(___L1___asm_23_asm_2d_16_2d_be)
___DEF_P_HLBL(___L2___asm_23_asm_2d_16_2d_be)
___DEF_P_HLBL(___L3___asm_23_asm_2d_16_2d_be)
___DEF_P_HLBL(___L4___asm_23_asm_2d_16_2d_be)
___DEF_P_HLBL(___L5___asm_23_asm_2d_16_2d_be)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_16_2d_be)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_16_2d_be)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___R2)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_16_2d_be)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(1),___PRC(595),___L___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_SLBL(2,___L2___asm_23_asm_2d_16_2d_be)
___SET_R2(___FIX(256L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),97,___G_modulo)
___DEF_SLBL(3,___L3___asm_23_asm_2d_16_2d_be)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___DEF_SLBL(4,___L4___asm_23_asm_2d_16_2d_be)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(5)
___DEF_SLBL(5,___L5___asm_23_asm_2d_16_2d_be)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(32),___L___asm_23_asm_2d_8)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_16_2d_le
#undef ___PH_LBL0
#define ___PH_LBL0 50
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_16_2d_le)
___DEF_P_HLBL(___L1___asm_23_asm_2d_16_2d_le)
___DEF_P_HLBL(___L2___asm_23_asm_2d_16_2d_le)
___DEF_P_HLBL(___L3___asm_23_asm_2d_16_2d_le)
___DEF_P_HLBL(___L4___asm_23_asm_2d_16_2d_le)
___DEF_P_HLBL(___L5___asm_23_asm_2d_16_2d_le)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_16_2d_le)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_16_2d_le)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_16_2d_le)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(32),___L___asm_23_asm_2d_8)
___DEF_SLBL(2,___L2___asm_23_asm_2d_16_2d_le)
___SET_R1(___STK(-5))
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(1),___PRC(595),___L___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_SLBL(3,___L3___asm_23_asm_2d_16_2d_le)
___SET_R2(___FIX(256L))
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(2),97,___G_modulo)
___DEF_SLBL(4,___L4___asm_23_asm_2d_16_2d_le)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(5)
___DEF_SLBL(5,___L5___asm_23_asm_2d_16_2d_le)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_32
#undef ___PH_LBL0
#define ___PH_LBL0 57
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_32)
___DEF_P_HLBL(___L1___asm_23_asm_2d_32)
___DEF_P_HLBL(___L2___asm_23_asm_2d_32)
___DEF_P_HLBL(___L3___asm_23_asm_2d_32)
___DEF_P_HLBL(___L4___asm_23_asm_2d_32)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_32)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_32)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___FIX(2L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_32)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(2,___L2___asm_23_asm_2d_32)
___IF(___NOT(___EQP(___R1,___SYM_be)))
___GOTO(___L5___asm_23_asm_2d_32)
___END_IF
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_32)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(63),___L___asm_23_asm_2d_32_2d_be)
___DEF_GLBL(___L5___asm_23_asm_2d_32)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_32)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(69),___L___asm_23_asm_2d_32_2d_le)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_32_2d_be
#undef ___PH_LBL0
#define ___PH_LBL0 63
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_32_2d_be)
___DEF_P_HLBL(___L1___asm_23_asm_2d_32_2d_be)
___DEF_P_HLBL(___L2___asm_23_asm_2d_32_2d_be)
___DEF_P_HLBL(___L3___asm_23_asm_2d_32_2d_be)
___DEF_P_HLBL(___L4___asm_23_asm_2d_32_2d_be)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_32_2d_be)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_32_2d_be)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___R2)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_32_2d_be)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(1),___PRC(603),___L___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_SLBL(2,___L2___asm_23_asm_2d_32_2d_be)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(2),___PRC(43),___L___asm_23_asm_2d_16_2d_be)
___DEF_SLBL(3,___L3___asm_23_asm_2d_32_2d_be)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_32_2d_be)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(43),___L___asm_23_asm_2d_16_2d_be)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_32_2d_le
#undef ___PH_LBL0
#define ___PH_LBL0 69
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_32_2d_le)
___DEF_P_HLBL(___L1___asm_23_asm_2d_32_2d_le)
___DEF_P_HLBL(___L2___asm_23_asm_2d_32_2d_le)
___DEF_P_HLBL(___L3___asm_23_asm_2d_32_2d_le)
___DEF_P_HLBL(___L4___asm_23_asm_2d_32_2d_le)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_32_2d_le)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_32_2d_le)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_32_2d_le)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(50),___L___asm_23_asm_2d_16_2d_le)
___DEF_SLBL(2,___L2___asm_23_asm_2d_32_2d_le)
___SET_R1(___STK(-5))
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(1),___PRC(603),___L___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_SLBL(3,___L3___asm_23_asm_2d_32_2d_le)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_32_2d_le)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(50),___L___asm_23_asm_2d_16_2d_le)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_64
#undef ___PH_LBL0
#define ___PH_LBL0 75
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_64)
___DEF_P_HLBL(___L1___asm_23_asm_2d_64)
___DEF_P_HLBL(___L2___asm_23_asm_2d_64)
___DEF_P_HLBL(___L3___asm_23_asm_2d_64)
___DEF_P_HLBL(___L4___asm_23_asm_2d_64)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_64)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_64)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___FIX(2L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_64)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(2,___L2___asm_23_asm_2d_64)
___IF(___NOT(___EQP(___R1,___SYM_be)))
___GOTO(___L5___asm_23_asm_2d_64)
___END_IF
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_64)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(81),___L___asm_23_asm_2d_64_2d_be)
___DEF_GLBL(___L5___asm_23_asm_2d_64)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_64)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(87),___L___asm_23_asm_2d_64_2d_le)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_64_2d_be
#undef ___PH_LBL0
#define ___PH_LBL0 81
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_64_2d_be)
___DEF_P_HLBL(___L1___asm_23_asm_2d_64_2d_be)
___DEF_P_HLBL(___L2___asm_23_asm_2d_64_2d_be)
___DEF_P_HLBL(___L3___asm_23_asm_2d_64_2d_be)
___DEF_P_HLBL(___L4___asm_23_asm_2d_64_2d_be)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_64_2d_be)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_64_2d_be)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___R2)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_64_2d_be)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(1),___PRC(611),___L___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_SLBL(2,___L2___asm_23_asm_2d_64_2d_be)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(2),___PRC(63),___L___asm_23_asm_2d_32_2d_be)
___DEF_SLBL(3,___L3___asm_23_asm_2d_64_2d_be)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_64_2d_be)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(63),___L___asm_23_asm_2d_32_2d_be)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_64_2d_le
#undef ___PH_LBL0
#define ___PH_LBL0 87
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_64_2d_le)
___DEF_P_HLBL(___L1___asm_23_asm_2d_64_2d_le)
___DEF_P_HLBL(___L2___asm_23_asm_2d_64_2d_le)
___DEF_P_HLBL(___L3___asm_23_asm_2d_64_2d_le)
___DEF_P_HLBL(___L4___asm_23_asm_2d_64_2d_le)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_64_2d_le)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_64_2d_le)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_64_2d_le)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(69),___L___asm_23_asm_2d_32_2d_le)
___DEF_SLBL(2,___L2___asm_23_asm_2d_64_2d_le)
___SET_R1(___STK(-5))
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(1),___PRC(611),___L___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_SLBL(3,___L3___asm_23_asm_2d_64_2d_le)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_64_2d_le)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(69),___L___asm_23_asm_2d_32_2d_le)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_int
#undef ___PH_LBL0
#define ___PH_LBL0 93
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_int)
___DEF_P_HLBL(___L1___asm_23_asm_2d_int)
___DEF_P_HLBL(___L2___asm_23_asm_2d_int)
___DEF_P_HLBL(___L3___asm_23_asm_2d_int)
___DEF_P_HLBL(___L4___asm_23_asm_2d_int)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_int)
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,3,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_int)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R2(___FIX(2L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_int)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(2,___L2___asm_23_asm_2d_int)
___IF(___NOT(___EQP(___R1,___SYM_be)))
___GOTO(___L5___asm_23_asm_2d_int)
___END_IF
___SET_R3(___STK(-4))
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_int)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(3),___PRC(99),___L___asm_23_asm_2d_int_2d_be)
___DEF_GLBL(___L5___asm_23_asm_2d_int)
___SET_R3(___STK(-4))
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_int)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(3),___PRC(110),___L___asm_23_asm_2d_int_2d_le)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_int_2d_be
#undef ___PH_LBL0
#define ___PH_LBL0 99
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_int_2d_be)
___DEF_P_HLBL(___L1___asm_23_asm_2d_int_2d_be)
___DEF_P_HLBL(___L2___asm_23_asm_2d_int_2d_be)
___DEF_P_HLBL(___L3___asm_23_asm_2d_int_2d_be)
___DEF_P_HLBL(___L4___asm_23_asm_2d_int_2d_be)
___DEF_P_HLBL(___L5___asm_23_asm_2d_int_2d_be)
___DEF_P_HLBL(___L6___asm_23_asm_2d_int_2d_be)
___DEF_P_HLBL(___L7___asm_23_asm_2d_int_2d_be)
___DEF_P_HLBL(___L8___asm_23_asm_2d_int_2d_be)
___DEF_P_HLBL(___L9___asm_23_asm_2d_int_2d_be)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_int_2d_be)
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,3,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_int_2d_be)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R3)
___SET_R2(___FIX(8L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_int_2d_be)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_int_2d_be)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L10___asm_23_asm_2d_int_2d_be)
___END_IF
___SET_R1(___STK(-5))
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(1),___PRC(542),___L___asm_23_asm_2d_signed_2d_lo8)
___DEF_SLBL(3,___L3___asm_23_asm_2d_int_2d_be)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(32),___L___asm_23_asm_2d_8)
___DEF_SLBL(4,___L4___asm_23_asm_2d_int_2d_be)
___SET_R1(___STK(-5))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L10___asm_23_asm_2d_int_2d_be)
___SET_R1(___STK(-4))
___SET_R2(___FIX(16L))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(5,___L5___asm_23_asm_2d_int_2d_be)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L11___asm_23_asm_2d_int_2d_be)
___END_IF
___SET_R1(___STK(-5))
___SET_R0(___LBL(6))
___JUMPINT(___SET_NARGS(1),___PRC(551),___L___asm_23_asm_2d_signed_2d_lo16)
___DEF_SLBL(6,___L6___asm_23_asm_2d_int_2d_be)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(43),___L___asm_23_asm_2d_16_2d_be)
___DEF_GLBL(___L11___asm_23_asm_2d_int_2d_be)
___SET_R1(___STK(-4))
___SET_R2(___FIX(32L))
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(7,___L7___asm_23_asm_2d_int_2d_be)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L12___asm_23_asm_2d_int_2d_be)
___END_IF
___SET_R1(___STK(-5))
___SET_R0(___LBL(8))
___JUMPINT(___SET_NARGS(1),___PRC(560),___L___asm_23_asm_2d_signed_2d_lo32)
___DEF_SLBL(8,___L8___asm_23_asm_2d_int_2d_be)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(63),___L___asm_23_asm_2d_32_2d_be)
___DEF_GLBL(___L12___asm_23_asm_2d_int_2d_be)
___SET_R1(___STK(-5))
___SET_R0(___LBL(9))
___JUMPINT(___SET_NARGS(1),___PRC(569),___L___asm_23_asm_2d_signed_2d_lo64)
___DEF_SLBL(9,___L9___asm_23_asm_2d_int_2d_be)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(81),___L___asm_23_asm_2d_64_2d_be)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_int_2d_le
#undef ___PH_LBL0
#define ___PH_LBL0 110
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_int_2d_le)
___DEF_P_HLBL(___L1___asm_23_asm_2d_int_2d_le)
___DEF_P_HLBL(___L2___asm_23_asm_2d_int_2d_le)
___DEF_P_HLBL(___L3___asm_23_asm_2d_int_2d_le)
___DEF_P_HLBL(___L4___asm_23_asm_2d_int_2d_le)
___DEF_P_HLBL(___L5___asm_23_asm_2d_int_2d_le)
___DEF_P_HLBL(___L6___asm_23_asm_2d_int_2d_le)
___DEF_P_HLBL(___L7___asm_23_asm_2d_int_2d_le)
___DEF_P_HLBL(___L8___asm_23_asm_2d_int_2d_le)
___DEF_P_HLBL(___L9___asm_23_asm_2d_int_2d_le)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_int_2d_le)
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,3,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_int_2d_le)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R3)
___SET_R2(___FIX(8L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_int_2d_le)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_int_2d_le)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L10___asm_23_asm_2d_int_2d_le)
___END_IF
___SET_R1(___STK(-5))
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(1),___PRC(542),___L___asm_23_asm_2d_signed_2d_lo8)
___DEF_SLBL(3,___L3___asm_23_asm_2d_int_2d_le)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(32),___L___asm_23_asm_2d_8)
___DEF_SLBL(4,___L4___asm_23_asm_2d_int_2d_le)
___SET_R1(___STK(-5))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L10___asm_23_asm_2d_int_2d_le)
___SET_R1(___STK(-4))
___SET_R2(___FIX(16L))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(5,___L5___asm_23_asm_2d_int_2d_le)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L11___asm_23_asm_2d_int_2d_le)
___END_IF
___SET_R1(___STK(-5))
___SET_R0(___LBL(6))
___JUMPINT(___SET_NARGS(1),___PRC(551),___L___asm_23_asm_2d_signed_2d_lo16)
___DEF_SLBL(6,___L6___asm_23_asm_2d_int_2d_le)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(50),___L___asm_23_asm_2d_16_2d_le)
___DEF_GLBL(___L11___asm_23_asm_2d_int_2d_le)
___SET_R1(___STK(-4))
___SET_R2(___FIX(32L))
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(7,___L7___asm_23_asm_2d_int_2d_le)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L12___asm_23_asm_2d_int_2d_le)
___END_IF
___SET_R1(___STK(-5))
___SET_R0(___LBL(8))
___JUMPINT(___SET_NARGS(1),___PRC(560),___L___asm_23_asm_2d_signed_2d_lo32)
___DEF_SLBL(8,___L8___asm_23_asm_2d_int_2d_le)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(69),___L___asm_23_asm_2d_32_2d_le)
___DEF_GLBL(___L12___asm_23_asm_2d_int_2d_le)
___SET_R1(___STK(-5))
___SET_R0(___LBL(9))
___JUMPINT(___SET_NARGS(1),___PRC(569),___L___asm_23_asm_2d_signed_2d_lo64)
___DEF_SLBL(9,___L9___asm_23_asm_2d_int_2d_le)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(87),___L___asm_23_asm_2d_64_2d_le)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_f32
#undef ___PH_LBL0
#define ___PH_LBL0 121
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_f32)
___DEF_P_HLBL(___L1___asm_23_asm_2d_f32)
___DEF_P_HLBL(___L2___asm_23_asm_2d_f32)
___DEF_P_HLBL(___L3___asm_23_asm_2d_f32)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_f32)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_f32)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___R2)
___SET_R2(___FAL)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_f32)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(697),___L___asm_23_asm_2d_float_2d__3e_bits)
___DEF_SLBL(2,___L2___asm_23_asm_2d_f32)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_f32)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(57),___L___asm_23_asm_2d_32)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_f64
#undef ___PH_LBL0
#define ___PH_LBL0 126
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_f64)
___DEF_P_HLBL(___L1___asm_23_asm_2d_f64)
___DEF_P_HLBL(___L2___asm_23_asm_2d_f64)
___DEF_P_HLBL(___L3___asm_23_asm_2d_f64)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_f64)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_f64)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___R2)
___SET_R2(___TRU)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_f64)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(697),___L___asm_23_asm_2d_float_2d__3e_bits)
___DEF_SLBL(2,___L2___asm_23_asm_2d_f64)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_f64)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(75),___L___asm_23_asm_2d_64)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_UTF_2d_8_2d_string
#undef ___PH_LBL0
#define ___PH_LBL0 131
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L1___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L2___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L3___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L4___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L5___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L6___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L7___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L8___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L9___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L10___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L11___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L12___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L13___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L14___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_P_HLBL(___L15___asm_23_asm_2d_UTF_2d_8_2d_string)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_UTF_2d_8_2d_string)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___ALLOC_CLO(1UL))
___BEGIN_SETUP_CLO(1,___STK(3),14)
___ADD_CLO_ELEM(0,___R2)
___END_SETUP_CLO(1)
___SET_R2(___STK(3))
___SET_R1(___CNS(0))
___ADJFP(8)
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1___asm_23_asm_2d_UTF_2d_8_2d_string)
___POLL(2)
___DEF_SLBL(2,___L2___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),124,___G_with_2d_output_2d_to_2d_u8vector)
___DEF_SLBL(3,___L3___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_STK(-5,___R1)
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(1),115,___G_u8vector_2d_length)
___DEF_SLBL(4,___L4___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_STK(-4,___STK(-7))
___SET_STK(-7,___STK(-6))
___SET_R2(___R1)
___SET_R1(___STK(-5))
___SET_R3(___FIX(0L))
___SET_R0(___STK(-4))
___ADJFP(-7)
___POLL(5)
___DEF_SLBL(5,___L5___asm_23_asm_2d_UTF_2d_8_2d_string)
___GOTO(___L16___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_SLBL(6,___L6___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_R3(___R1)
___SET_R2(___STK(-4))
___SET_R1(___STK(-5))
___SET_R0(___STK(-6))
___ADJFP(-7)
___POLL(7)
___DEF_SLBL(7,___L7___asm_23_asm_2d_UTF_2d_8_2d_string)
___DEF_GLBL(___L16___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R3)
___ADJFP(7)
___POLL(8)
___DEF_SLBL(8,___L8___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_R0(___LBL(9))
___JUMPGLONOTSAFE(___SET_NARGS(2),85,___G_fx_3c_)
___DEF_SLBL(9,___L9___asm_23_asm_2d_UTF_2d_8_2d_string)
___IF(___NOTFALSEP(___R1))
___GOTO(___L17___asm_23_asm_2d_UTF_2d_8_2d_string)
___END_IF
___SET_R1(___STK(-7))
___SET_R2(___FIX(0L))
___SET_R0(___STK(-6))
___POLL(10)
___DEF_SLBL(10,___L10___asm_23_asm_2d_UTF_2d_8_2d_string)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(32),___L___asm_23_asm_2d_8)
___DEF_GLBL(___L17___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_R2(___STK(-3))
___SET_R1(___STK(-5))
___SET_R0(___LBL(11))
___JUMPGLONOTSAFE(___SET_NARGS(2),116,___G_u8vector_2d_ref)
___DEF_SLBL(11,___L11___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_R2(___FIX(256L))
___SET_R0(___LBL(12))
___JUMPGLONOTSAFE(___SET_NARGS(2),97,___G_modulo)
___DEF_SLBL(12,___L12___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(13))
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___DEF_SLBL(13,___L13___asm_23_asm_2d_UTF_2d_8_2d_string)
___SET_R1(___STK(-3))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(14,___L14___asm_23_asm_2d_UTF_2d_8_2d_string)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(14,0,0,0)
___SET_R1(___CLO(___R4,1))
___POLL(15)
___DEF_SLBL(15,___L15___asm_23_asm_2d_UTF_2d_8_2d_string)
___JUMPGLONOTSAFE(___SET_NARGS(1),77,___G_display)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_make_2d_label
#undef ___PH_LBL0
#define ___PH_LBL0 148
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_make_2d_label)
___DEF_P_HLBL(___L1___asm_23_asm_2d_make_2d_label)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_make_2d_label)
___IF_NARGS_EQ(2,___SET_R3(___FAL))
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,2,1,0)
___DEF_GLBL(___L___asm_23_asm_2d_make_2d_label)
___SET_STK(1,___R3)
___SET_R3(___R2)
___SET_R2(___STK(1))
___SET_R1(___SYM_label)
___ADJFP(1)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_make_2d_label)
___ADJFP(-1)
___JUMPGLONOTSAFE(___SET_NARGS(3),118,___G_vector)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_label_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 151
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_label_3f_)
___DEF_P_HLBL(___L1___asm_23_asm_2d_label_3f_)
___DEF_P_HLBL(___L2___asm_23_asm_2d_label_3f_)
___DEF_P_HLBL(___L3___asm_23_asm_2d_label_3f_)
___DEF_P_HLBL(___L4___asm_23_asm_2d_label_3f_)
___DEF_P_HLBL(___L5___asm_23_asm_2d_label_3f_)
___DEF_P_HLBL(___L6___asm_23_asm_2d_label_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_label_3f_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_label_3f_)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_label_3f_)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(1),122,___G_vector_3f_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_label_3f_)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L7___asm_23_asm_2d_label_3f_)
___END_IF
___SET_R1(___STK(-6))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(1),119,___G_vector_2d_length)
___DEF_SLBL(3,___L3___asm_23_asm_2d_label_3f_)
___SET_R2(___FIX(3L))
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(4,___L4___asm_23_asm_2d_label_3f_)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L7___asm_23_asm_2d_label_3f_)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(5))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(5,___L5___asm_23_asm_2d_label_3f_)
___SET_R2(___SYM_label)
___SET_R0(___STK(-3))
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_label_3f_)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_GLBL(___L7___asm_23_asm_2d_label_3f_)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_label
#undef ___PH_LBL0
#define ___PH_LBL0 159
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_label)
___DEF_P_HLBL(___L1___asm_23_asm_2d_label)
___DEF_P_HLBL(___L2___asm_23_asm_2d_label)
___DEF_P_HLBL(___L3___asm_23_asm_2d_label)
___DEF_P_HLBL(___L4___asm_23_asm_2d_label)
___DEF_P_HLBL(___L5___asm_23_asm_2d_label)
___DEF_P_HLBL(___L6___asm_23_asm_2d_label)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_label)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_label)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___R2)
___SET_R2(___FIX(1L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_label)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(2,___L2___asm_23_asm_2d_label)
___IF(___NOTFALSEP(___R1))
___GOTO(___L7___asm_23_asm_2d_label)
___END_IF
___SET_R1(___STK(-5))
___SET_R3(___FIX(0L))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(3,___L3___asm_23_asm_2d_label)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_label)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___DEF_GLBL(___L7___asm_23_asm_2d_label)
___SET_R1(___STK(-5))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(5))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(5,___L5___asm_23_asm_2d_label)
___SET_R2(___R1)
___SET_R1(___SUB(0))
___SET_R0(___STK(-3))
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_label)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),70,___G_c_23_compiler_2d_internal_2d_error)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_label_2d_id
#undef ___PH_LBL0
#define ___PH_LBL0 167
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_label_2d_id)
___DEF_P_HLBL(___L1___asm_23_asm_2d_label_2d_id)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_label_2d_id)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_label_2d_id)
___SET_R2(___FIX(2L))
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_label_2d_id)
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_label_2d_name
#undef ___PH_LBL0
#define ___PH_LBL0 170
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_label_2d_name)
___DEF_P_HLBL(___L1___asm_23_asm_2d_label_2d_name)
___DEF_P_HLBL(___L2___asm_23_asm_2d_label_2d_name)
___DEF_P_HLBL(___L3___asm_23_asm_2d_label_2d_name)
___DEF_P_HLBL(___L4___asm_23_asm_2d_label_2d_name)
___DEF_P_HLBL(___L5___asm_23_asm_2d_label_2d_name)
___DEF_P_HLBL(___L6___asm_23_asm_2d_label_2d_name)
___DEF_P_HLBL(___L7___asm_23_asm_2d_label_2d_name)
___DEF_P_HLBL(___L8___asm_23_asm_2d_label_2d_name)
___DEF_P_HLBL(___L9___asm_23_asm_2d_label_2d_name)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_label_2d_name)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_label_2d_name)
___SET_STK(1,___R0)
___SET_R2(___FIX(2L))
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_label_2d_name)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(2,___L2___asm_23_asm_2d_label_2d_name)
___SET_STK(-2,___R1)
___SET_R0(___LBL(3))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(1),111,___G_string_3f_)
___DEF_SLBL(3,___L3___asm_23_asm_2d_label_2d_name)
___IF(___NOTFALSEP(___R1))
___GOTO(___L12___asm_23_asm_2d_label_2d_name)
___END_IF
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(1),113,___G_symbol_3f_)
___DEF_SLBL(4,___L4___asm_23_asm_2d_label_2d_name)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L10___asm_23_asm_2d_label_2d_name)
___END_IF
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(5)
___DEF_SLBL(5,___L5___asm_23_asm_2d_label_2d_name)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(1),112,___G_symbol_2d__3e_string)
___DEF_GLBL(___L10___asm_23_asm_2d_label_2d_name)
___SET_R1(___STK(-6))
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(1),103,___G_number_3f_)
___DEF_SLBL(6,___L6___asm_23_asm_2d_label_2d_name)
___IF(___NOTFALSEP(___R1))
___GOTO(___L11___asm_23_asm_2d_label_2d_name)
___END_IF
___SET_R2(___STK(-6))
___SET_R1(___SUB(1))
___SET_R0(___STK(-7))
___POLL(7)
___DEF_SLBL(7,___L7___asm_23_asm_2d_label_2d_name)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),70,___G_c_23_compiler_2d_internal_2d_error)
___DEF_GLBL(___L11___asm_23_asm_2d_label_2d_name)
___SET_R1(___STK(-6))
___SET_R0(___LBL(8))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(1),102,___G_number_2d__3e_string)
___DEF_SLBL(8,___L8___asm_23_asm_2d_label_2d_name)
___SET_R2(___R1)
___SET_R1(___SUB(2))
___SET_R0(___STK(-3))
___POLL(9)
___DEF_SLBL(9,___L9___asm_23_asm_2d_label_2d_name)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),109,___G_string_2d_append)
___DEF_GLBL(___L12___asm_23_asm_2d_label_2d_name)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_label_2d_pos
#undef ___PH_LBL0
#define ___PH_LBL0 181
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_label_2d_pos)
___DEF_P_HLBL(___L1___asm_23_asm_2d_label_2d_pos)
___DEF_P_HLBL(___L2___asm_23_asm_2d_label_2d_pos)
___DEF_P_HLBL(___L3___asm_23_asm_2d_label_2d_pos)
___DEF_P_HLBL(___L4___asm_23_asm_2d_label_2d_pos)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_label_2d_pos)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_label_2d_pos)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___FIX(1L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_label_2d_pos)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(2,___L2___asm_23_asm_2d_label_2d_pos)
___IF(___NOTFALSEP(___R1))
___GOTO(___L5___asm_23_asm_2d_label_2d_pos)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(3))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(3,___L3___asm_23_asm_2d_label_2d_pos)
___SET_R2(___R1)
___SET_R1(___SUB(3))
___SET_R0(___STK(-3))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_label_2d_pos)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),70,___G_c_23_compiler_2d_internal_2d_error)
___DEF_GLBL(___L5___asm_23_asm_2d_label_2d_pos)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_align
#undef ___PH_LBL0
#define ___PH_LBL0 187
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_align)
___DEF_P_HLBL(___L1___asm_23_asm_2d_align)
___DEF_P_HLBL(___L2___asm_23_asm_2d_align)
___DEF_P_HLBL(___L3___asm_23_asm_2d_align)
___DEF_P_HLBL(___L4___asm_23_asm_2d_align)
___DEF_P_HLBL(___L5___asm_23_asm_2d_align)
___DEF_P_HLBL(___L6___asm_23_asm_2d_align)
___DEF_P_HLBL(___L7___asm_23_asm_2d_align)
___DEF_P_HLBL(___L8___asm_23_asm_2d_align)
___DEF_P_HLBL(___L9___asm_23_asm_2d_align)
___DEF_P_HLBL(___L10___asm_23_asm_2d_align)
___DEF_P_HLBL(___L11___asm_23_asm_2d_align)
___DEF_P_HLBL(___L12___asm_23_asm_2d_align)
___DEF_P_HLBL(___L13___asm_23_asm_2d_align)
___DEF_P_HLBL(___L14___asm_23_asm_2d_align)
___DEF_P_HLBL(___L15___asm_23_asm_2d_align)
___DEF_P_HLBL(___L16___asm_23_asm_2d_align)
___DEF_P_HLBL(___L17___asm_23_asm_2d_align)
___DEF_P_HLBL(___L18___asm_23_asm_2d_align)
___DEF_P_HLBL(___L19___asm_23_asm_2d_align)
___DEF_P_HLBL(___L20___asm_23_asm_2d_align)
___DEF_P_HLBL(___L21___asm_23_asm_2d_align)
___DEF_P_HLBL(___L22___asm_23_asm_2d_align)
___DEF_P_HLBL(___L23___asm_23_asm_2d_align)
___DEF_P_HLBL(___L24___asm_23_asm_2d_align)
___DEF_P_HLBL(___L25___asm_23_asm_2d_align)
___DEF_P_HLBL(___L26___asm_23_asm_2d_align)
___DEF_P_HLBL(___L27___asm_23_asm_2d_align)
___DEF_P_HLBL(___L28___asm_23_asm_2d_align)
___DEF_P_HLBL(___L29___asm_23_asm_2d_align)
___DEF_P_HLBL(___L30___asm_23_asm_2d_align)
___DEF_P_HLBL(___L31___asm_23_asm_2d_align)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_align)
___IF_NARGS_EQ(2,___PUSH(___R1) ___SET_R1(___R2) ___SET_R2(___FIX(0L)) ___SET_R3(___FIX(
0L)))
___IF_NARGS_EQ(3,___PUSH(___R1) ___SET_R1(___R2) ___SET_R2(___R3) ___SET_R3(___FIX(0L)
))
___IF_NARGS_EQ(4,___NOTHING)
___WRONG_NARGS(0,2,2,0)
___DEF_GLBL(___L___asm_23_asm_2d_align)
___SET_STK(1,___ALLOC_CLO(2UL))
___BEGIN_SETUP_CLO(2,___STK(1),27)
___ADD_CLO_ELEM(0,___R1)
___ADD_CLO_ELEM(1,___R2)
___END_SETUP_CLO(2)
___SET_STK(2,___ALLOC_CLO(3UL))
___BEGIN_SETUP_CLO(3,___STK(2),11)
___ADD_CLO_ELEM(0,___R3)
___ADD_CLO_ELEM(1,___R1)
___ADD_CLO_ELEM(2,___R2)
___END_SETUP_CLO(3)
___SET_R3(___STK(2))
___SET_R1(___STK(0))
___SET_R2(___STK(1))
___ADJFP(2)
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1___asm_23_asm_2d_align)
___POLL(2)
___DEF_SLBL(2,___L2___asm_23_asm_2d_align)
___ADJFP(-3)
___SET_NARGS(3) ___GOTO(___L3___asm_23_asm_2d_align)
___DEF_SLBL(3,___L3___asm_23_asm_2d_align)
___IF_NARGS_EQ(1,___SET_R2(___NUL))
___GET_REST(3,1,0,0)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R3(___FIX(0L))
___SET_R1(___SYM_deferred)
___ADJFP(8)
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_align)
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(3),118,___G_vector)
___DEF_SLBL(5,___L5___asm_23_asm_2d_align)
___SET_STK(-5,___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(6,___L6___asm_23_asm_2d_align)
___SET_STK(-6,___R1)
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(7,___L7___asm_23_asm_2d_align)
___SET_STK(-4,___R1)
___SET_R1(___STK(-5))
___SET_R2(___NUL)
___SET_R0(___LBL(8))
___JUMPGLONOTSAFE(___SET_NARGS(2),75,___G_cons)
___DEF_SLBL(8,___L8___asm_23_asm_2d_align)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-4))
___SET_R0(___LBL(9))
___JUMPGLONOTSAFE(___SET_NARGS(2),108,___G_set_2d_cdr_21_)
___DEF_SLBL(9,___L9___asm_23_asm_2d_align)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(10)
___DEF_SLBL(10,___L10___asm_23_asm_2d_align)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),107,___G_set_2d_car_21_)
___DEF_SLBL(11,___L11___asm_23_asm_2d_align)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(11,2,0,0)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R4)
___SET_STK(4,___R2)
___SET_R2(___CLO(___R4,3))
___SET_R1(___STK(4))
___ADJFP(8)
___POLL(12)
___DEF_SLBL(12,___L12___asm_23_asm_2d_align)
___SET_R0(___LBL(13))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(13,___L13___asm_23_asm_2d_align)
___SET_R2(___R1)
___SET_R1(___CLO(___STK(-5),2))
___SET_R0(___LBL(14))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(14,___L14___asm_23_asm_2d_align)
___SET_R2(___CLO(___STK(-5),2))
___SET_R0(___LBL(15))
___JUMPGLONOTSAFE(___SET_NARGS(2),89,___G_fxmodulo)
___DEF_SLBL(15,___L15___asm_23_asm_2d_align)
___SET_R3(___R1)
___SET_R2(___STK(-6))
___SET_R1(___CLO(___STK(-5),1))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(16)
___DEF_SLBL(16,___L16___asm_23_asm_2d_align)
___GOTO(___L32___asm_23_asm_2d_align)
___DEF_SLBL(17,___L17___asm_23_asm_2d_align)
___SET_R3(___R1)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(18)
___DEF_SLBL(18,___L18___asm_23_asm_2d_align)
___DEF_GLBL(___L32___asm_23_asm_2d_align)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R3)
___SET_R2(___FIX(0L))
___ADJFP(8)
___POLL(19)
___DEF_SLBL(19,___L19___asm_23_asm_2d_align)
___SET_R0(___LBL(20))
___JUMPGLONOTSAFE(___SET_NARGS(2),87,___G_fx_3e_)
___DEF_SLBL(20,___L20___asm_23_asm_2d_align)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L33___asm_23_asm_2d_align)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(256L))
___SET_R0(___LBL(21))
___JUMPGLONOTSAFE(___SET_NARGS(2),97,___G_modulo)
___DEF_SLBL(21,___L21___asm_23_asm_2d_align)
___SET_R2(___R1)
___SET_R1(___STK(-5))
___SET_R0(___LBL(22))
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___DEF_SLBL(22,___L22___asm_23_asm_2d_align)
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(23))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(23,___L23___asm_23_asm_2d_align)
___SET_STK(-4,___R1)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(24))
___JUMPGLONOTSAFE(___SET_NARGS(2),87,___G_fx_3e_)
___DEF_SLBL(24,___L24___asm_23_asm_2d_align)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L33___asm_23_asm_2d_align)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(256L))
___SET_R0(___LBL(25))
___JUMPGLONOTSAFE(___SET_NARGS(2),97,___G_modulo)
___DEF_SLBL(25,___L25___asm_23_asm_2d_align)
___SET_R2(___R1)
___SET_R1(___STK(-5))
___SET_R0(___LBL(26))
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___DEF_SLBL(26,___L26___asm_23_asm_2d_align)
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(17))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_GLBL(___L33___asm_23_asm_2d_align)
___SET_R1(___VOID)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_SLBL(27,___L27___asm_23_asm_2d_align)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(27,2,0,0)
___SET_STK(1,___R0)
___SET_STK(2,___R4)
___SET_STK(3,___R2)
___SET_R2(___CLO(___R4,2))
___SET_R1(___STK(3))
___ADJFP(8)
___POLL(28)
___DEF_SLBL(28,___L28___asm_23_asm_2d_align)
___SET_R0(___LBL(29))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(29,___L29___asm_23_asm_2d_align)
___SET_R2(___R1)
___SET_R1(___CLO(___STK(-6),1))
___SET_R0(___LBL(30))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(30,___L30___asm_23_asm_2d_align)
___SET_R2(___CLO(___STK(-6),1))
___SET_R0(___STK(-7))
___POLL(31)
___DEF_SLBL(31,___L31___asm_23_asm_2d_align)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),89,___G_fxmodulo)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_origin
#undef ___PH_LBL0
#define ___PH_LBL0 220
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L1___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L2___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L3___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L4___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L5___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L6___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L7___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L8___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L9___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L10___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L11___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L12___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L13___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L14___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L15___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L16___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L17___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L18___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L19___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L20___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L21___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L22___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L23___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L24___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L25___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L26___asm_23_asm_2d_origin)
___DEF_P_HLBL(___L27___asm_23_asm_2d_origin)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_origin)
___IF_NARGS_EQ(2,___SET_R3(___FIX(0L)))
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,2,1,0)
___DEF_GLBL(___L___asm_23_asm_2d_origin)
___SET_STK(1,___ALLOC_CLO(1UL))
___BEGIN_SETUP_CLO(1,___STK(1),26)
___ADD_CLO_ELEM(0,___R2)
___END_SETUP_CLO(1)
___SET_STK(2,___ALLOC_CLO(3UL))
___BEGIN_SETUP_CLO(3,___STK(2),11)
___ADD_CLO_ELEM(0,___R2)
___ADD_CLO_ELEM(1,___R1)
___ADD_CLO_ELEM(2,___R3)
___END_SETUP_CLO(3)
___SET_R3(___STK(2))
___SET_R2(___STK(1))
___ADJFP(2)
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1___asm_23_asm_2d_origin)
___POLL(2)
___DEF_SLBL(2,___L2___asm_23_asm_2d_origin)
___ADJFP(-2)
___SET_NARGS(3) ___GOTO(___L3___asm_23_asm_2d_origin)
___DEF_SLBL(3,___L3___asm_23_asm_2d_origin)
___IF_NARGS_EQ(1,___SET_R2(___NUL))
___GET_REST(3,1,0,0)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R3(___FIX(0L))
___SET_R1(___SYM_deferred)
___ADJFP(8)
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_origin)
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(3),118,___G_vector)
___DEF_SLBL(5,___L5___asm_23_asm_2d_origin)
___SET_STK(-5,___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(6,___L6___asm_23_asm_2d_origin)
___SET_STK(-6,___R1)
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(7,___L7___asm_23_asm_2d_origin)
___SET_STK(-4,___R1)
___SET_R1(___STK(-5))
___SET_R2(___NUL)
___SET_R0(___LBL(8))
___JUMPGLONOTSAFE(___SET_NARGS(2),75,___G_cons)
___DEF_SLBL(8,___L8___asm_23_asm_2d_origin)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-4))
___SET_R0(___LBL(9))
___JUMPGLONOTSAFE(___SET_NARGS(2),108,___G_set_2d_cdr_21_)
___DEF_SLBL(9,___L9___asm_23_asm_2d_origin)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(10)
___DEF_SLBL(10,___L10___asm_23_asm_2d_origin)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),107,___G_set_2d_car_21_)
___DEF_SLBL(11,___L11___asm_23_asm_2d_origin)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(11,1,0,0)
___SET_STK(1,___R0)
___SET_STK(2,___R4)
___SET_R2(___R1)
___SET_R1(___CLO(___R4,1))
___ADJFP(8)
___POLL(12)
___DEF_SLBL(12,___L12___asm_23_asm_2d_origin)
___SET_R0(___LBL(13))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(13,___L13___asm_23_asm_2d_origin)
___SET_STK(-5,___R1)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(14))
___JUMPGLONOTSAFE(___SET_NARGS(2),85,___G_fx_3c_)
___DEF_SLBL(14,___L14___asm_23_asm_2d_origin)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L28___asm_23_asm_2d_origin)
___END_IF
___SET_R1(___SUB(4))
___SET_R0(___STK(-7))
___POLL(15)
___DEF_SLBL(15,___L15___asm_23_asm_2d_origin)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(1),70,___G_c_23_compiler_2d_internal_2d_error)
___DEF_GLBL(___L28___asm_23_asm_2d_origin)
___SET_R3(___STK(-5))
___SET_R2(___CLO(___STK(-6),3))
___SET_R1(___CLO(___STK(-6),2))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(16)
___DEF_SLBL(16,___L16___asm_23_asm_2d_origin)
___GOTO(___L29___asm_23_asm_2d_origin)
___DEF_SLBL(17,___L17___asm_23_asm_2d_origin)
___SET_R3(___R1)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(18)
___DEF_SLBL(18,___L18___asm_23_asm_2d_origin)
___DEF_GLBL(___L29___asm_23_asm_2d_origin)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R3)
___SET_R2(___FIX(0L))
___ADJFP(8)
___POLL(19)
___DEF_SLBL(19,___L19___asm_23_asm_2d_origin)
___SET_R0(___LBL(20))
___JUMPGLONOTSAFE(___SET_NARGS(2),87,___G_fx_3e_)
___DEF_SLBL(20,___L20___asm_23_asm_2d_origin)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L30___asm_23_asm_2d_origin)
___END_IF
___SET_R1(___STK(-5))
___SET_R2(___FIX(256L))
___SET_R0(___LBL(21))
___JUMPGLONOTSAFE(___SET_NARGS(2),97,___G_modulo)
___DEF_SLBL(21,___L21___asm_23_asm_2d_origin)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(22))
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___DEF_SLBL(22,___L22___asm_23_asm_2d_origin)
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(23))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(23,___L23___asm_23_asm_2d_origin)
___SET_STK(-4,___R1)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(24))
___JUMPGLONOTSAFE(___SET_NARGS(2),87,___G_fx_3e_)
___DEF_SLBL(24,___L24___asm_23_asm_2d_origin)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L30___asm_23_asm_2d_origin)
___END_IF
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___LBL(25))
___JUMPINT(___SET_NARGS(2),___PRC(32),___L___asm_23_asm_2d_8)
___DEF_SLBL(25,___L25___asm_23_asm_2d_origin)
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(17))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_GLBL(___L30___asm_23_asm_2d_origin)
___SET_R1(___VOID)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_SLBL(26,___L26___asm_23_asm_2d_origin)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(26,1,0,0)
___SET_R2(___R1)
___SET_R1(___CLO(___R4,1))
___POLL(27)
___DEF_SLBL(27,___L27___asm_23_asm_2d_origin)
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_at_2d_assembly
#undef ___PH_LBL0
#define ___PH_LBL0 249
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_at_2d_assembly)
___DEF_P_HLBL(___L1___asm_23_asm_2d_at_2d_assembly)
___DEF_P_HLBL(___L2___asm_23_asm_2d_at_2d_assembly)
___DEF_P_HLBL(___L3___asm_23_asm_2d_at_2d_assembly)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_at_2d_assembly)
___IF_NARGS_EQ(1,___SET_R2(___NUL))
___GET_REST(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_at_2d_assembly)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R3(___FIX(0L))
___SET_R1(___SYM_deferred)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_at_2d_assembly)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(3),118,___G_vector)
___DEF_SLBL(2,___L2___asm_23_asm_2d_at_2d_assembly)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_at_2d_assembly)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_listing
#undef ___PH_LBL0
#define ___PH_LBL0 254
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_listing)
___DEF_P_HLBL(___L1___asm_23_asm_2d_listing)
___DEF_P_HLBL(___L2___asm_23_asm_2d_listing)
___DEF_P_HLBL(___L3___asm_23_asm_2d_listing)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_listing)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_listing)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___SYM_listing)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_listing)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),118,___G_vector)
___DEF_SLBL(2,___L2___asm_23_asm_2d_listing)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_listing)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(519),___L___asm_23_asm_2d_code_2d_extend)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_separated_2d_list
#undef ___PH_LBL0
#define ___PH_LBL0 259
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_separated_2d_list)
___DEF_P_HLBL(___L1___asm_23_asm_2d_separated_2d_list)
___DEF_P_HLBL(___L2___asm_23_asm_2d_separated_2d_list)
___DEF_P_HLBL(___L3___asm_23_asm_2d_separated_2d_list)
___DEF_P_HLBL(___L4___asm_23_asm_2d_separated_2d_list)
___DEF_P_HLBL(___L5___asm_23_asm_2d_separated_2d_list)
___DEF_P_HLBL(___L6___asm_23_asm_2d_separated_2d_list)
___DEF_P_HLBL(___L7___asm_23_asm_2d_separated_2d_list)
___DEF_P_HLBL(___L8___asm_23_asm_2d_separated_2d_list)
___DEF_P_HLBL(___L9___asm_23_asm_2d_separated_2d_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_separated_2d_list)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_separated_2d_list)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_separated_2d_list)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(1),104,___G_pair_3f_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_separated_2d_list)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L10___asm_23_asm_2d_separated_2d_list)
___END_IF
___SET_R1(___STK(-6))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(3,___L3___asm_23_asm_2d_separated_2d_list)
___SET_STK(-4,___R1)
___SET_STK(-3,___ALLOC_CLO(1UL))
___BEGIN_SETUP_CLO(1,___STK(-3),8)
___ADD_CLO_ELEM(0,___STK(-5))
___END_SETUP_CLO(1)
___SET_STK(-5,___STK(-3))
___SET_R1(___STK(-6))
___SET_R0(___LBL(5))
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4___asm_23_asm_2d_separated_2d_list)
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(5,___L5___asm_23_asm_2d_separated_2d_list)
___SET_R2(___R1)
___SET_R1(___STK(-5))
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(2),96,___G_map)
___DEF_SLBL(6,___L6___asm_23_asm_2d_separated_2d_list)
___SET_R2(___R1)
___SET_R0(___STK(-7))
___SET_R1(___STK(-4))
___POLL(7)
___DEF_SLBL(7,___L7___asm_23_asm_2d_separated_2d_list)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),75,___G_cons)
___DEF_SLBL(8,___L8___asm_23_asm_2d_separated_2d_list)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(8,1,0,0)
___SET_R2(___R1)
___SET_R1(___CLO(___R4,1))
___POLL(9)
___DEF_SLBL(9,___L9___asm_23_asm_2d_separated_2d_list)
___JUMPGLONOTSAFE(___SET_NARGS(2),93,___G_list)
___DEF_GLBL(___L10___asm_23_asm_2d_separated_2d_list)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_display_2d_listing
#undef ___PH_LBL0
#define ___PH_LBL0 270
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L1___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L2___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L3___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L4___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L5___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L6___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L7___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L8___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L9___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L10___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L11___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L12___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L13___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L14___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L15___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L16___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L17___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L18___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L19___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L20___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L21___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L22___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L23___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L24___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L25___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L26___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L27___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L28___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L29___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L30___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L31___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L32___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L33___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L34___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L35___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L36___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L37___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L38___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L39___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L40___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L41___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L42___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L43___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L44___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L45___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L46___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L47___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L48___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L49___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L50___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L51___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L52___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L53___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L54___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L55___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L56___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L57___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L58___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L59___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L60___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L61___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L62___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L63___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L64___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L65___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L66___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L67___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L68___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L69___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L70___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L71___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L72___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L73___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L74___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L75___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L76___asm_23_asm_2d_display_2d_listing)
___DEF_P_HLBL(___L77___asm_23_asm_2d_display_2d_listing)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_display_2d_listing)
___IF_NARGS_EQ(1,___SET_R2(___ABSENT) ___SET_R3(___FAL))
___IF_NARGS_EQ(2,___SET_R3(___FAL))
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,1,2,0)
___DEF_GLBL(___L___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___EQP(___R2,___ABSENT)))
___GOTO(___L78___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R3)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_display_2d_listing)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(0),76,___G_current_2d_output_2d_port)
___DEF_SLBL(2,___L2___asm_23_asm_2d_display_2d_listing)
___SET_R3(___STK(-5))
___SET_R0(___STK(-7))
___SET_STK(-7,___STK(-6))
___ADJFP(-7)
___GOTO(___L79___asm_23_asm_2d_display_2d_listing)
___DEF_GLBL(___L78___asm_23_asm_2d_display_2d_listing)
___SET_STK(1,___R1)
___SET_R1(___R2)
___ADJFP(1)
___DEF_GLBL(___L79___asm_23_asm_2d_display_2d_listing)
___SET_STK(1,___STK(0))
___SET_STK(0,___R3)
___SET_STK(2,___STK(1))
___SET_STK(1,___R1)
___SET_STK(3,___R0)
___SET_R1(___STK(2))
___SET_R2(___FIX(3L))
___ADJFP(7)
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_display_2d_listing)
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(4,___L4___asm_23_asm_2d_display_2d_listing)
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(5,___L5___asm_23_asm_2d_display_2d_listing)
___SET_STK(-3,___R1)
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(6,___L6___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R3(___FIX(0L))
___SET_R0(___STK(-4))
___SET_R1(___STK(-3))
___ADJFP(-6)
___POLL(7)
___DEF_SLBL(7,___L7___asm_23_asm_2d_display_2d_listing)
___GOTO(___L80___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(8,___L8___asm_23_asm_2d_display_2d_listing)
___SET_R3(___R1)
___SET_R0(___STK(-5))
___SET_R2(___STK(-3))
___SET_R1(___STK(-4))
___ADJFP(-6)
___POLL(9)
___DEF_SLBL(9,___L9___asm_23_asm_2d_display_2d_listing)
___DEF_GLBL(___L80___asm_23_asm_2d_display_2d_listing)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___ADJFP(10)
___POLL(10)
___DEF_SLBL(10,___L10___asm_23_asm_2d_display_2d_listing)
___SET_R0(___LBL(11))
___JUMPGLONOTSAFE(___SET_NARGS(1),104,___G_pair_3f_)
___DEF_SLBL(11,___L11___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L101___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R1(___STK(-8))
___SET_R0(___LBL(12))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(12,___L12___asm_23_asm_2d_display_2d_listing)
___SET_STK(-5,___R1)
___SET_R0(___LBL(13))
___JUMPGLONOTSAFE(___SET_NARGS(1),122,___G_vector_3f_)
___DEF_SLBL(13,___L13___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L99___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R1(___STK(-5))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(14))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(14,___L14___asm_23_asm_2d_display_2d_listing)
___SET_R2(___SYM_listing)
___SET_R0(___LBL(15))
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_SLBL(15,___L15___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L98___asm_23_asm_2d_display_2d_listing)
___END_IF
___IF(___NOT(___NOTFALSEP(___STK(-11))))
___GOTO(___L93___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(16))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(16,___L16___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L97___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R2(___STK(-7))
___SET_R1(___STK(-10))
___SET_R0(___LBL(46))
___GOTO(___L82___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(17,___L17___asm_23_asm_2d_display_2d_listing)
___DEF_GLBL(___L81___asm_23_asm_2d_display_2d_listing)
___SET_R2(___STK(-7))
___SET_R1(___STK(-10))
___SET_R0(___LBL(54))
___DEF_GLBL(___L82___asm_23_asm_2d_display_2d_listing)
___SET_R3(___FIX(6L))
___POLL(18)
___DEF_SLBL(18,___L18___asm_23_asm_2d_display_2d_listing)
___DEF_GLBL(___L83___asm_23_asm_2d_display_2d_listing)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R3)
___SET_R2(___FIX(0L))
___ADJFP(8)
___POLL(19)
___DEF_SLBL(19,___L19___asm_23_asm_2d_display_2d_listing)
___SET_R0(___LBL(20))
___JUMPGLONOTSAFE(___SET_NARGS(2),87,___G_fx_3e_)
___DEF_SLBL(20,___L20___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L89___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R1(___STK(-5))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(21))
___JUMPGLONOTSAFE(___SET_NARGS(2),85,___G_fx_3c_)
___DEF_SLBL(21,___L21___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L88___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(22))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(22,___L22___asm_23_asm_2d_display_2d_listing)
___SET_R3(___R1)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___LBL(23))
___GOTO(___L83___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(23,___L23___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-6))
___SET_R2(___SUB(5))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(24)
___DEF_SLBL(24,___L24___asm_23_asm_2d_display_2d_listing)
___GOTO(___L84___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(25,___L25___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(26)
___DEF_SLBL(26,___L26___asm_23_asm_2d_display_2d_listing)
___DEF_GLBL(___L84___asm_23_asm_2d_display_2d_listing)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___R2)
___ADJFP(8)
___POLL(27)
___DEF_SLBL(27,___L27___asm_23_asm_2d_display_2d_listing)
___SET_R0(___LBL(28))
___JUMPGLONOTSAFE(___SET_NARGS(1),101,___G_null_3f_)
___DEF_SLBL(28,___L28___asm_23_asm_2d_display_2d_listing)
___IF(___NOTFALSEP(___R1))
___GOTO(___L87___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R1(___STK(-5))
___SET_R0(___LBL(29))
___JUMPGLONOTSAFE(___SET_NARGS(1),104,___G_pair_3f_)
___DEF_SLBL(29,___L29___asm_23_asm_2d_display_2d_listing)
___IF(___NOTFALSEP(___R1))
___GOTO(___L86___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R2(___STK(-6))
___SET_R1(___STK(-5))
___SET_R0(___STK(-7))
___POLL(30)
___DEF_SLBL(30,___L30___asm_23_asm_2d_display_2d_listing)
___GOTO(___L85___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(31,___L31___asm_23_asm_2d_display_2d_listing)
___SET_R2(___STK(-6))
___SET_R0(___STK(-7))
___POLL(32)
___DEF_SLBL(32,___L32___asm_23_asm_2d_display_2d_listing)
___DEF_GLBL(___L85___asm_23_asm_2d_display_2d_listing)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),77,___G_display)
___DEF_GLBL(___L86___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-5))
___SET_R0(___LBL(33))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(33,___L33___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(34))
___GOTO(___L84___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(34,___L34___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-5))
___SET_R0(___LBL(25))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_GLBL(___L87___asm_23_asm_2d_display_2d_listing)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L88___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-5))
___SET_R2(___FIX(16L))
___SET_R0(___LBL(35))
___JUMPGLONOTSAFE(___SET_NARGS(2),90,___G_fxquotient)
___DEF_SLBL(35,___L35___asm_23_asm_2d_display_2d_listing)
___SET_STK(-3,___R1)
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(36))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(36,___L36___asm_23_asm_2d_display_2d_listing)
___SET_R3(___R1)
___SET_R1(___STK(-6))
___SET_R2(___STK(-3))
___SET_R0(___LBL(37))
___GOTO(___L83___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(37,___L37___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-5))
___SET_R2(___FIX(16L))
___SET_R0(___LBL(38))
___JUMPGLONOTSAFE(___SET_NARGS(2),89,___G_fxmodulo)
___DEF_SLBL(38,___L38___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R1(___SUB(6))
___SET_R0(___LBL(31))
___JUMPGLONOTSAFE(___SET_NARGS(2),110,___G_string_2d_ref)
___DEF_SLBL(39,___L39___asm_23_asm_2d_display_2d_listing)
___IF(___NOTFALSEP(___R1))
___GOTO(___L90___asm_23_asm_2d_display_2d_listing)
___END_IF
___DEF_GLBL(___L89___asm_23_asm_2d_display_2d_listing)
___SET_R1(___VOID)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L90___asm_23_asm_2d_display_2d_listing)
___SET_R1(___FIX(9L))
___SET_R0(___LBL(40))
___JUMPGLONOTSAFE(___SET_NARGS(1),92,___G_integer_2d__3e_char)
___DEF_SLBL(40,___L40___asm_23_asm_2d_display_2d_listing)
___SET_R2(___STK(-6))
___SET_R0(___LBL(41))
___JUMPGLONOTSAFE(___SET_NARGS(2),77,___G_display)
___DEF_SLBL(41,___L41___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-5))
___SET_R2(___FIX(8L))
___SET_R0(___LBL(42))
___JUMPGLONOTSAFE(___SET_NARGS(2),90,___G_fxquotient)
___DEF_SLBL(42,___L42___asm_23_asm_2d_display_2d_listing)
___SET_R2(___FIX(1L))
___SET_R0(___LBL(43))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(43,___L43___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R1(___FIX(8L))
___SET_R0(___LBL(44))
___JUMPGLONOTSAFE(___SET_NARGS(2),82,___G_fx_2a_)
___DEF_SLBL(44,___L44___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(45)
___DEF_SLBL(45,___L45___asm_23_asm_2d_display_2d_listing)
___GOTO(___L92___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(46,___L46___asm_23_asm_2d_display_2d_listing)
___SET_R1(___FIX(6L))
___DEF_GLBL(___L91___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R1(___STK(-10))
___SET_R0(___LBL(48))
___DEF_GLBL(___L92___asm_23_asm_2d_display_2d_listing)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___R2)
___SET_R2(___FIX(24L))
___ADJFP(8)
___POLL(47)
___DEF_SLBL(47,___L47___asm_23_asm_2d_display_2d_listing)
___SET_R0(___LBL(39))
___JUMPGLONOTSAFE(___SET_NARGS(2),85,___G_fx_3c_)
___DEF_SLBL(48,___L48___asm_23_asm_2d_display_2d_listing)
___DEF_GLBL(___L93___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(49))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(49,___L49___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(50))
___GOTO(___L84___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(50,___L50___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-6))
___SET_R0(___LBL(51))
___JUMPGLONOTSAFE(___SET_NARGS(1),99,___G_newline)
___DEF_SLBL(51,___L51___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-4))
___SET_R0(___LBL(52))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(52,___L52___asm_23_asm_2d_display_2d_listing)
___SET_R2(___STK(-3))
___SET_R3(___FIX(0L))
___SET_R0(___STK(-5))
___ADJFP(-6)
___POLL(53)
___DEF_SLBL(53,___L53___asm_23_asm_2d_display_2d_listing)
___GOTO(___L80___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(54,___L54___asm_23_asm_2d_display_2d_listing)
___SET_R2(___STK(-10))
___SET_R1(___SUB(7))
___SET_R0(___LBL(55))
___JUMPGLONOTSAFE(___SET_NARGS(2),77,___G_display)
___DEF_SLBL(55,___L55___asm_23_asm_2d_display_2d_listing)
___SET_R2(___STK(-5))
___SET_R1(___STK(-10))
___SET_R0(___LBL(67))
___ADJFP(-4)
___GOTO(___L94___asm_23_asm_2d_display_2d_listing)
___DEF_SLBL(56,___L56___asm_23_asm_2d_display_2d_listing)
___IF(___NOTFALSEP(___R1))
___GOTO(___L95___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R2(___STK(-5))
___SET_R1(___STK(-10))
___SET_R0(___LBL(64))
___DEF_GLBL(___L94___asm_23_asm_2d_display_2d_listing)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___R2)
___SET_R2(___FIX(16L))
___ADJFP(8)
___POLL(57)
___DEF_SLBL(57,___L57___asm_23_asm_2d_display_2d_listing)
___SET_R0(___LBL(58))
___JUMPGLONOTSAFE(___SET_NARGS(2),90,___G_fxquotient)
___DEF_SLBL(58,___L58___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R1(___SUB(6))
___SET_R0(___LBL(59))
___JUMPGLONOTSAFE(___SET_NARGS(2),110,___G_string_2d_ref)
___DEF_SLBL(59,___L59___asm_23_asm_2d_display_2d_listing)
___SET_R2(___STK(-6))
___SET_R0(___LBL(37))
___JUMPGLONOTSAFE(___SET_NARGS(2),77,___G_display)
___DEF_SLBL(60,___L60___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L96___asm_23_asm_2d_display_2d_listing)
___END_IF
___DEF_GLBL(___L95___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(61))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(61,___L61___asm_23_asm_2d_display_2d_listing)
___SET_R0(___LBL(62))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(62,___L62___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L81___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R1(___STK(-10))
___SET_R0(___LBL(17))
___JUMPGLONOTSAFE(___SET_NARGS(1),99,___G_newline)
___DEF_GLBL(___L96___asm_23_asm_2d_display_2d_listing)
___SET_R2(___FIX(2L))
___SET_R1(___FIX(24L))
___SET_R0(___LBL(63))
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___DEF_SLBL(63,___L63___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(56))
___JUMPGLONOTSAFE(___SET_NARGS(2),88,___G_fx_3e__3d_)
___DEF_SLBL(64,___L64___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-8))
___SET_R0(___LBL(65))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(65,___L65___asm_23_asm_2d_display_2d_listing)
___SET_STK(-8,___R1)
___SET_R1(___STK(-7))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(66))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(66,___L66___asm_23_asm_2d_display_2d_listing)
___SET_STK(-7,___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(8))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(67,___L67___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-4))
___SET_R0(___LBL(68))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(68,___L68___asm_23_asm_2d_display_2d_listing)
___SET_STK(-4,___R1)
___SET_R1(___STK(-3))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(69))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(69,___L69___asm_23_asm_2d_display_2d_listing)
___SET_STK(-3,___R1)
___SET_R2(___FIX(1L))
___SET_R1(___FIX(6L))
___SET_R0(___LBL(70))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(70,___L70___asm_23_asm_2d_display_2d_listing)
___SET_R2(___FIX(2L))
___SET_R0(___LBL(8))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_GLBL(___L97___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-6))
___GOTO(___L91___asm_23_asm_2d_display_2d_listing)
___DEF_GLBL(___L98___asm_23_asm_2d_display_2d_listing)
___SET_R1(___SUB(8))
___SET_R0(___STK(-9))
___POLL(71)
___DEF_SLBL(71,___L71___asm_23_asm_2d_display_2d_listing)
___ADJFP(-12)
___JUMPGLONOTSAFE(___SET_NARGS(1),70,___G_c_23_compiler_2d_internal_2d_error)
___DEF_GLBL(___L99___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-11))
___SET_R0(___LBL(72))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(72,___L72___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L100___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R1(___STK(-8))
___SET_R0(___LBL(73))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(73,___L73___asm_23_asm_2d_display_2d_listing)
___SET_STK(-8,___R1)
___SET_R1(___STK(-7))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(74))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(74,___L74___asm_23_asm_2d_display_2d_listing)
___SET_R2(___R1)
___SET_R3(___STK(-6))
___SET_R0(___STK(-9))
___SET_R1(___STK(-8))
___ADJFP(-10)
___POLL(75)
___DEF_SLBL(75,___L75___asm_23_asm_2d_display_2d_listing)
___GOTO(___L80___asm_23_asm_2d_display_2d_listing)
___DEF_GLBL(___L100___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(60))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_GLBL(___L101___asm_23_asm_2d_display_2d_listing)
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(76))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),87,___G_fx_3e_)
___DEF_SLBL(76,___L76___asm_23_asm_2d_display_2d_listing)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L102___asm_23_asm_2d_display_2d_listing)
___END_IF
___SET_R1(___STK(-6))
___SET_R0(___STK(-5))
___POLL(77)
___DEF_SLBL(77,___L77___asm_23_asm_2d_display_2d_listing)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(1),99,___G_newline)
___DEF_GLBL(___L102___asm_23_asm_2d_display_2d_listing)
___SET_R1(___VOID)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(3))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_assemble
#undef ___PH_LBL0
#define ___PH_LBL0 349
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L1___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L2___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L3___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L4___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L5___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L6___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L7___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L8___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L9___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L10___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L11___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L12___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L13___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L14___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L15___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L16___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L17___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L18___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L19___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L20___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L21___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L22___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L23___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L24___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L25___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L26___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L27___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L28___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L29___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L30___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L31___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L32___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L33___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L34___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L35___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L36___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L37___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L38___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L39___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L40___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L41___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L42___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L43___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L44___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L45___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L46___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L47___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L48___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L49___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L50___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L51___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L52___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L53___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L54___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L55___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L56___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L57___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L58___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L59___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L60___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L61___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L62___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L63___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L64___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L65___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L66___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L67___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L68___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L69___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L70___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L71___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L72___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L73___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L74___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L75___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L76___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L77___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L78___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L79___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L80___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L81___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L82___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L83___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L84___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L85___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L86___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L87___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L88___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L89___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L90___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L91___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L92___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L93___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L94___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L95___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L96___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L97___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L98___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L99___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L100___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L101___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L102___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L103___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L104___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L105___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L106___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L107___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L108___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L109___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L110___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L111___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L112___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L113___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L114___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L115___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L116___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L117___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L118___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L119___asm_23_asm_2d_assemble)
___DEF_P_HLBL(___L120___asm_23_asm_2d_assemble)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_assemble)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_assemble)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___FIX(3L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_assemble)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(2,___L2___asm_23_asm_2d_assemble)
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(3,___L3___asm_23_asm_2d_assemble)
___SET_STK(1,___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(4))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(4,___L4___asm_23_asm_2d_assemble)
___SET_R3(___R1)
___SET_R2(___FIX(0L))
___SET_R1(___NUL)
___SET_R0(___LBL(24))
___ADJFP(-3)
___GOTO(___L121___asm_23_asm_2d_assemble)
___DEF_SLBL(5,___L5___asm_23_asm_2d_assemble)
___SET_R3(___STK(-3))
___SET_R2(___FIX(0L))
___SET_R0(___STK(-6))
___ADJFP(-7)
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_assemble)
___DEF_GLBL(___L121___asm_23_asm_2d_assemble)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___STK(0))
___ADJFP(7)
___POLL(7)
___DEF_SLBL(7,___L7___asm_23_asm_2d_assemble)
___SET_R0(___LBL(8))
___JUMPGLONOTSAFE(___SET_NARGS(1),104,___G_pair_3f_)
___DEF_SLBL(8,___L8___asm_23_asm_2d_assemble)
___IF(___NOTFALSEP(___R1))
___GOTO(___L122___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-5))
___SET_R0(___STK(-6))
___POLL(9)
___DEF_SLBL(9,___L9___asm_23_asm_2d_assemble)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(1),106,___G_reverse)
___DEF_GLBL(___L122___asm_23_asm_2d_assemble)
___SET_R1(___STK(-7))
___SET_R0(___LBL(10))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(10,___L10___asm_23_asm_2d_assemble)
___SET_STK(-2,___R1)
___SET_R0(___LBL(11))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(1),122,___G_vector_3f_)
___DEF_SLBL(11,___L11___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L125___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(12))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(12,___L12___asm_23_asm_2d_assemble)
___SET_STK(-5,___R1)
___SET_R2(___SYM_label)
___SET_R0(___LBL(13))
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_SLBL(13,___L13___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L123___asm_23_asm_2d_assemble)
___END_IF
___SET_R3(___STK(-7))
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(14))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(14,___L14___asm_23_asm_2d_assemble)
___SET_R1(___STK(-7))
___SET_R0(___LBL(15))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(15,___L15___asm_23_asm_2d_assemble)
___SET_STK(-2,___STK(-7))
___SET_STK(-7,___R1)
___SET_R2(___STK(-2))
___SET_R1(___STK(-4))
___SET_R0(___LBL(16))
___JUMPGLONOTSAFE(___SET_NARGS(2),75,___G_cons)
___DEF_SLBL(16,___L16___asm_23_asm_2d_assemble)
___SET_R2(___STK(-5))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(2),75,___G_cons)
___DEF_GLBL(___L123___asm_23_asm_2d_assemble)
___SET_R1(___STK(-5))
___SET_R2(___SYM_deferred)
___SET_R0(___LBL(17))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_SLBL(17,___L17___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L124___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-7))
___SET_R0(___LBL(15))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_GLBL(___L124___asm_23_asm_2d_assemble)
___SET_R1(___STK(-7))
___SET_R0(___LBL(18))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(18,___L18___asm_23_asm_2d_assemble)
___SET_STK(-7,___R1)
___SET_R3(___STK(-3))
___SET_R2(___STK(-4))
___SET_R1(___STK(-5))
___SET_R0(___STK(-6))
___ADJFP(-7)
___POLL(19)
___DEF_SLBL(19,___L19___asm_23_asm_2d_assemble)
___GOTO(___L121___asm_23_asm_2d_assemble)
___DEF_GLBL(___L125___asm_23_asm_2d_assemble)
___SET_R1(___STK(-11))
___SET_R0(___LBL(20))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(20,___L20___asm_23_asm_2d_assemble)
___SET_STK(-7,___R1)
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(21))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(21,___L21___asm_23_asm_2d_assemble)
___SET_STK(-4,___R1)
___SET_R1(___STK(-3))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(22))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(22,___L22___asm_23_asm_2d_assemble)
___SET_R3(___R1)
___SET_R1(___STK(-5))
___SET_R0(___STK(-6))
___SET_R2(___STK(-4))
___ADJFP(-7)
___POLL(23)
___DEF_SLBL(23,___L23___asm_23_asm_2d_assemble)
___GOTO(___L121___asm_23_asm_2d_assemble)
___DEF_SLBL(24,___L24___asm_23_asm_2d_assemble)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(80))
___GOTO(___L126___asm_23_asm_2d_assemble)
___DEF_SLBL(25,___L25___asm_23_asm_2d_assemble)
___IF(___NOTFALSEP(___R1))
___GOTO(___L134___asm_23_asm_2d_assemble)
___END_IF
___IF(___NOT(___NOTFALSEP(___STK(-6))))
___GOTO(___L137___asm_23_asm_2d_assemble)
___END_IF
___SET_R2(___STK(-10))
___SET_R1(___STK(-11))
___SET_R0(___STK(-9))
___ADJFP(-12)
___POLL(26)
___DEF_SLBL(26,___L26___asm_23_asm_2d_assemble)
___DEF_GLBL(___L126___asm_23_asm_2d_assemble)
___SET_STK(1,___R1)
___SET_STK(2,___R2)
___SET_STK(3,___R0)
___SET_STK(4,___R2)
___SET_R2(___FIX(1L))
___ADJFP(8)
___POLL(27)
___DEF_SLBL(27,___L27___asm_23_asm_2d_assemble)
___SET_R0(___LBL(28))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(28,___L28___asm_23_asm_2d_assemble)
___SET_R2(___R1)
___SET_R1(___STK(-4))
___SET_R3(___FAL)
___SET_R0(___STK(-5))
___ADJFP(-6)
___POLL(29)
___DEF_SLBL(29,___L29___asm_23_asm_2d_assemble)
___GOTO(___L127___asm_23_asm_2d_assemble)
___DEF_SLBL(30,___L30___asm_23_asm_2d_assemble)
___SET_R2(___R1)
___SET_R3(___TRU)
___SET_R0(___STK(-3))
___SET_R1(___STK(-5))
___ADJFP(-6)
___POLL(31)
___DEF_SLBL(31,___L31___asm_23_asm_2d_assemble)
___DEF_GLBL(___L127___asm_23_asm_2d_assemble)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___ADJFP(10)
___POLL(32)
___DEF_SLBL(32,___L32___asm_23_asm_2d_assemble)
___SET_R0(___LBL(33))
___JUMPGLONOTSAFE(___SET_NARGS(1),104,___G_pair_3f_)
___DEF_SLBL(33,___L33___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L132___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-8))
___SET_R0(___LBL(34))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(34,___L34___asm_23_asm_2d_assemble)
___SET_STK(-5,___R1)
___SET_R0(___LBL(35))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(35,___L35___asm_23_asm_2d_assemble)
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(36))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(36,___L36___asm_23_asm_2d_assemble)
___SET_STK(-7,___R1)
___SET_R1(___STK(-5))
___SET_R0(___LBL(37))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(37,___L37___asm_23_asm_2d_assemble)
___SET_R0(___LBL(38))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(38,___L38___asm_23_asm_2d_assemble)
___SET_STK(-5,___R1)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(39))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(39,___L39___asm_23_asm_2d_assemble)
___SET_R2(___SYM_label)
___SET_R0(___LBL(40))
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_SLBL(40,___L40___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L128___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-8))
___SET_R0(___LBL(41))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(41,___L41___asm_23_asm_2d_assemble)
___SET_R3(___STK(-6))
___SET_R2(___STK(-7))
___SET_R0(___STK(-9))
___ADJFP(-10)
___POLL(42)
___DEF_SLBL(42,___L42___asm_23_asm_2d_assemble)
___GOTO(___L127___asm_23_asm_2d_assemble)
___DEF_GLBL(___L128___asm_23_asm_2d_assemble)
___SET_R1(___STK(-5))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(43))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(43,___L43___asm_23_asm_2d_assemble)
___SET_STK(-4,___STK(-9))
___SET_STK(-9,___STK(-8))
___SET_STK(-8,___STK(-6))
___SET_R3(___R1)
___SET_R2(___STK(-5))
___SET_R1(___STK(-7))
___SET_R0(___STK(-4))
___ADJFP(-8)
___POLL(44)
___DEF_SLBL(44,___L44___asm_23_asm_2d_assemble)
___GOTO(___L129___asm_23_asm_2d_assemble)
___DEF_SLBL(45,___L45___asm_23_asm_2d_assemble)
___SET_R3(___STK(-4))
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(46)
___DEF_SLBL(46,___L46___asm_23_asm_2d_assemble)
___DEF_GLBL(___L129___asm_23_asm_2d_assemble)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R2)
___SET_R2(___FIX(1L))
___ADJFP(8)
___POLL(47)
___DEF_SLBL(47,___L47___asm_23_asm_2d_assemble)
___SET_R0(___LBL(48))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(48,___L48___asm_23_asm_2d_assemble)
___SET_R0(___LBL(49))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(49,___L49___asm_23_asm_2d_assemble)
___SET_R2(___STK(-6))
___SET_STK(-3,___R1)
___SET_R1(___STK(-11))
___SET_R0(___LBL(50))
___JUMPGENNOTSAFE(___SET_NARGS(2),___STK(-3))
___DEF_SLBL(50,___L50___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L131___asm_23_asm_2d_assemble)
___END_IF
___SET_STK(-3,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-4))
___SET_R0(___LBL(51))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(51,___L51___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L130___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-9))
___SET_R0(___LBL(52))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(52,___L52___asm_23_asm_2d_assemble)
___SET_STK(-9,___R1)
___SET_R2(___STK(-4))
___SET_R1(___STK(-6))
___SET_R0(___LBL(53))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(53,___L53___asm_23_asm_2d_assemble)
___SET_R2(___R1)
___SET_R3(___STK(-4))
___SET_R0(___STK(-3))
___SET_R1(___STK(-5))
___ADJFP(-6)
___POLL(54)
___DEF_SLBL(54,___L54___asm_23_asm_2d_assemble)
___GOTO(___L127___asm_23_asm_2d_assemble)
___DEF_GLBL(___L130___asm_23_asm_2d_assemble)
___SET_R3(___STK(-3))
___SET_R1(___STK(-5))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(55))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(55,___L55___asm_23_asm_2d_assemble)
___SET_R1(___STK(-9))
___SET_R0(___LBL(56))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(56,___L56___asm_23_asm_2d_assemble)
___SET_STK(-9,___R1)
___SET_R2(___STK(-4))
___SET_R1(___STK(-6))
___SET_R0(___LBL(30))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_GLBL(___L131___asm_23_asm_2d_assemble)
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(57))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(57,___L57___asm_23_asm_2d_assemble)
___SET_R0(___LBL(58))
___JUMPGLONOTSAFE(___SET_NARGS(1),73,___G_cddr)
___DEF_SLBL(58,___L58___asm_23_asm_2d_assemble)
___SET_R3(___R1)
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(45))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_GLBL(___L132___asm_23_asm_2d_assemble)
___SET_R1(___STK(-11))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(59))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(59,___L59___asm_23_asm_2d_assemble)
___SET_R2(___R1)
___SET_R3(___STK(-6))
___SET_R1(___STK(-10))
___SET_R0(___STK(-9))
___ADJFP(-10)
___POLL(60)
___DEF_SLBL(60,___L60___asm_23_asm_2d_assemble)
___GOTO(___L133___asm_23_asm_2d_assemble)
___DEF_SLBL(61,___L61___asm_23_asm_2d_assemble)
___SET_R2(___STK(-3))
___SET_R3(___TRU)
___SET_R0(___STK(-5))
___ADJFP(-6)
___POLL(62)
___DEF_SLBL(62,___L62___asm_23_asm_2d_assemble)
___DEF_GLBL(___L133___asm_23_asm_2d_assemble)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___ADJFP(10)
___POLL(63)
___DEF_SLBL(63,___L63___asm_23_asm_2d_assemble)
___SET_R0(___LBL(25))
___JUMPGLONOTSAFE(___SET_NARGS(1),104,___G_pair_3f_)
___DEF_GLBL(___L134___asm_23_asm_2d_assemble)
___SET_R1(___STK(-8))
___SET_R0(___LBL(64))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(64,___L64___asm_23_asm_2d_assemble)
___SET_STK(-5,___R1)
___SET_R0(___LBL(65))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(65,___L65___asm_23_asm_2d_assemble)
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(66))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(66,___L66___asm_23_asm_2d_assemble)
___SET_STK(-7,___R1)
___SET_R1(___STK(-5))
___SET_R0(___LBL(67))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(67,___L67___asm_23_asm_2d_assemble)
___SET_R0(___LBL(68))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(68,___L68___asm_23_asm_2d_assemble)
___SET_STK(-5,___R1)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(69))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(69,___L69___asm_23_asm_2d_assemble)
___SET_R2(___SYM_label)
___SET_R0(___LBL(70))
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_SLBL(70,___L70___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L136___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(71))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(71,___L71___asm_23_asm_2d_assemble)
___SET_R2(___STK(-7))
___SET_R0(___LBL(72))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(72,___L72___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L135___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-8))
___SET_R0(___LBL(73))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(73,___L73___asm_23_asm_2d_assemble)
___SET_R3(___STK(-6))
___SET_R2(___STK(-7))
___SET_R0(___STK(-9))
___ADJFP(-10)
___POLL(74)
___DEF_SLBL(74,___L74___asm_23_asm_2d_assemble)
___GOTO(___L133___asm_23_asm_2d_assemble)
___DEF_GLBL(___L135___asm_23_asm_2d_assemble)
___SET_R3(___STK(-7))
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(75))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(75,___L75___asm_23_asm_2d_assemble)
___SET_R1(___STK(-4))
___SET_R0(___LBL(61))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_GLBL(___L136___asm_23_asm_2d_assemble)
___SET_R1(___STK(-5))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(76))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(76,___L76___asm_23_asm_2d_assemble)
___SET_STK(-5,___R1)
___SET_R1(___STK(-8))
___SET_R0(___LBL(77))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(77,___L77___asm_23_asm_2d_assemble)
___SET_STK(-8,___R1)
___SET_R2(___STK(-5))
___SET_R1(___STK(-7))
___SET_R0(___LBL(78))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(78,___L78___asm_23_asm_2d_assemble)
___SET_R2(___R1)
___SET_R3(___STK(-6))
___SET_R0(___STK(-9))
___SET_R1(___STK(-8))
___ADJFP(-10)
___POLL(79)
___DEF_SLBL(79,___L79___asm_23_asm_2d_assemble)
___GOTO(___L133___asm_23_asm_2d_assemble)
___DEF_GLBL(___L137___asm_23_asm_2d_assemble)
___SET_R1(___VOID)
___ADJFP(-12)
___JUMPPRM(___NOTHING,___STK(3))
___DEF_SLBL(80,___L80___asm_23_asm_2d_assemble)
___SET_STK(-5,___STK(-7))
___SET_STK(-7,___STK(-6))
___SET_R1(___STK(-6))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(81))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(81,___L81___asm_23_asm_2d_assemble)
___SET_STK(-4,___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(82))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(82,___L82___asm_23_asm_2d_assemble)
___SET_R0(___LBL(83))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(83,___L83___asm_23_asm_2d_assemble)
___SET_STK(-3,___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(84))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(84,___L84___asm_23_asm_2d_assemble)
___SET_R3(___R1)
___SET_R0(___STK(-5))
___SET_R2(___STK(-3))
___SET_R1(___STK(-4))
___ADJFP(-7)
___POLL(85)
___DEF_SLBL(85,___L85___asm_23_asm_2d_assemble)
___GOTO(___L138___asm_23_asm_2d_assemble)
___DEF_SLBL(86,___L86___asm_23_asm_2d_assemble)
___SET_R3(___STK(-7))
___SET_R2(___STK(-6))
___SET_R1(___STK(-9))
___SET_R0(___STK(-10))
___ADJFP(-11)
___POLL(87)
___DEF_SLBL(87,___L87___asm_23_asm_2d_assemble)
___DEF_GLBL(___L138___asm_23_asm_2d_assemble)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R2)
___ADJFP(7)
___POLL(88)
___DEF_SLBL(88,___L88___asm_23_asm_2d_assemble)
___SET_R0(___LBL(89))
___JUMPGLONOTSAFE(___SET_NARGS(1),104,___G_pair_3f_)
___DEF_SLBL(89,___L89___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L144___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-4))
___SET_R0(___LBL(90))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(90,___L90___asm_23_asm_2d_assemble)
___SET_STK(-2,___R1)
___SET_R1(___STK(-4))
___SET_R0(___LBL(91))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(91,___L91___asm_23_asm_2d_assemble)
___SET_STK(-5,___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(92))
___JUMPGLONOTSAFE(___SET_NARGS(1),122,___G_vector_3f_)
___DEF_SLBL(92,___L92___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L143___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(93))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(93,___L93___asm_23_asm_2d_assemble)
___SET_STK(-4,___R1)
___SET_R2(___SYM_label)
___SET_R0(___LBL(94))
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_SLBL(94,___L94___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L141___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(95))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(95,___L95___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L140___asm_23_asm_2d_assemble)
___END_IF
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(96))
___JUMPGLONOTSAFE(___SET_NARGS(2),86,___G_fx_3d_)
___DEF_SLBL(96,___L96___asm_23_asm_2d_assemble)
___SET_R0(___LBL(97))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(97,___L97___asm_23_asm_2d_assemble)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L139___asm_23_asm_2d_assemble)
___END_IF
___SET_R1(___SUB(9))
___SET_R0(___LBL(98))
___JUMPGLONOTSAFE(___SET_NARGS(1),70,___G_c_23_compiler_2d_internal_2d_error)
___DEF_SLBL(98,___L98___asm_23_asm_2d_assemble)
___DEF_GLBL(___L139___asm_23_asm_2d_assemble)
___SET_R2(___STK(-5))
___SET_R1(___STK(-9))
___SET_R0(___LBL(99))
___JUMPGLONOTSAFE(___SET_NARGS(2),108,___G_set_2d_cdr_21_)
___DEF_SLBL(99,___L99___asm_23_asm_2d_assemble)
___SET_R3(___STK(-7))
___SET_R2(___STK(-5))
___SET_R1(___STK(-9))
___SET_R0(___STK(-10))
___ADJFP(-11)
___POLL(100)
___DEF_SLBL(100,___L100___asm_23_asm_2d_assemble)
___GOTO(___L138___asm_23_asm_2d_assemble)
___DEF_GLBL(___L140___asm_23_asm_2d_assemble)
___SET_R3(___STK(-7))
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(98))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_GLBL(___L141___asm_23_asm_2d_assemble)
___SET_R1(___STK(-4))
___SET_R2(___SYM_deferred)
___SET_R0(___LBL(101))
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_SLBL(101,___L101___asm_23_asm_2d_assemble)
___IF(___NOTFALSEP(___R1))
___GOTO(___L142___asm_23_asm_2d_assemble)
___END_IF
___SET_R3(___STK(-7))
___SET_R2(___STK(-5))
___SET_R1(___STK(-8))
___SET_R0(___STK(-10))
___ADJFP(-11)
___POLL(102)
___DEF_SLBL(102,___L102___asm_23_asm_2d_assemble)
___GOTO(___L138___asm_23_asm_2d_assemble)
___DEF_GLBL(___L142___asm_23_asm_2d_assemble)
___SET_R1(___STK(-11))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(103))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(103,___L103___asm_23_asm_2d_assemble)
___SET_STK(-8,___R1)
___SET_R0(___LBL(104))
___JUMPINT(___SET_NARGS(0),___PRC(514),___L___asm_23_asm_2d_make_2d_stream)
___DEF_SLBL(104,___L104___asm_23_asm_2d_assemble)
___SET_R3(___R1)
___SET_R1(___STK(-11))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(105))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(105,___L105___asm_23_asm_2d_assemble)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(106))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(106,___L106___asm_23_asm_2d_assemble)
___SET_R0(___LBL(107))
___JUMPGLONOTSAFE(___SET_NARGS(1),71,___G_cadr)
___DEF_SLBL(107,___L107___asm_23_asm_2d_assemble)
___SET_R2(___STK(-7))
___SET_STK(-6,___R1)
___SET_R1(___STK(-11))
___SET_R0(___LBL(108))
___JUMPGENNOTSAFE(___SET_NARGS(2),___STK(-6))
___DEF_SLBL(108,___L108___asm_23_asm_2d_assemble)
___SET_R1(___STK(-11))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(109))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(109,___L109___asm_23_asm_2d_assemble)
___SET_R0(___LBL(110))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(110,___L110___asm_23_asm_2d_assemble)
___SET_R2(___STK(-5))
___SET_R0(___LBL(111))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),108,___G_set_2d_cdr_21_)
___DEF_SLBL(111,___L111___asm_23_asm_2d_assemble)
___SET_R1(___STK(-7))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(112))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(112,___L112___asm_23_asm_2d_assemble)
___SET_R0(___LBL(113))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(113,___L113___asm_23_asm_2d_assemble)
___SET_STK(-2,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-5))
___SET_R0(___LBL(114))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(2),108,___G_set_2d_cdr_21_)
___DEF_SLBL(114,___L114___asm_23_asm_2d_assemble)
___SET_R3(___STK(-8))
___SET_R1(___STK(-11))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(86))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_GLBL(___L143___asm_23_asm_2d_assemble)
___SET_R1(___STK(-7))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(115))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(115,___L115___asm_23_asm_2d_assemble)
___SET_R3(___R1)
___SET_R2(___STK(-5))
___SET_R1(___STK(-8))
___SET_R0(___STK(-10))
___ADJFP(-11)
___POLL(116)
___DEF_SLBL(116,___L116___asm_23_asm_2d_assemble)
___GOTO(___L138___asm_23_asm_2d_assemble)
___DEF_GLBL(___L144___asm_23_asm_2d_assemble)
___SET_R1(___STK(-7))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(117))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(117,___L117___asm_23_asm_2d_assemble)
___SET_R2(___STK(-5))
___SET_R0(___LBL(118))
___JUMPGLONOTSAFE(___SET_NARGS(2),107,___G_set_2d_car_21_)
___DEF_SLBL(118,___L118___asm_23_asm_2d_assemble)
___SET_R1(___STK(-7))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(119))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(119,___L119___asm_23_asm_2d_assemble)
___SET_R2(___R1)
___SET_R1(___STK(-3))
___SET_R0(___STK(-6))
___POLL(120)
___DEF_SLBL(120,___L120___asm_23_asm_2d_assemble)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),84,___G_fx_2d_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_assemble_2d_to_2d_file
#undef ___PH_LBL0
#define ___PH_LBL0 471
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L1___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L2___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L3___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L4___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L5___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L6___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L7___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L8___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L9___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L10___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L11___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L12___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L13___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L14___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L15___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L16___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L17___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L18___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_P_HLBL(___L19___asm_23_asm_2d_assemble_2d_to_2d_file)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_assemble_2d_to_2d_file)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(1),___PRC(349),___L___asm_23_asm_2d_assemble)
___DEF_SLBL(2,___L2___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_STK(-4,___ALLOC_CLO(1UL))
___BEGIN_SETUP_CLO(1,___STK(-4),5)
___ADD_CLO_ELEM(0,___STK(-6))
___END_SETUP_CLO(1)
___SET_R2(___STK(-4))
___SET_R1(___STK(-5))
___SET_R0(___STK(-7))
___ADJFP(-4)
___CHECK_HEAP(3,4096)
___DEF_SLBL(3,___L3___asm_23_asm_2d_assemble_2d_to_2d_file)
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_assemble_2d_to_2d_file)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),123,___G_with_2d_output_2d_to_2d_file)
___DEF_SLBL(5,___L5___asm_23_asm_2d_assemble_2d_to_2d_file)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(5,0,0,0)
___SET_STK(1,___R0)
___SET_R1(___CLO(___R4,1))
___SET_R2(___FIX(3L))
___ADJFP(4)
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(7,___L7___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R0(___LBL(8))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(8,___L8___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R0(___STK(-3))
___ADJFP(-4)
___POLL(9)
___DEF_SLBL(9,___L9___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___ADJFP(8)
___POLL(10)
___DEF_SLBL(10,___L10___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R0(___LBL(11))
___JUMPGLONOTSAFE(___SET_NARGS(1),104,___G_pair_3f_)
___DEF_SLBL(11,___L11___asm_23_asm_2d_assemble_2d_to_2d_file)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L22___asm_23_asm_2d_assemble_2d_to_2d_file)
___END_IF
___SET_R1(___STK(-6))
___SET_R0(___LBL(12))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(12,___L12___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_STK(-5,___R1)
___SET_R0(___LBL(13))
___JUMPGLONOTSAFE(___SET_NARGS(1),122,___G_vector_3f_)
___DEF_SLBL(13,___L13___asm_23_asm_2d_assemble_2d_to_2d_file)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L21___asm_23_asm_2d_assemble_2d_to_2d_file)
___END_IF
___SET_R1(___STK(-5))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(14))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(14,___L14___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R2(___SYM_listing)
___SET_R0(___LBL(15))
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_SLBL(15,___L15___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R0(___LBL(16))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(16,___L16___asm_23_asm_2d_assemble_2d_to_2d_file)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L20___asm_23_asm_2d_assemble_2d_to_2d_file)
___END_IF
___SET_R1(___SUB(10))
___SET_R0(___LBL(17))
___JUMPGLONOTSAFE(___SET_NARGS(1),70,___G_c_23_compiler_2d_internal_2d_error)
___DEF_SLBL(17,___L17___asm_23_asm_2d_assemble_2d_to_2d_file)
___DEF_GLBL(___L20___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R1(___STK(-6))
___SET_R0(___LBL(8))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_GLBL(___L21___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R1(___STK(-5))
___SET_R0(___LBL(18))
___JUMPGLONOTSAFE(___SET_NARGS(1),92,___G_integer_2d__3e_char)
___DEF_SLBL(18,___L18___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R0(___LBL(19))
___JUMPGLONOTSAFE(___SET_NARGS(1),125,___G_write_2d_char)
___DEF_SLBL(19,___L19___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R1(___STK(-6))
___SET_R0(___LBL(8))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_GLBL(___L22___asm_23_asm_2d_assemble_2d_to_2d_file)
___SET_R1(___VOID)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector
#undef ___PH_LBL0
#define ___PH_LBL0 492
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L1___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L2___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L3___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L4___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L5___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L6___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L7___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L8___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L9___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L10___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L11___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L12___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L13___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L14___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L15___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L16___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L17___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L18___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L19___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_P_HLBL(___L20___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(1),___PRC(349),___L___asm_23_asm_2d_assemble)
___DEF_SLBL(2,___L2___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),94,___G_make_2d_u8vector)
___DEF_SLBL(3,___L3___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_STK(-5,___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(3L))
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(4,___L4___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(5,___L5___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R2(___R1)
___SET_R1(___STK(-5))
___SET_R3(___FIX(0L))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___GOTO(___L21___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_SLBL(7,___L7___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R2(___R1)
___SET_R3(___STK(-4))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(8)
___DEF_SLBL(8,___L8___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_GLBL(___L21___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R2)
___ADJFP(8)
___POLL(9)
___DEF_SLBL(9,___L9___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R0(___LBL(10))
___JUMPGLONOTSAFE(___SET_NARGS(1),104,___G_pair_3f_)
___DEF_SLBL(10,___L10___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L24___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___END_IF
___SET_R1(___STK(-5))
___SET_R0(___LBL(11))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(11,___L11___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_STK(-3,___R1)
___SET_R0(___LBL(12))
___JUMPGLONOTSAFE(___SET_NARGS(1),122,___G_vector_3f_)
___DEF_SLBL(12,___L12___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L23___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___END_IF
___SET_R1(___STK(-3))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(13))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(13,___L13___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R2(___SYM_listing)
___SET_R0(___LBL(14))
___JUMPGLONOTSAFE(___SET_NARGS(2),78,___G_eq_3f_)
___DEF_SLBL(14,___L14___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R0(___LBL(15))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(15,___L15___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L22___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___END_IF
___SET_R1(___SUB(11))
___SET_R0(___LBL(16))
___JUMPGLONOTSAFE(___SET_NARGS(1),70,___G_c_23_compiler_2d_internal_2d_error)
___DEF_SLBL(16,___L16___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_GLBL(___L22___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R1(___STK(-5))
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_GLBL(___L23___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R3(___STK(-3))
___SET_R2(___STK(-4))
___SET_R1(___STK(-6))
___SET_R0(___LBL(17))
___JUMPGLONOTSAFE(___SET_NARGS(3),117,___G_u8vector_2d_set_21_)
___DEF_SLBL(17,___L17___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R1(___STK(-5))
___SET_R0(___LBL(18))
___JUMPGLONOTSAFE(___SET_NARGS(1),74,___G_cdr)
___DEF_SLBL(18,___L18___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_STK(-5,___R1)
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(19))
___JUMPGLONOTSAFE(___SET_NARGS(2),83,___G_fx_2b_)
___DEF_SLBL(19,___L19___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R3(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___SET_R2(___STK(-5))
___ADJFP(-8)
___POLL(20)
___DEF_SLBL(20,___L20___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___GOTO(___L21___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___DEF_GLBL(___L24___asm_23_asm_2d_assemble_2d_to_2d_u8vector)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_make_2d_stream
#undef ___PH_LBL0
#define ___PH_LBL0 514
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_make_2d_stream)
___DEF_P_HLBL(___L1___asm_23_asm_2d_make_2d_stream)
___DEF_P_HLBL(___L2___asm_23_asm_2d_make_2d_stream)
___DEF_P_HLBL(___L3___asm_23_asm_2d_make_2d_stream)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_make_2d_stream)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(0,0,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_make_2d_stream)
___SET_STK(1,___R0)
___SET_R2(___NUL)
___SET_R1(___NUL)
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_make_2d_stream)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),75,___G_cons)
___DEF_SLBL(2,___L2___asm_23_asm_2d_make_2d_stream)
___SET_STK(-2,___R1)
___SET_R2(___R1)
___SET_R0(___LBL(3))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(2),107,___G_set_2d_car_21_)
___DEF_SLBL(3,___L3___asm_23_asm_2d_make_2d_stream)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_code_2d_extend
#undef ___PH_LBL0
#define ___PH_LBL0 519
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_code_2d_extend)
___DEF_P_HLBL(___L1___asm_23_asm_2d_code_2d_extend)
___DEF_P_HLBL(___L2___asm_23_asm_2d_code_2d_extend)
___DEF_P_HLBL(___L3___asm_23_asm_2d_code_2d_extend)
___DEF_P_HLBL(___L4___asm_23_asm_2d_code_2d_extend)
___DEF_P_HLBL(___L5___asm_23_asm_2d_code_2d_extend)
___DEF_P_HLBL(___L6___asm_23_asm_2d_code_2d_extend)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_code_2d_extend)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_code_2d_extend)
___SET_STK(1,___R0)
___SET_STK(2,___R2)
___SET_R2(___FIX(3L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_code_2d_extend)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(2,___L2___asm_23_asm_2d_code_2d_extend)
___SET_STK(-5,___R1)
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(1),72,___G_car)
___DEF_SLBL(3,___L3___asm_23_asm_2d_code_2d_extend)
___SET_STK(-4,___R1)
___SET_R1(___STK(-6))
___SET_R2(___NUL)
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(2),75,___G_cons)
___DEF_SLBL(4,___L4___asm_23_asm_2d_code_2d_extend)
___SET_STK(-6,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-4))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(2),108,___G_set_2d_cdr_21_)
___DEF_SLBL(5,___L5___asm_23_asm_2d_code_2d_extend)
___SET_R2(___STK(-6))
___SET_R1(___STK(-5))
___SET_R0(___STK(-7))
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_code_2d_extend)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),107,___G_set_2d_car_21_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_signed8_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 527
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_signed8_3f_)
___DEF_P_HLBL(___L1___asm_23_asm_2d_signed8_3f_)
___DEF_P_HLBL(___L2___asm_23_asm_2d_signed8_3f_)
___DEF_P_HLBL(___L3___asm_23_asm_2d_signed8_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_signed8_3f_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_signed8_3f_)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___R1)
___SET_R1(___FIX(-128L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_signed8_3f_)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),67,___G__3c__3d_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_signed8_3f_)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L4___asm_23_asm_2d_signed8_3f_)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(127L))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_signed8_3f_)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),67,___G__3c__3d_)
___DEF_GLBL(___L4___asm_23_asm_2d_signed8_3f_)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_signed16_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 532
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_signed16_3f_)
___DEF_P_HLBL(___L1___asm_23_asm_2d_signed16_3f_)
___DEF_P_HLBL(___L2___asm_23_asm_2d_signed16_3f_)
___DEF_P_HLBL(___L3___asm_23_asm_2d_signed16_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_signed16_3f_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_signed16_3f_)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___R1)
___SET_R1(___FIX(-32768L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_signed16_3f_)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),67,___G__3c__3d_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_signed16_3f_)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L4___asm_23_asm_2d_signed16_3f_)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(32767L))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_signed16_3f_)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),67,___G__3c__3d_)
___DEF_GLBL(___L4___asm_23_asm_2d_signed16_3f_)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_signed32_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 537
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_signed32_3f_)
___DEF_P_HLBL(___L1___asm_23_asm_2d_signed32_3f_)
___DEF_P_HLBL(___L2___asm_23_asm_2d_signed32_3f_)
___DEF_P_HLBL(___L3___asm_23_asm_2d_signed32_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_signed32_3f_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_signed32_3f_)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___R1)
___SET_R1(___BIGFIX(12,-2147483648LL))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_signed32_3f_)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),67,___G__3c__3d_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_signed32_3f_)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L4___asm_23_asm_2d_signed32_3f_)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___BIGFIX(13,2147483647LL))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_signed32_3f_)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),67,___G__3c__3d_)
___DEF_GLBL(___L4___asm_23_asm_2d_signed32_3f_)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_signed_2d_lo8
#undef ___PH_LBL0
#define ___PH_LBL0 542
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_signed_2d_lo8)
___DEF_P_HLBL(___L1___asm_23_asm_2d_signed_2d_lo8)
___DEF_P_HLBL(___L2___asm_23_asm_2d_signed_2d_lo8)
___DEF_P_HLBL(___L3___asm_23_asm_2d_signed_2d_lo8)
___DEF_P_HLBL(___L4___asm_23_asm_2d_signed_2d_lo8)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_signed_2d_lo8)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_signed_2d_lo8)
___SET_STK(1,___R0)
___SET_R2(___FIX(128L))
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_signed_2d_lo8)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_signed_2d_lo8)
___SET_R2(___FIX(255L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),69,___G_bitwise_2d_and)
___DEF_SLBL(3,___L3___asm_23_asm_2d_signed_2d_lo8)
___SET_R2(___FIX(128L))
___SET_R0(___STK(-3))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_signed_2d_lo8)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_unsigned_2d_lo8
#undef ___PH_LBL0
#define ___PH_LBL0 548
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo8)
___DEF_P_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo8)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_unsigned_2d_lo8)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_unsigned_2d_lo8)
___SET_R2(___FIX(255L))
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_unsigned_2d_lo8)
___JUMPGLONOTSAFE(___SET_NARGS(2),69,___G_bitwise_2d_and)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_signed_2d_lo16
#undef ___PH_LBL0
#define ___PH_LBL0 551
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_signed_2d_lo16)
___DEF_P_HLBL(___L1___asm_23_asm_2d_signed_2d_lo16)
___DEF_P_HLBL(___L2___asm_23_asm_2d_signed_2d_lo16)
___DEF_P_HLBL(___L3___asm_23_asm_2d_signed_2d_lo16)
___DEF_P_HLBL(___L4___asm_23_asm_2d_signed_2d_lo16)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_signed_2d_lo16)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_signed_2d_lo16)
___SET_STK(1,___R0)
___SET_R2(___FIX(32768L))
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_signed_2d_lo16)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_signed_2d_lo16)
___SET_R2(___FIX(65535L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),69,___G_bitwise_2d_and)
___DEF_SLBL(3,___L3___asm_23_asm_2d_signed_2d_lo16)
___SET_R2(___FIX(32768L))
___SET_R0(___STK(-3))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_signed_2d_lo16)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_unsigned_2d_lo16
#undef ___PH_LBL0
#define ___PH_LBL0 557
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo16)
___DEF_P_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo16)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_unsigned_2d_lo16)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_unsigned_2d_lo16)
___SET_R2(___FIX(65535L))
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_unsigned_2d_lo16)
___JUMPGLONOTSAFE(___SET_NARGS(2),69,___G_bitwise_2d_and)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_signed_2d_lo32
#undef ___PH_LBL0
#define ___PH_LBL0 560
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_signed_2d_lo32)
___DEF_P_HLBL(___L1___asm_23_asm_2d_signed_2d_lo32)
___DEF_P_HLBL(___L2___asm_23_asm_2d_signed_2d_lo32)
___DEF_P_HLBL(___L3___asm_23_asm_2d_signed_2d_lo32)
___DEF_P_HLBL(___L4___asm_23_asm_2d_signed_2d_lo32)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_signed_2d_lo32)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_signed_2d_lo32)
___SET_STK(1,___R0)
___SET_R2(___BIGFIX(14,2147483648LL))
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_signed_2d_lo32)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_signed_2d_lo32)
___SET_R2(___BIGFIX(15,4294967295LL))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),69,___G_bitwise_2d_and)
___DEF_SLBL(3,___L3___asm_23_asm_2d_signed_2d_lo32)
___SET_R2(___BIGFIX(14,2147483648LL))
___SET_R0(___STK(-3))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_signed_2d_lo32)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_unsigned_2d_lo32
#undef ___PH_LBL0
#define ___PH_LBL0 566
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo32)
___DEF_P_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo32)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_unsigned_2d_lo32)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_unsigned_2d_lo32)
___SET_R2(___BIGFIX(15,4294967295LL))
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_unsigned_2d_lo32)
___JUMPGLONOTSAFE(___SET_NARGS(2),69,___G_bitwise_2d_and)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_signed_2d_lo64
#undef ___PH_LBL0
#define ___PH_LBL0 569
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_signed_2d_lo64)
___DEF_P_HLBL(___L1___asm_23_asm_2d_signed_2d_lo64)
___DEF_P_HLBL(___L2___asm_23_asm_2d_signed_2d_lo64)
___DEF_P_HLBL(___L3___asm_23_asm_2d_signed_2d_lo64)
___DEF_P_HLBL(___L4___asm_23_asm_2d_signed_2d_lo64)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_signed_2d_lo64)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_signed_2d_lo64)
___SET_STK(1,___R0)
___SET_R2(___SUB(16))
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_signed_2d_lo64)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_signed_2d_lo64)
___SET_R2(___SUB(17))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),69,___G_bitwise_2d_and)
___DEF_SLBL(3,___L3___asm_23_asm_2d_signed_2d_lo64)
___SET_R2(___SUB(16))
___SET_R0(___STK(-3))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_signed_2d_lo64)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_unsigned_2d_lo64
#undef ___PH_LBL0
#define ___PH_LBL0 575
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo64)
___DEF_P_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo64)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_unsigned_2d_lo64)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_unsigned_2d_lo64)
___SET_R2(___SUB(17))
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_unsigned_2d_lo64)
___JUMPGLONOTSAFE(___SET_NARGS(2),69,___G_bitwise_2d_and)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_signed_2d_lo
#undef ___PH_LBL0
#define ___PH_LBL0 578
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_signed_2d_lo)
___DEF_P_HLBL(___L1___asm_23_asm_2d_signed_2d_lo)
___DEF_P_HLBL(___L2___asm_23_asm_2d_signed_2d_lo)
___DEF_P_HLBL(___L3___asm_23_asm_2d_signed_2d_lo)
___DEF_P_HLBL(___L4___asm_23_asm_2d_signed_2d_lo)
___DEF_P_HLBL(___L5___asm_23_asm_2d_signed_2d_lo)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_signed_2d_lo)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_signed_2d_lo)
___BEGIN_SWITCH_FIXNUM(___R2)
___SWITCH_FIXNUM_CASE_GOTO(___FIX(8L),___L9___asm_23_asm_2d_signed_2d_lo)
___SWITCH_FIXNUM_CASE_GOTO(___FIX(16L),___L8___asm_23_asm_2d_signed_2d_lo)
___SWITCH_FIXNUM_CASE_GOTO(___FIX(32L),___L7___asm_23_asm_2d_signed_2d_lo)
___SWITCH_FIXNUM_CASE_GOTO(___FIX(64L),___L6___asm_23_asm_2d_signed_2d_lo)
___END_SWITCH_FIXNUM
___SET_R1(___SUB(18))
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_signed_2d_lo)
___JUMPGLONOTSAFE(___SET_NARGS(2),79,___G_error)
___DEF_GLBL(___L6___asm_23_asm_2d_signed_2d_lo)
___POLL(2)
___DEF_SLBL(2,___L2___asm_23_asm_2d_signed_2d_lo)
___JUMPINT(___SET_NARGS(1),___PRC(569),___L___asm_23_asm_2d_signed_2d_lo64)
___DEF_GLBL(___L7___asm_23_asm_2d_signed_2d_lo)
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_signed_2d_lo)
___JUMPINT(___SET_NARGS(1),___PRC(560),___L___asm_23_asm_2d_signed_2d_lo32)
___DEF_GLBL(___L8___asm_23_asm_2d_signed_2d_lo)
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_signed_2d_lo)
___JUMPINT(___SET_NARGS(1),___PRC(551),___L___asm_23_asm_2d_signed_2d_lo16)
___DEF_GLBL(___L9___asm_23_asm_2d_signed_2d_lo)
___POLL(5)
___DEF_SLBL(5,___L5___asm_23_asm_2d_signed_2d_lo)
___JUMPINT(___SET_NARGS(1),___PRC(542),___L___asm_23_asm_2d_signed_2d_lo8)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_unsigned_2d_lo
#undef ___PH_LBL0
#define ___PH_LBL0 585
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_unsigned_2d_lo)
___DEF_P_HLBL(___L1___asm_23_asm_2d_unsigned_2d_lo)
___DEF_P_HLBL(___L2___asm_23_asm_2d_unsigned_2d_lo)
___DEF_P_HLBL(___L3___asm_23_asm_2d_unsigned_2d_lo)
___DEF_P_HLBL(___L4___asm_23_asm_2d_unsigned_2d_lo)
___DEF_P_HLBL(___L5___asm_23_asm_2d_unsigned_2d_lo)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_unsigned_2d_lo)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_unsigned_2d_lo)
___BEGIN_SWITCH_FIXNUM(___R2)
___SWITCH_FIXNUM_CASE_GOTO(___FIX(8L),___L10___asm_23_asm_2d_unsigned_2d_lo)
___SWITCH_FIXNUM_CASE_GOTO(___FIX(16L),___L9___asm_23_asm_2d_unsigned_2d_lo)
___SWITCH_FIXNUM_CASE_GOTO(___FIX(32L),___L7___asm_23_asm_2d_unsigned_2d_lo)
___SWITCH_FIXNUM_CASE_GOTO(___FIX(64L),___L6___asm_23_asm_2d_unsigned_2d_lo)
___END_SWITCH_FIXNUM
___SET_R1(___SUB(19))
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_unsigned_2d_lo)
___JUMPGLONOTSAFE(___SET_NARGS(2),79,___G_error)
___DEF_GLBL(___L6___asm_23_asm_2d_unsigned_2d_lo)
___SET_R2(___SUB(17))
___POLL(2)
___DEF_SLBL(2,___L2___asm_23_asm_2d_unsigned_2d_lo)
___GOTO(___L8___asm_23_asm_2d_unsigned_2d_lo)
___DEF_GLBL(___L7___asm_23_asm_2d_unsigned_2d_lo)
___SET_R2(___BIGFIX(15,4294967295LL))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_unsigned_2d_lo)
___DEF_GLBL(___L8___asm_23_asm_2d_unsigned_2d_lo)
___JUMPGLONOTSAFE(___SET_NARGS(2),69,___G_bitwise_2d_and)
___DEF_GLBL(___L9___asm_23_asm_2d_unsigned_2d_lo)
___SET_R2(___FIX(65535L))
___POLL(4)
___DEF_SLBL(4,___L4___asm_23_asm_2d_unsigned_2d_lo)
___GOTO(___L8___asm_23_asm_2d_unsigned_2d_lo)
___DEF_GLBL(___L10___asm_23_asm_2d_unsigned_2d_lo)
___SET_R2(___FIX(255L))
___POLL(5)
___DEF_SLBL(5,___L5___asm_23_asm_2d_unsigned_2d_lo)
___GOTO(___L8___asm_23_asm_2d_unsigned_2d_lo)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_bits_2d_0_2d_to_2d_7
#undef ___PH_LBL0
#define ___PH_LBL0 592
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
___DEF_P_HLBL(___L1___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
___SET_R2(___FIX(256L))
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_bits_2d_0_2d_to_2d_7)
___JUMPGLONOTSAFE(___SET_NARGS(2),97,___G_modulo)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_bits_2d_8_2d_and_2d_up
#undef ___PH_LBL0
#define ___PH_LBL0 595
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_P_HLBL(___L1___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_P_HLBL(___L2___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_P_HLBL(___L3___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_P_HLBL(___L4___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_P_HLBL(___L5___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___DEF_P_HLBL(___L6___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___FIX(0L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),68,___G__3e__3d_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L7___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(256L))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),105,___G_quotient)
___DEF_GLBL(___L7___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(4))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(4,___L4___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___SET_R2(___FIX(256L))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(2),105,___G_quotient)
___DEF_SLBL(5,___L5___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___SET_R2(___FIX(1L))
___SET_R0(___STK(-3))
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_bits_2d_8_2d_and_2d_up)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_bits_2d_16_2d_and_2d_up
#undef ___PH_LBL0
#define ___PH_LBL0 603
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_P_HLBL(___L1___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_P_HLBL(___L2___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_P_HLBL(___L3___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_P_HLBL(___L4___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_P_HLBL(___L5___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___DEF_P_HLBL(___L6___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___FIX(0L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),68,___G__3e__3d_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L7___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___FIX(65536L))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),105,___G_quotient)
___DEF_GLBL(___L7___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(4))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(4,___L4___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___SET_R2(___FIX(65536L))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(2),105,___G_quotient)
___DEF_SLBL(5,___L5___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___SET_R2(___FIX(1L))
___SET_R0(___STK(-3))
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_bits_2d_16_2d_and_2d_up)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_bits_2d_32_2d_and_2d_up
#undef ___PH_LBL0
#define ___PH_LBL0 611
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_P_HLBL(___L1___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_P_HLBL(___L2___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_P_HLBL(___L3___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_P_HLBL(___L4___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_P_HLBL(___L5___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___DEF_P_HLBL(___L6___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___FIX(0L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),68,___G__3e__3d_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L7___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___BIGFIX(20,4294967296LL))
___SET_R0(___STK(-7))
___POLL(3)
___DEF_SLBL(3,___L3___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),105,___G_quotient)
___DEF_GLBL(___L7___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(4))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(4,___L4___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___SET_R2(___BIGFIX(20,4294967296LL))
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(2),105,___G_quotient)
___DEF_SLBL(5,___L5___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___SET_R2(___FIX(1L))
___SET_R0(___STK(-3))
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_bits_2d_32_2d_and_2d_up)
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format
#undef ___PH_LBL0
#define ___PH_LBL0 619
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L1___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L2___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L3___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L4___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L5___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L6___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L7___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L8___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L9___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L10___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L11___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L12___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L13___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L14___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L15___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L16___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L17___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L18___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L19___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L20___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L21___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L22___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L23___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L24___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L25___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L26___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L27___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L28___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L29___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L30___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L31___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L32___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L33___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L34___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L35___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L36___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L37___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L38___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L39___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L40___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L41___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L42___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L43___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L44___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L45___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L46___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L47___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L48___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L49___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L50___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L51___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_P_HLBL(___L52___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R2)))
___GOTO(___L53___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___SET_R2(___FIX(11L))
___GOTO(___L54___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_GLBL(___L53___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___FIX(8L))
___DEF_GLBL(___L54___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___R2)
___SET_R2(___FIX(1L))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(2,___L2___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___FIX(2L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),81,___G_expt)
___DEF_SLBL(3,___L3___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___FIX(1L))
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(4,___L4___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-5,___R1)
___SET_R2(___STK(-6))
___SET_R1(___GLO___asm_23_asm_2d_inexact_2d__2b_1)
___SET_R0(___LBL(52))
___GOTO(___L55___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_SLBL(5,___L5___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L57___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___SET_R1(___STK(-6))
___SET_R2(___GLO___asm_23_asm_2d_inexact_2d__2b_1)
___SET_R0(___LBL(10))
___DEF_GLBL(___L55___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___R2)
___ADJFP(8)
___POLL(6)
___DEF_SLBL(6,___L6___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(1),98,___G_negative_3f_)
___DEF_SLBL(7,___L7___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L56___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___POLL(8)
___DEF_SLBL(8,___L8___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(1),64,___G__2d_)
___DEF_GLBL(___L56___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L57___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___STK(-6))
___SET_R1(___STK(-5))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(9)
___DEF_SLBL(9,___L9___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___GOTO(___L58___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_SLBL(10,___L10___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___STK(-5))
___SET_R0(___LBL(51))
___ADJFP(-4)
___DEF_GLBL(___L58___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___R2)
___SET_R2(___GLO___asm_23_asm_2d_inexact_2d__2b_1)
___ADJFP(8)
___POLL(11)
___DEF_SLBL(11,___L11___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(12))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(12,___L12___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L65___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___SET_STK(-3,___STK(-6))
___SET_R1(___STK(-5))
___SET_R3(___FIX(1L))
___SET_R2(___GLO___asm_23_asm_2d_inexact_2d__2b_1_2f_2)
___SET_R0(___LBL(29))
___ADJFP(-3)
___GOTO(___L59___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_SLBL(13,___L13___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R3(___STK(-6))
___SET_R1(___STK(-9))
___SET_R0(___LBL(19))
___ADJFP(-3)
___DEF_GLBL(___L59___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R2(___R3)
___SET_R1(___R3)
___ADJFP(7)
___POLL(14)
___DEF_SLBL(14,___L14___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(15))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(15,___L15___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-2,___R1)
___SET_R1(___STK(-7))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(16))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(16,___L16___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(17))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(17,___L17___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L60___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___SET_R2(___STK(-8))
___SET_R1(___STK(-9))
___SET_R0(___LBL(18))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(18,___L18___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L60___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___SET_STK(-3,___STK(-11))
___SET_R2(___STK(-8))
___SET_R1(___STK(-8))
___SET_R0(___LBL(13))
___JUMPGLONOTSAFE(___SET_NARGS(2),62,___G__2a_)
___DEF_GLBL(___L60___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R1(___STK(-9))
___SET_R3(___FIX(1L))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(19))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(3),118,___G_vector)
___DEF_SLBL(19,___L19___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-5,___R1)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(20))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(20,___L20___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-2,___R1)
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(21))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(21,___L21___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(22))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(22,___L22___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-7,___R1)
___SET_R1(___STK(-11))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(23))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(23,___L23___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(24))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(24,___L24___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOTFALSEP(___R1))
___GOTO(___L64___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___GOTO(___L61___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_SLBL(25,___L25___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOTFALSEP(___R1))
___GOTO(___L63___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___DEF_GLBL(___L61___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___ADJFP(-4)
___DEF_GLBL(___L62___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R1(___STK(-5))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(2))
___DEF_GLBL(___L63___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___STK(-8))
___SET_R1(___STK(-6))
___SET_R0(___LBL(26))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),65,___G__2f_)
___DEF_SLBL(26,___L26___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R3(___R1)
___SET_R1(___STK(-5))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(27))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(27,___L27___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R3(___STK(-3))
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(28))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(28,___L28___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___GOTO(___L62___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_GLBL(___L64___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___STK(-8))
___SET_R1(___STK(-6))
___SET_R0(___LBL(25))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(29,___L29___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-2,___R1)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(30))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(30,___L30___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___GLO___asm_23_asm_2d_inexact_2d__2b_2)
___SET_R0(___LBL(31))
___JUMPGLONOTSAFE(___SET_NARGS(2),62,___G__2a_)
___DEF_SLBL(31,___L31___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R3(___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(32))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(32,___L32___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(33))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(33,___L33___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___FIX(-1L))
___SET_R0(___LBL(34))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(34,___L34___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R3(___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(35))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(35,___L35___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L65___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-4,___STK(-7))
___SET_STK(-7,___STK(-6))
___SET_R1(___STK(-5))
___SET_R3(___FIX(1L))
___SET_R2(___GLO___asm_23_asm_2d_inexact_2d__2b_2)
___SET_R0(___STK(-4))
___ADJFP(-7)
___POLL(36)
___DEF_SLBL(36,___L36___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___GOTO(___L66___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_SLBL(37,___L37___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R3(___STK(-6))
___SET_R1(___STK(-9))
___SET_R0(___LBL(44))
___ADJFP(-3)
___DEF_GLBL(___L66___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R2(___R3)
___SET_R1(___R3)
___ADJFP(7)
___POLL(38)
___DEF_SLBL(38,___L38___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(39))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(39,___L39___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-2,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(40))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(40,___L40___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(41))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(41,___L41___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L67___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___SET_R2(___STK(-8))
___SET_R1(___STK(-9))
___SET_R0(___LBL(42))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(42,___L42___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(43))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(43,___L43___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L67___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___SET_STK(-3,___STK(-11))
___SET_R2(___STK(-8))
___SET_R1(___STK(-8))
___SET_R0(___LBL(37))
___JUMPGLONOTSAFE(___SET_NARGS(2),62,___G__2a_)
___DEF_GLBL(___L67___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R1(___STK(-9))
___SET_R3(___FIX(1L))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(44))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(3),118,___G_vector)
___DEF_SLBL(44,___L44___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-5,___R1)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(45))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(45,___L45___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-2,___R1)
___SET_R1(___STK(-5))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(46))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(46,___L46___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(47))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(47,___L47___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-7,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-11))
___SET_R0(___LBL(48))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(48,___L48___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(49))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(49,___L49___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L61___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___END_IF
___SET_R2(___STK(-8))
___SET_R1(___STK(-6))
___SET_R0(___LBL(50))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(50,___L50___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(25))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(51,___L51___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_STK(-2,___R1)
___SET_R3(___FIX(-1L))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(35))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(52,___L52___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(1),98,___G_negative_3f_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format
#undef ___PH_LBL0
#define ___PH_LBL0 673
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L1___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L2___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L3___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L4___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L5___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L6___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L7___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L8___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L9___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L10___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L11___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L12___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L13___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L14___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L15___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L16___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L17___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L18___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L19___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L20___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L21___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_P_HLBL(___L22___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_STK(1,___R0)
___SET_STK(2,___R2)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(619),___L___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format)
___DEF_SLBL(2,___L2___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___STK(-6))))
___GOTO(___L23___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___END_IF
___SET_R2(___FIX(52L))
___IF(___NOTFALSEP(___STK(-6)))
___GOTO(___L24___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___END_IF
___GOTO(___L28___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_GLBL(___L23___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R2(___FIX(23L))
___IF(___NOT(___NOTFALSEP(___STK(-6))))
___GOTO(___L28___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___END_IF
___DEF_GLBL(___L24___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R3(___FIX(11L))
___DEF_GLBL(___L25___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_STK(-6,___R1)
___SET_STK(-5,___R2)
___SET_STK(-4,___R3)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(3,___L3___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_STK(-3,___R1)
___SET_R2(___GLO___asm_23_asm_2d_inexact_2d__2b_2)
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(4,___L4___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R0(___LBL(5))
___JUMPGLONOTSAFE(___SET_NARGS(1),100,___G_not)
___DEF_SLBL(5,___L5___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L27___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___END_IF
___SET_R2(___STK(-3))
___SET_R1(___GLO___asm_23_asm_2d_inexact_2d__2b_0)
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(6,___L6___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L26___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___END_IF
___SET_R2(___STK(-5))
___SET_R1(___FIX(2L))
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(2),81,___G_expt)
___DEF_SLBL(7,___L7___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R3(___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(8))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(8,___L8___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(9))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(9,___L9___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___FIX(2L))
___SET_R0(___LBL(10))
___JUMPGLONOTSAFE(___SET_NARGS(2),81,___G_expt)
___DEF_SLBL(10,___L10___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R3(___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(11))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(11,___L11___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(12))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(12,___L12___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R2(___STK(-5))
___SET_R0(___LBL(13))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(13,___L13___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R3(___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(14))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_SLBL(14,___L14___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L26___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R2(___STK(-5))
___SET_R1(___FIX(2L))
___SET_R0(___LBL(15))
___JUMPGLONOTSAFE(___SET_NARGS(2),81,___G_expt)
___DEF_SLBL(15,___L15___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R2(___FIX(2L))
___SET_R0(___LBL(16))
___JUMPGLONOTSAFE(___SET_NARGS(2),62,___G__2a_)
___DEF_SLBL(16,___L16___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R2(___FIX(1L))
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_GLBL(___L27___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(17))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(17,___L17___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_STK(-4,___R1)
___SET_R2(___STK(-5))
___SET_R1(___FIX(2L))
___SET_R0(___LBL(18))
___JUMPGLONOTSAFE(___SET_NARGS(2),81,___G_expt)
___DEF_SLBL(18,___L18___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R0(___LBL(19))
___JUMPGLONOTSAFE(___SET_NARGS(1),80,___G_exact_2d__3e_inexact)
___DEF_SLBL(19,___L19___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R2(___R1)
___SET_R1(___STK(-4))
___SET_R0(___LBL(20))
___JUMPGLONOTSAFE(___SET_NARGS(2),62,___G__2a_)
___DEF_SLBL(20,___L20___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R0(___LBL(21))
___JUMPGLONOTSAFE(___SET_NARGS(1),91,___G_inexact_2d__3e_exact)
___DEF_SLBL(21,___L21___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R0(___LBL(22))
___JUMPGLONOTSAFE(___SET_NARGS(1),114,___G_truncate)
___DEF_SLBL(22,___L22___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R3(___R1)
___SET_R1(___STK(-6))
___SET_R2(___FIX(0L))
___SET_R0(___LBL(11))
___JUMPGLONOTSAFE(___SET_NARGS(3),121,___G_vector_2d_set_21_)
___DEF_GLBL(___L28___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___SET_R3(___FIX(8L))
___GOTO(___L25___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H___asm_23_asm_2d_float_2d__3e_bits
#undef ___PH_LBL0
#define ___PH_LBL0 697
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L1___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L2___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L3___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L4___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L5___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L6___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L7___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L8___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L9___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L10___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L11___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L12___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L13___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L14___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L15___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L16___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L17___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L18___asm_23_asm_2d_float_2d__3e_bits)
___DEF_P_HLBL(___L19___asm_23_asm_2d_float_2d__3e_bits)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___asm_23_asm_2d_float_2d__3e_bits)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L___asm_23_asm_2d_float_2d__3e_bits)
___IF(___NOT(___NOTFALSEP(___R2)))
___GOTO(___L20___asm_23_asm_2d_float_2d__3e_bits)
___END_IF
___SET_R3(___FIX(52L))
___IF(___NOTFALSEP(___R2))
___GOTO(___L21___asm_23_asm_2d_float_2d__3e_bits)
___END_IF
___GOTO(___L26___asm_23_asm_2d_float_2d__3e_bits)
___DEF_GLBL(___L20___asm_23_asm_2d_float_2d__3e_bits)
___SET_R3(___FIX(23L))
___IF(___NOT(___NOTFALSEP(___R2)))
___GOTO(___L26___asm_23_asm_2d_float_2d__3e_bits)
___END_IF
___DEF_GLBL(___L21___asm_23_asm_2d_float_2d__3e_bits)
___SET_R4(___FIX(11L))
___DEF_GLBL(___L22___asm_23_asm_2d_float_2d__3e_bits)
___SET_STK(1,___R0)
___SET_STK(2,___R3)
___SET_STK(3,___R4)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1___asm_23_asm_2d_float_2d__3e_bits)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(673),___L___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format)
___DEF_SLBL(2,___L2___asm_23_asm_2d_float_2d__3e_bits)
___SET_STK(-4,___R1)
___SET_R2(___FIX(0L))
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(3,___L3___asm_23_asm_2d_float_2d__3e_bits)
___SET_STK(-3,___R1)
___SET_R1(___STK(-4))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(4))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(4,___L4___asm_23_asm_2d_float_2d__3e_bits)
___SET_STK(-2,___R1)
___SET_R2(___STK(-6))
___SET_R1(___FIX(2L))
___SET_R0(___LBL(5))
___ADJFP(4)
___JUMPGLONOTSAFE(___SET_NARGS(2),81,___G_expt)
___DEF_SLBL(5,___L5___asm_23_asm_2d_float_2d__3e_bits)
___SET_STK(-5,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(6))
___JUMPGLONOTSAFE(___SET_NARGS(2),66,___G__3c_)
___DEF_SLBL(6,___L6___asm_23_asm_2d_float_2d__3e_bits)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L25___asm_23_asm_2d_float_2d__3e_bits)
___END_IF
___SET_R1(___STK(-7))
___ADJFP(-4)
___GOTO(___L23___asm_23_asm_2d_float_2d__3e_bits)
___DEF_SLBL(7,___L7___asm_23_asm_2d_float_2d__3e_bits)
___DEF_GLBL(___L23___asm_23_asm_2d_float_2d__3e_bits)
___SET_STK(-3,___R1)
___SET_R1(___STK(-4))
___SET_R2(___FIX(2L))
___SET_R0(___LBL(8))
___JUMPGLONOTSAFE(___SET_NARGS(2),120,___G_vector_2d_ref)
___DEF_SLBL(8,___L8___asm_23_asm_2d_float_2d__3e_bits)
___SET_R0(___LBL(9))
___JUMPGLONOTSAFE(___SET_NARGS(1),98,___G_negative_3f_)
___DEF_SLBL(9,___L9___asm_23_asm_2d_float_2d__3e_bits)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L24___asm_23_asm_2d_float_2d__3e_bits)
___END_IF
___SET_R2(___STK(-6))
___SET_R1(___STK(-5))
___SET_R0(___LBL(10))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(10,___L10___asm_23_asm_2d_float_2d__3e_bits)
___SET_R2(___R1)
___SET_R1(___FIX(2L))
___SET_R0(___LBL(11))
___JUMPGLONOTSAFE(___SET_NARGS(2),81,___G_expt)
___DEF_SLBL(11,___L11___asm_23_asm_2d_float_2d__3e_bits)
___SET_R2(___STK(-3))
___SET_R0(___STK(-7))
___POLL(12)
___DEF_SLBL(12,___L12___asm_23_asm_2d_float_2d__3e_bits)
___ADJFP(-8)
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_GLBL(___L24___asm_23_asm_2d_float_2d__3e_bits)
___SET_R1(___STK(-3))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L25___asm_23_asm_2d_float_2d__3e_bits)
___SET_R2(___STK(-5))
___SET_R1(___STK(-7))
___SET_R0(___LBL(13))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(13,___L13___asm_23_asm_2d_float_2d__3e_bits)
___SET_STK(-7,___R1)
___SET_R2(___STK(-10))
___SET_R1(___STK(-6))
___SET_R0(___LBL(14))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(14,___L14___asm_23_asm_2d_float_2d__3e_bits)
___SET_STK(-6,___R1)
___SET_R1(___STK(-9))
___SET_R2(___FIX(1L))
___SET_R0(___LBL(15))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(15,___L15___asm_23_asm_2d_float_2d__3e_bits)
___SET_R2(___R1)
___SET_R1(___FIX(2L))
___SET_R0(___LBL(16))
___JUMPGLONOTSAFE(___SET_NARGS(2),81,___G_expt)
___DEF_SLBL(16,___L16___asm_23_asm_2d_float_2d__3e_bits)
___SET_R2(___FIX(1L))
___SET_R0(___LBL(17))
___JUMPGLONOTSAFE(___SET_NARGS(2),64,___G__2d_)
___DEF_SLBL(17,___L17___asm_23_asm_2d_float_2d__3e_bits)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(18))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_SLBL(18,___L18___asm_23_asm_2d_float_2d__3e_bits)
___SET_R2(___STK(-5))
___SET_R0(___LBL(19))
___ADJFP(-4)
___JUMPGLONOTSAFE(___SET_NARGS(2),62,___G__2a_)
___DEF_SLBL(19,___L19___asm_23_asm_2d_float_2d__3e_bits)
___SET_R2(___R1)
___SET_R1(___STK(-3))
___SET_R0(___LBL(7))
___JUMPGLONOTSAFE(___SET_NARGS(2),63,___G__2b_)
___DEF_GLBL(___L26___asm_23_asm_2d_float_2d__3e_bits)
___SET_R4(___FIX(8L))
___GOTO(___L22___asm_23_asm_2d_float_2d__3e_bits)
___END_P_SW
___END_P_COD
___END_M_SW
___END_M_COD
___BEGIN_LBL
___DEF_LBL_INTRO(___H___asm_23_,"_asm#",___REF_FAL,8,0)
,___DEF_LBL_PROC(___H___asm_23_,0,-1)
,___DEF_LBL_RET(___H___asm_23_,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_make_2d_code_2d_block,"_asm#asm-make-code-block",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_make_2d_code_2d_block,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_make_2d_code_2d_block,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_make_2d_code_2d_block,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_make_2d_code_2d_block,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_init_2d_code_2d_block,"_asm#asm-init-code-block",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_init_2d_code_2d_block,3,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_init_2d_code_2d_block,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_init_2d_code_2d_block,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_init_2d_code_2d_block,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_init_2d_code_2d_block,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_init_2d_code_2d_block,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_copy_2d_code_2d_block,"_asm#asm-copy-code-block",___REF_FAL,9,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_copy_2d_code_2d_block,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_copy_2d_code_2d_block,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_copy_2d_code_2d_block,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_copy_2d_code_2d_block,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_copy_2d_code_2d_block,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_copy_2d_code_2d_block,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_copy_2d_code_2d_block,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_copy_2d_code_2d_block,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_copy_2d_code_2d_block,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_8,"_asm#asm-8",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_8,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_8,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_8,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_8,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_16,"_asm#asm-16",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_16,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_16,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_16_2d_be,"_asm#asm-16-be",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_16_2d_be,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_be,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_be,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_be,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_be,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_be,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_16_2d_le,"_asm#asm-16-le",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_16_2d_le,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_le,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_le,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_le,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_le,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_16_2d_le,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_32,"_asm#asm-32",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_32,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_32,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_32,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_32,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_32,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_32_2d_be,"_asm#asm-32-be",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_32_2d_be,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_32_2d_be,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_32_2d_be,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_32_2d_be,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_32_2d_be,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_32_2d_le,"_asm#asm-32-le",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_32_2d_le,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_32_2d_le,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_32_2d_le,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_32_2d_le,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_32_2d_le,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_64,"_asm#asm-64",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_64,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_64,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_64,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_64,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_64,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_64_2d_be,"_asm#asm-64-be",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_64_2d_be,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_64_2d_be,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_64_2d_be,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_64_2d_be,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_64_2d_be,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_64_2d_le,"_asm#asm-64-le",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_64_2d_le,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_64_2d_le,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_64_2d_le,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_64_2d_le,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_64_2d_le,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_int,"_asm#asm-int",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_int,3,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_int,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_int_2d_be,"_asm#asm-int-be",___REF_FAL,10,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_int_2d_be,3,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_be,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_be,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_be,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_be,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_be,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_be,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_be,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_be,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_be,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_int_2d_le,"_asm#asm-int-le",___REF_FAL,10,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_int_2d_le,3,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_le,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_le,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_le,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_le,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_le,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_le,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_le,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_le,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_int_2d_le,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_f32,"_asm#asm-f32",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_f32,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_f32,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_f32,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_f32,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_f64,"_asm#asm-f64",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_f64,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_f64,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_f64,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_f64,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_UTF_2d_8_2d_string,"_asm#asm-UTF-8-string",___REF_FAL,16,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_UTF_2d_8_2d_string,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETN,5,1,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETI,8,1,0x3f1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_PROC(___H___asm_23_asm_2d_UTF_2d_8_2d_string,0,1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_UTF_2d_8_2d_string,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_make_2d_label,"_asm#asm-make-label",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_make_2d_label,3,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_make_2d_label,___IFD(___RETI,1,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_label_3f_,"_asm#asm-label?",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_label_3f_,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_3f_,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_3f_,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_3f_,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_3f_,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_3f_,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_3f_,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_label,"_asm#asm-label",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_label,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_label,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_label_2d_id,"_asm#asm-label-id",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_label_2d_id,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_id,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_label_2d_name,"_asm#asm-label-name",___REF_FAL,10,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_label_2d_name,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_name,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_name,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_name,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_name,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_name,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_name,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_name,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_name,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_name,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_label_2d_pos,"_asm#asm-label-pos",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_label_2d_pos,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_pos,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_pos,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_pos,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_label_2d_pos,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_align,"_asm#asm-align",___REF_FAL,32,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_align,4,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,3,4,0x3f2L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,3,4,0x3f2L))
,___DEF_LBL_PROC(___H___asm_23_asm_2d_align,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0xbL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_PROC(___H___asm_23_asm_2d_align,2,3)
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_PROC(___H___asm_23_asm_2d_align,2,2)
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_align,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_origin,"_asm#asm-origin",___REF_FAL,28,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_origin,3,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,2,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,2,4,0x3f1L))
,___DEF_LBL_PROC(___H___asm_23_asm_2d_origin,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0xbL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_PROC(___H___asm_23_asm_2d_origin,1,3)
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_PROC(___H___asm_23_asm_2d_origin,1,1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_origin,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_at_2d_assembly,"_asm#asm-at-assembly",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_at_2d_assembly,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_at_2d_assembly,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_at_2d_assembly,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_at_2d_assembly,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_listing,"_asm#asm-listing",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_listing,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_listing,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_listing,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_listing,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_separated_2d_list,"_asm#asm-separated-list",___REF_FAL,10,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_separated_2d_list,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_separated_2d_list,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_separated_2d_list,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_separated_2d_list,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_separated_2d_list,___IFD(___RETI,8,0,0x3f0dL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_separated_2d_list,___IFD(___RETN,5,0,0xdL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_separated_2d_list,___IFD(___RETN,5,0,0x9L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_separated_2d_list,___IFD(___RETI,8,8,0x3f08L))
,___DEF_LBL_PROC(___H___asm_23_asm_2d_separated_2d_list,1,1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_separated_2d_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_display_2d_listing,"_asm#asm-display-listing",___REF_FAL,78,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_display_2d_listing,3,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,8,3,0x3f0fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,3,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,3,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,3,0x1bL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,2,4,0x3fbL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___OFD(___RETI,12,2,0x3f03fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x37L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x2fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___OFD(___RETI,12,12,0x3f000L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x37L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,9,2,0x2fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,2,4,0x3fbL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETN,5,2,0x6L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_display_2d_listing,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_assemble,"_asm#asm-assemble",___REF_FAL,121,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_assemble,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,0,0x103L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x13L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,8,1,0x3f1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1eL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1eL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,1,4,0x3f9L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,8,2,0x3f0fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,2,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,4,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,2,4,0x3f7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___OFD(___RETI,12,2,0x3f03fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x6fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x37L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,4,4,0x3ffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0xffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,4,4,0x3ffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___OFD(___RETI,12,4,0x3f0ffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0xffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0xffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0xffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0x1ffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0xbbL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,4,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,2,4,0x3f7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0xb7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0xb3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0xffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,4,0xffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x27L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,2,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___OFD(___RETI,12,2,0x3f03fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x6fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x37L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,2,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x77L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,2,0x2fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,2,4,0x3fbL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,2,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,2,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,2,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,2,0x1dL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,1,4,0x3f9L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x37L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,8,1,0x3f1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0xffL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x77L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x57L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x57L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x57L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x57L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x77L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,9,1,0x4bL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x13L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETN,5,1,0x12L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_assemble_2d_to_2d_file,"_asm#asm-assemble-to-file",___REF_FAL,20,
0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_assemble_2d_to_2d_file,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_PROC(___H___asm_23_asm_2d_assemble_2d_to_2d_file,0,1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_file,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,"_asm#asm-assemble-to-u8vector",___REF_FAL,
21,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0xbL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0xbL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_assemble_2d_to_2d_u8vector,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_make_2d_stream,"_asm#asm-make-stream",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_make_2d_stream,0,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_make_2d_stream,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_make_2d_stream,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_make_2d_stream,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_code_2d_extend,"_asm#asm-code-extend",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_code_2d_extend,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_code_2d_extend,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_code_2d_extend,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_code_2d_extend,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_code_2d_extend,___IFD(___RETN,5,0,0xdL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_code_2d_extend,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_code_2d_extend,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_signed8_3f_,"_asm#asm-signed8?",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_signed8_3f_,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed8_3f_,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed8_3f_,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed8_3f_,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_signed16_3f_,"_asm#asm-signed16?",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_signed16_3f_,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed16_3f_,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed16_3f_,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed16_3f_,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_signed32_3f_,"_asm#asm-signed32?",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_signed32_3f_,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed32_3f_,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed32_3f_,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed32_3f_,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_signed_2d_lo8,"_asm#asm-signed-lo8",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_signed_2d_lo8,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo8,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo8,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo8,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo8,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_unsigned_2d_lo8,"_asm#asm-unsigned-lo8",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_unsigned_2d_lo8,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_unsigned_2d_lo8,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_signed_2d_lo16,"_asm#asm-signed-lo16",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_signed_2d_lo16,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo16,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo16,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo16,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo16,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_unsigned_2d_lo16,"_asm#asm-unsigned-lo16",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_unsigned_2d_lo16,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_unsigned_2d_lo16,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_signed_2d_lo32,"_asm#asm-signed-lo32",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_signed_2d_lo32,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo32,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo32,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo32,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo32,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_unsigned_2d_lo32,"_asm#asm-unsigned-lo32",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_unsigned_2d_lo32,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_unsigned_2d_lo32,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_signed_2d_lo64,"_asm#asm-signed-lo64",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_signed_2d_lo64,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo64,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo64,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo64,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo64,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_unsigned_2d_lo64,"_asm#asm-unsigned-lo64",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_unsigned_2d_lo64,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_unsigned_2d_lo64,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_signed_2d_lo,"_asm#asm-signed-lo",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_signed_2d_lo,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_signed_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_unsigned_2d_lo,"_asm#asm-unsigned-lo",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_unsigned_2d_lo,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_unsigned_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_unsigned_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_unsigned_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_unsigned_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_unsigned_2d_lo,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_bits_2d_0_2d_to_2d_7,"_asm#asm-bits-0-to-7",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_bits_2d_0_2d_to_2d_7,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_0_2d_to_2d_7,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,"_asm#asm-bits-8-and-up",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,"_asm#asm-bits-16-and-up",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,"_asm#asm-bits-32-and-up",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,1,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,"_asm#asm-float->inexact-exponential-format",
___REF_FAL,53,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x13fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETI,8,1,0x3f1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,1,0x1bL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x2fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3eL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3eL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3eL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,1,0x16L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,1,0x16L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,1,0x6L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x13fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETI,8,1,0x3f1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,1,0x1bL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x2fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3eL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3eL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,9,1,0x3eL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,"_asm#asm-float->exact-exponential-format",
___REF_FAL,23,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_INTRO(___H___asm_23_asm_2d_float_2d__3e_bits,"_asm#asm-float->bits",___REF_FAL,20,0)
,___DEF_LBL_PROC(___H___asm_23_asm_2d_float_2d__3e_bits,2,-1)
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,5,0,0x1fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,9,0,0x3fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,9,0,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,5,0,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,5,0,0x17L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,5,0,0x11L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,5,0,0x11L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,9,0,0x6fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,9,0,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,9,0,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,9,0,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,9,0,0x7fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,9,0,0x5fL))
,___DEF_LBL_RET(___H___asm_23_asm_2d_float_2d__3e_bits,___IFD(___RETN,5,0,0x1fL))
___END_LBL
___BEGIN_OFD
___DEF_OFD(___RETI,12,2)
___GCMAP1(0x3f03fL)
,___DEF_OFD(___RETI,12,12)
___GCMAP1(0x3f000L)
,___DEF_OFD(___RETI,12,2)
___GCMAP1(0x3f03fL)
,___DEF_OFD(___RETI,12,4)
___GCMAP1(0x3f0ffL)
,___DEF_OFD(___RETI,12,2)
___GCMAP1(0x3f03fL)
___END_OFD
___BEGIN_MOD_PRM
___DEF_MOD_PRM(0,___G___asm_23_,1)
___DEF_MOD_PRM(44,___G___asm_23_asm_2d_make_2d_code_2d_block,10)
___DEF_MOD_PRM(34,___G___asm_23_asm_2d_init_2d_code_2d_block,15)
___DEF_MOD_PRM(22,___G___asm_23_asm_2d_copy_2d_code_2d_block,22)
___DEF_MOD_PRM(10,___G___asm_23_asm_2d_8,32)
___DEF_MOD_PRM(1,___G___asm_23_asm_2d_16,37)
___DEF_MOD_PRM(2,___G___asm_23_asm_2d_16_2d_be,43)
___DEF_MOD_PRM(3,___G___asm_23_asm_2d_16_2d_le,50)
___DEF_MOD_PRM(4,___G___asm_23_asm_2d_32,57)
___DEF_MOD_PRM(5,___G___asm_23_asm_2d_32_2d_be,63)
___DEF_MOD_PRM(6,___G___asm_23_asm_2d_32_2d_le,69)
___DEF_MOD_PRM(7,___G___asm_23_asm_2d_64,75)
___DEF_MOD_PRM(8,___G___asm_23_asm_2d_64_2d_be,81)
___DEF_MOD_PRM(9,___G___asm_23_asm_2d_64_2d_le,87)
___DEF_MOD_PRM(35,___G___asm_23_asm_2d_int,93)
___DEF_MOD_PRM(36,___G___asm_23_asm_2d_int_2d_be,99)
___DEF_MOD_PRM(37,___G___asm_23_asm_2d_int_2d_le,110)
___DEF_MOD_PRM(24,___G___asm_23_asm_2d_f32,121)
___DEF_MOD_PRM(25,___G___asm_23_asm_2d_f64,126)
___DEF_MOD_PRM(11,___G___asm_23_asm_2d_UTF_2d_8_2d_string,131)
___DEF_MOD_PRM(45,___G___asm_23_asm_2d_make_2d_label,148)
___DEF_MOD_PRM(42,___G___asm_23_asm_2d_label_3f_,151)
___DEF_MOD_PRM(38,___G___asm_23_asm_2d_label,159)
___DEF_MOD_PRM(39,___G___asm_23_asm_2d_label_2d_id,167)
___DEF_MOD_PRM(40,___G___asm_23_asm_2d_label_2d_name,170)
___DEF_MOD_PRM(41,___G___asm_23_asm_2d_label_2d_pos,181)
___DEF_MOD_PRM(12,___G___asm_23_asm_2d_align,187)
___DEF_MOD_PRM(47,___G___asm_23_asm_2d_origin,220)
___DEF_MOD_PRM(16,___G___asm_23_asm_2d_at_2d_assembly,249)
___DEF_MOD_PRM(43,___G___asm_23_asm_2d_listing,254)
___DEF_MOD_PRM(48,___G___asm_23_asm_2d_separated_2d_list,259)
___DEF_MOD_PRM(23,___G___asm_23_asm_2d_display_2d_listing,270)
___DEF_MOD_PRM(13,___G___asm_23_asm_2d_assemble,349)
___DEF_MOD_PRM(14,___G___asm_23_asm_2d_assemble_2d_to_2d_file,471)
___DEF_MOD_PRM(15,___G___asm_23_asm_2d_assemble_2d_to_2d_u8vector,492)
___DEF_MOD_PRM(46,___G___asm_23_asm_2d_make_2d_stream,514)
___DEF_MOD_PRM(21,___G___asm_23_asm_2d_code_2d_extend,519)
___DEF_MOD_PRM(56,___G___asm_23_asm_2d_signed8_3f_,527)
___DEF_MOD_PRM(54,___G___asm_23_asm_2d_signed16_3f_,532)
___DEF_MOD_PRM(55,___G___asm_23_asm_2d_signed32_3f_,537)
___DEF_MOD_PRM(53,___G___asm_23_asm_2d_signed_2d_lo8,542)
___DEF_MOD_PRM(61,___G___asm_23_asm_2d_unsigned_2d_lo8,548)
___DEF_MOD_PRM(50,___G___asm_23_asm_2d_signed_2d_lo16,551)
___DEF_MOD_PRM(58,___G___asm_23_asm_2d_unsigned_2d_lo16,557)
___DEF_MOD_PRM(51,___G___asm_23_asm_2d_signed_2d_lo32,560)
___DEF_MOD_PRM(59,___G___asm_23_asm_2d_unsigned_2d_lo32,566)
___DEF_MOD_PRM(52,___G___asm_23_asm_2d_signed_2d_lo64,569)
___DEF_MOD_PRM(60,___G___asm_23_asm_2d_unsigned_2d_lo64,575)
___DEF_MOD_PRM(49,___G___asm_23_asm_2d_signed_2d_lo,578)
___DEF_MOD_PRM(57,___G___asm_23_asm_2d_unsigned_2d_lo,585)
___DEF_MOD_PRM(17,___G___asm_23_asm_2d_bits_2d_0_2d_to_2d_7,592)
___DEF_MOD_PRM(20,___G___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,595)
___DEF_MOD_PRM(18,___G___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,603)
___DEF_MOD_PRM(19,___G___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,611)
___DEF_MOD_PRM(28,___G___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,619)
___DEF_MOD_PRM(27,___G___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,673)
___DEF_MOD_PRM(26,___G___asm_23_asm_2d_float_2d__3e_bits,697)
___END_MOD_PRM
___BEGIN_MOD_C_INIT
___END_MOD_C_INIT
___BEGIN_MOD_GLO
___DEF_MOD_GLO(0,___G___asm_23_,1)
___DEF_MOD_GLO(44,___G___asm_23_asm_2d_make_2d_code_2d_block,10)
___DEF_MOD_GLO(34,___G___asm_23_asm_2d_init_2d_code_2d_block,15)
___DEF_MOD_GLO(22,___G___asm_23_asm_2d_copy_2d_code_2d_block,22)
___DEF_MOD_GLO(10,___G___asm_23_asm_2d_8,32)
___DEF_MOD_GLO(1,___G___asm_23_asm_2d_16,37)
___DEF_MOD_GLO(2,___G___asm_23_asm_2d_16_2d_be,43)
___DEF_MOD_GLO(3,___G___asm_23_asm_2d_16_2d_le,50)
___DEF_MOD_GLO(4,___G___asm_23_asm_2d_32,57)
___DEF_MOD_GLO(5,___G___asm_23_asm_2d_32_2d_be,63)
___DEF_MOD_GLO(6,___G___asm_23_asm_2d_32_2d_le,69)
___DEF_MOD_GLO(7,___G___asm_23_asm_2d_64,75)
___DEF_MOD_GLO(8,___G___asm_23_asm_2d_64_2d_be,81)
___DEF_MOD_GLO(9,___G___asm_23_asm_2d_64_2d_le,87)
___DEF_MOD_GLO(35,___G___asm_23_asm_2d_int,93)
___DEF_MOD_GLO(36,___G___asm_23_asm_2d_int_2d_be,99)
___DEF_MOD_GLO(37,___G___asm_23_asm_2d_int_2d_le,110)
___DEF_MOD_GLO(24,___G___asm_23_asm_2d_f32,121)
___DEF_MOD_GLO(25,___G___asm_23_asm_2d_f64,126)
___DEF_MOD_GLO(11,___G___asm_23_asm_2d_UTF_2d_8_2d_string,131)
___DEF_MOD_GLO(45,___G___asm_23_asm_2d_make_2d_label,148)
___DEF_MOD_GLO(42,___G___asm_23_asm_2d_label_3f_,151)
___DEF_MOD_GLO(38,___G___asm_23_asm_2d_label,159)
___DEF_MOD_GLO(39,___G___asm_23_asm_2d_label_2d_id,167)
___DEF_MOD_GLO(40,___G___asm_23_asm_2d_label_2d_name,170)
___DEF_MOD_GLO(41,___G___asm_23_asm_2d_label_2d_pos,181)
___DEF_MOD_GLO(12,___G___asm_23_asm_2d_align,187)
___DEF_MOD_GLO(47,___G___asm_23_asm_2d_origin,220)
___DEF_MOD_GLO(16,___G___asm_23_asm_2d_at_2d_assembly,249)
___DEF_MOD_GLO(43,___G___asm_23_asm_2d_listing,254)
___DEF_MOD_GLO(48,___G___asm_23_asm_2d_separated_2d_list,259)
___DEF_MOD_GLO(23,___G___asm_23_asm_2d_display_2d_listing,270)
___DEF_MOD_GLO(13,___G___asm_23_asm_2d_assemble,349)
___DEF_MOD_GLO(14,___G___asm_23_asm_2d_assemble_2d_to_2d_file,471)
___DEF_MOD_GLO(15,___G___asm_23_asm_2d_assemble_2d_to_2d_u8vector,492)
___DEF_MOD_GLO(46,___G___asm_23_asm_2d_make_2d_stream,514)
___DEF_MOD_GLO(21,___G___asm_23_asm_2d_code_2d_extend,519)
___DEF_MOD_GLO(56,___G___asm_23_asm_2d_signed8_3f_,527)
___DEF_MOD_GLO(54,___G___asm_23_asm_2d_signed16_3f_,532)
___DEF_MOD_GLO(55,___G___asm_23_asm_2d_signed32_3f_,537)
___DEF_MOD_GLO(53,___G___asm_23_asm_2d_signed_2d_lo8,542)
___DEF_MOD_GLO(61,___G___asm_23_asm_2d_unsigned_2d_lo8,548)
___DEF_MOD_GLO(50,___G___asm_23_asm_2d_signed_2d_lo16,551)
___DEF_MOD_GLO(58,___G___asm_23_asm_2d_unsigned_2d_lo16,557)
___DEF_MOD_GLO(51,___G___asm_23_asm_2d_signed_2d_lo32,560)
___DEF_MOD_GLO(59,___G___asm_23_asm_2d_unsigned_2d_lo32,566)
___DEF_MOD_GLO(52,___G___asm_23_asm_2d_signed_2d_lo64,569)
___DEF_MOD_GLO(60,___G___asm_23_asm_2d_unsigned_2d_lo64,575)
___DEF_MOD_GLO(49,___G___asm_23_asm_2d_signed_2d_lo,578)
___DEF_MOD_GLO(57,___G___asm_23_asm_2d_unsigned_2d_lo,585)
___DEF_MOD_GLO(17,___G___asm_23_asm_2d_bits_2d_0_2d_to_2d_7,592)
___DEF_MOD_GLO(20,___G___asm_23_asm_2d_bits_2d_8_2d_and_2d_up,595)
___DEF_MOD_GLO(18,___G___asm_23_asm_2d_bits_2d_16_2d_and_2d_up,603)
___DEF_MOD_GLO(19,___G___asm_23_asm_2d_bits_2d_32_2d_and_2d_up,611)
___DEF_MOD_GLO(28,___G___asm_23_asm_2d_float_2d__3e_inexact_2d_exponential_2d_format,619)
___DEF_MOD_GLO(27,___G___asm_23_asm_2d_float_2d__3e_exact_2d_exponential_2d_format,673)
___DEF_MOD_GLO(26,___G___asm_23_asm_2d_float_2d__3e_bits,697)
___END_MOD_GLO
___BEGIN_MOD_SYM_KEY
___DEF_MOD_SYM(0,___S_UTF_2d_8,"UTF-8")
___DEF_MOD_SYM(1,___S___asm,"_asm")
___DEF_MOD_SYM(2,___S_be,"be")
___DEF_MOD_SYM(3,___S_code_2d_block,"code-block")
___DEF_MOD_SYM(4,___S_deferred,"deferred")
___DEF_MOD_SYM(5,___S_label,"label")
___DEF_MOD_SYM(6,___S_listing,"listing")
___DEF_MOD_KEY(0,___K_char_2d_encoding,"char-encoding")
___END_MOD_SYM_KEY
#endif
| 41.868126 | 154 | 0.854821 | [
"vector"
] |
43846e724eac9b61acdfc831af97e837191e1c5f | 2,195 | h | C | physicalrobots/player/server/drivers/mixed/mricp/include/lasermodel.h | parasol-ppl/PPL_utils | 92728bb89692fda1705a0dee436592d97922a6cb | [
"BSD-3-Clause"
] | null | null | null | physicalrobots/player/server/drivers/mixed/mricp/include/lasermodel.h | parasol-ppl/PPL_utils | 92728bb89692fda1705a0dee436592d97922a6cb | [
"BSD-3-Clause"
] | null | null | null | physicalrobots/player/server/drivers/mixed/mricp/include/lasermodel.h | parasol-ppl/PPL_utils | 92728bb89692fda1705a0dee436592d97922a6cb | [
"BSD-3-Clause"
] | null | null | null | /***************************************************************************
* Copyright (C) 2005 by Tarek Taha *
* tataha@eng.uts.edu.au *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef LASERMODEL_H_
#define LASERMODEL_H_
// Info for a single range measurement
typedef struct
{
double range, bearing;
} laser_range_t;
class LaserModel
{
private:
mapgrid * * map; // Pointer to the OG map
double range_cov; // Covariance in the range reading
double range_bad; // Probability of spurious range readings
// Pre-computed laser sensor model
int lut_size;
double lut_res;
double *lut_probs;
int range_count;
laser_range_t *ranges;
public :
void ClearRanges();
void AddRange(double,double);
void PreCompute();
double RangeProb(double,double);
double PoseProb();
LaserModel();
~LaserModel();
LaserModel(mapgrid * * );
};
#endif /*LASERMODEL_H_*/
| 42.211538 | 77 | 0.494761 | [
"model"
] |
4386dcad6ca7a99221a6dce434f641328908e7e8 | 11,752 | h | C | modules/plotting/datastructures/column.h | victorca25/inviwo | 34b6675f6b791a08e358d24aea4f75d5baadc6da | [
"BSD-2-Clause"
] | null | null | null | modules/plotting/datastructures/column.h | victorca25/inviwo | 34b6675f6b791a08e358d24aea4f75d5baadc6da | [
"BSD-2-Clause"
] | null | null | null | modules/plotting/datastructures/column.h | victorca25/inviwo | 34b6675f6b791a08e358d24aea4f75d5baadc6da | [
"BSD-2-Clause"
] | null | null | null | /*********************************************************************************
*
* Inviwo - Interactive Visualization Workshop
*
* Copyright (c) 2017 Inviwo Foundation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*********************************************************************************/
#ifndef IVW_COLUMN_H
#define IVW_COLUMN_H
#include <modules/plotting/plottingmoduledefine.h>
#include <inviwo/core/common/inviwo.h>
#include <inviwo/core/datastructures/buffer/buffer.h>
#include <inviwo/core/datastructures/buffer/bufferram.h>
#include <inviwo/core/util/exception.h>
#include <modules/plotting/datastructures/datapoint.h>
namespace inviwo {
class DataPointBase;
class BufferBase;
class IVW_MODULE_PLOTTING_API InvalidConversion : public Exception {
public:
InvalidConversion(const std::string &message = "", ExceptionContext context = ExceptionContext())
: Exception(message, context) {
}
virtual ~InvalidConversion() throw() {}
};
namespace plot {
/**
* \class Column
* \brief pure interface for representing a data column, i.e. a Buffer with a name
*/
class IVW_MODULE_PLOTTING_API Column {
public:
virtual ~Column() = default;
virtual Column *clone() const = 0;
virtual const std::string &getHeader() const = 0;
virtual void setHeader(const std::string &header) = 0;
virtual void add(const std::string &value) = 0;
virtual std::shared_ptr<BufferBase> getBuffer() = 0;
virtual std::shared_ptr<const BufferBase> getBuffer() const = 0;
virtual size_t getSize() const = 0;
virtual double getAsDouble(size_t idx) const = 0;
virtual dvec2 getAsDVec2(size_t idx) const = 0;
virtual dvec3 getAsDVec3(size_t idx) const = 0;
virtual dvec4 getAsDVec4(size_t idx) const = 0;
virtual std::string getAsString(size_t idx) const = 0;
virtual std::shared_ptr<DataPointBase> get(size_t idx, bool getStringsAsStrings) const = 0;
protected:
Column() = default;
};
/**
* \class TemplateColumn
* \brief Data column used for plotting which represents a named buffer of type T. The name
* is used as column header.
*/
template <typename T>
class TemplateColumn : public Column {
public:
using type = T;
TemplateColumn(const std::string &header);
TemplateColumn(const TemplateColumn<T> &rhs);
TemplateColumn(TemplateColumn<T> &&rhs);
TemplateColumn<T> &operator=(const TemplateColumn<T> &rhs);
TemplateColumn<T> &operator=(TemplateColumn<T> &&rhs);
virtual TemplateColumn *clone() const override;
virtual ~TemplateColumn() = default;
virtual const std::string &getHeader() const override;
void setHeader(const std::string &header) override;
virtual void add(const T &value);
/**
* \brief converts given value to type T, which is added to the column
*
* @param value
* @throws InvalidConversion if the value cannot be converted to T
*/
virtual void add(const std::string &value) override;
virtual void set(size_t idx, const T &value);
T get(size_t idx) const;
/**
* \brief returns the data value for the given index.
*
* @param idx index
* @param getStringsAsStrings if true, strings will be returned for categorical values
* instead of their internal representation. This will not affect other column types.
*
* \see CategoricalColumn
*/
virtual std::shared_ptr<DataPointBase> get(size_t idx, bool getStringsAsStrings) const override;
virtual double getAsDouble(size_t idx) const override;
virtual dvec2 getAsDVec2(size_t idx) const override;
virtual dvec3 getAsDVec3(size_t idx) const override;
virtual dvec4 getAsDVec4(size_t idx) const override;
void setBuffer(std::shared_ptr<Buffer<T>> buffer);
virtual std::string getAsString(size_t idx) const override;
virtual std::shared_ptr<BufferBase> getBuffer() override;
virtual std::shared_ptr<const BufferBase> getBuffer() const override;
std::shared_ptr<Buffer<T>> getTypedBuffer();
std::shared_ptr<const Buffer<T>> getTypedBuffer() const;
virtual size_t getSize() const override;
protected:
std::string header_;
std::shared_ptr<Buffer<T>> buffer_;
};
/**
* \class CategoricalColumn
* \brief Specialized data column representing categorical values, i.e. strings.
* Categorical values are internally mapped to a number representation.
*
* For example:
* The data column "blue", "blue", "red", "yellow" might internally be represented
* by 0, 0, 1, 2.
* The original string values can be accessed using CategoricalColumn::get(index, true)
*
* \see TemplateColumn, \see CategoricalColumn::get()
*/
class IVW_MODULE_PLOTTING_API CategoricalColumn : public TemplateColumn<std::uint32_t> {
public:
CategoricalColumn(const std::string &header);
CategoricalColumn(const CategoricalColumn &rhs) = default;
CategoricalColumn(CategoricalColumn &&rhs) = default;
CategoricalColumn &operator=(const CategoricalColumn &rhs) = default;
CategoricalColumn &operator=(CategoricalColumn &&rhs) = default;
virtual CategoricalColumn *clone() const override;
virtual ~CategoricalColumn() = default;
virtual std::string getAsString(size_t idx) const override;
/**
* \brief returns either the categorical value, i.e. a number representation, or
* the actual string for the given index.
*
* @param idx index
* @param getStringsAsStrings if true, a string will be returned instead of the
* internal representation. This will not affect other column types.
*
* \see TemplateColumn
*/
virtual std::shared_ptr<DataPointBase> get(size_t idx, bool getStringsAsStrings) const override;
using TemplateColumn<std::uint32_t>::set;
virtual void set(size_t idx, const std::string &str);
virtual void add(const std::string &value) override;
private:
virtual glm::uint32_t addOrGetID(const std::string &str);
std::vector<std::string> lookUpTable_;
};
template <typename T>
TemplateColumn<T>::TemplateColumn(const std::string &header)
: header_(header), buffer_(std::make_shared<Buffer<T>>()) {}
template <typename T>
TemplateColumn<T>::TemplateColumn(const TemplateColumn &rhs)
: header_(rhs.getHeader())
, buffer_(std::shared_ptr<Buffer<T>>(rhs.getTypedBuffer()->clone())) {}
template <typename T>
TemplateColumn<T>::TemplateColumn(TemplateColumn<T> &&rhs)
: header_(std::move(rhs.header_)), buffer_(std::move(rhs.buffer_)) {}
template <typename T>
TemplateColumn<T> &TemplateColumn<T>::operator=(const TemplateColumn<T> &rhs) {
if (this != &rhs) {
header_ = rhs.getHeader();
buffer_ = std::shared_ptr<Buffer<T>>(rhs.getTypedBuffer()->clone());
}
return *this;
}
template <typename T>
TemplateColumn<T> &TemplateColumn<T>::operator=(TemplateColumn<T> &&rhs) {
if (this != &rhs) {
header_ = std::move(rhs.header_);
buffer_ = std::move(rhs.buffer_);
}
return *this;
}
template <typename T>
TemplateColumn<T> *TemplateColumn<T>::clone() const {
return new TemplateColumn(*this);
}
template <typename T>
const std::string &TemplateColumn<T>::getHeader() const {
return header_;
}
template <typename T>
void TemplateColumn<T>::setHeader(const std::string &header) {
header_ = header;
}
template <typename T>
void TemplateColumn<T>::add(const T &value) {
buffer_->getEditableRAMRepresentation()->add(value);
}
namespace detail {
template <typename T>
void add(std::true_type, Buffer<T> *buffer, const std::string &value) {
T result;
std::istringstream stream(value);
stream >> result;
if (stream.fail()) {
throw InvalidConversion("cannot convert \"" + value + "\" to target type");
}
buffer->getEditableRAMRepresentation()->add(result);
}
template <typename T>
void add(std::false_type, Buffer<T> *buffer, const std::string &value) {
throw InvalidConversion("conversion to target type not implemented (\"" + value + "\")");
}
} // namespace detail
template <typename T>
void TemplateColumn<T>::add(const std::string &value) {
detail::add(typename std::integral_constant<bool,util::rank<T>::value == 0>::type(), buffer_.get(), value);
}
template <typename T>
void TemplateColumn<T>::set(size_t idx, const T &value) {
buffer_->getEditableRAMRepresentation()->set(idx, value);
}
template <typename T>
T TemplateColumn<T>::get(size_t idx) const {
auto val = buffer_->getRAMRepresentation()->getDataContainer()[idx];
return val;
}
template <typename T>
double TemplateColumn<T>::getAsDouble(size_t idx) const {
auto val = buffer_->getRAMRepresentation()->getDataContainer()[idx];
return util::glm_convert<double>(val);
}
template <typename T>
dvec2 TemplateColumn<T>::getAsDVec2(size_t idx) const {
auto val = buffer_->getRAMRepresentation()->getDataContainer()[idx];
return util::glm_convert<dvec2>(val);
}
template <typename T>
dvec3 TemplateColumn<T>::getAsDVec3(size_t idx) const {
auto val = buffer_->getRAMRepresentation()->getDataContainer()[idx];
return util::glm_convert<dvec3>(val);
}
template <typename T>
dvec4 TemplateColumn<T>::getAsDVec4(size_t idx) const {
auto val = buffer_->getRAMRepresentation()->getDataContainer()[idx];
return util::glm_convert<dvec4>(val);
}
template <typename T>
void TemplateColumn<T>::setBuffer(std::shared_ptr<Buffer<T>> buffer) {
buffer_ = buffer;
}
template <typename T>
std::string TemplateColumn<T>::getAsString(size_t idx) const {
std::ostringstream ss;
ss << buffer_->getRAMRepresentation()->get(idx);
return ss.str();
}
template <typename T>
std::shared_ptr<DataPointBase> TemplateColumn<T>::get(size_t idx, bool) const {
return std::make_shared<DataPoint<T>>(buffer_->getRAMRepresentation()->get(idx));
}
template <typename T>
std::shared_ptr<BufferBase> TemplateColumn<T>::getBuffer() {
return buffer_;
}
template <typename T>
std::shared_ptr<const BufferBase> TemplateColumn<T>::getBuffer() const {
return buffer_;
}
template <typename T>
std::shared_ptr<Buffer<T>> TemplateColumn<T>::getTypedBuffer() {
return buffer_;
}
template <typename T>
std::shared_ptr<const Buffer<T>> TemplateColumn<T>::getTypedBuffer() const {
return buffer_;
}
template <typename T>
size_t TemplateColumn<T>::getSize() const {
return buffer_->getSize();
}
} // namespace plot
} // namespace inviwo
#endif // IVW_COLUMN_H
| 31.848238 | 111 | 0.70337 | [
"vector"
] |
4389b942e4c56657ff3b5b707548ee4c4881533e | 2,030 | h | C | cinn/hlir/framework/instruction.h | Joejiong/CINN | a6beb59f729e515dfe60b2264b0bed670acaff88 | [
"Apache-2.0"
] | 1 | 2019-10-23T09:16:23.000Z | 2019-10-23T09:16:23.000Z | cinn/hlir/framework/instruction.h | Superjomn/CINN | 8a1183a3a6186a91d9a1bb653f53925709bdc8e2 | [
"Apache-2.0"
] | null | null | null | cinn/hlir/framework/instruction.h | Superjomn/CINN | 8a1183a3a6186a91d9a1bb653f53925709bdc8e2 | [
"Apache-2.0"
] | null | null | null | #pragma once
#include <string>
#include <vector>
#include "cinn/common/test_helper.h"
#include "cinn/hlir/framework/scope.h"
namespace cinn {
namespace hlir {
namespace framework {
/**
* Instruction is the basic executable element in runtime, it holds a pointer to the JIT-compiled LoweredFunc, and
* collect the cinn_buffer of the inputs and outputs from the scope, prepare the arguments and finally pass them into
* the LoweredFunc and execute it.
*/
class Instruction {
public:
using infershape_t = std::function<void(Scope*, const std::vector<std::string>&)>;
/**
* Constructor.
* @param target The \p target the instruction runs on.
* @param scope The scope containing all the runtime variables(Tensors and PODs).
* @param in_args The names of the inputs.
* @param out_args The names of the outputs.
* @param infershape The handler of this Instruction to perform shape inference.
*/
Instruction(const Target& target,
Scope* scope,
const std::vector<std::string>& in_args,
const std::vector<std::string>& out_args)
: target_(target), scope_(scope), in_args_(in_args), out_args_(out_args) {}
/**
* Set compiled function address.
* @param fn The JIT compiled function address.
*/
void SetLoweredFunc(lower_func_ptr_t fn) { fn_ = fn; }
/**
* Run the Instruction.
*/
void Run() {
CHECK(fn_) << "The LoweredFunc address should be set first by calling SetLoweredFunc method";
auto& pod_args = PreparePodArgs();
fn_(pod_args.data(), pod_args.size());
}
std::vector<std::string> GetInArgs() { return in_args_; }
std::vector<std::string> GetOutArgs() { return out_args_; }
protected:
std::vector<cinn_pod_value_t>& PreparePodArgs();
private:
Scope* scope_{};
std::vector<std::string> in_args_;
std::vector<std::string> out_args_;
std::vector<cinn_pod_value_t> args_cached_;
Target target_;
lower_func_ptr_t fn_{};
};
} // namespace framework
} // namespace hlir
} // namespace cinn
| 28.591549 | 117 | 0.691626 | [
"shape",
"vector"
] |
438b4060715e127871abd2eaeff44460cca9ab9a | 4,345 | h | C | mi8/drivers/staging/qcacld-3.0/core/dp/ol/inc/ol_txrx_dbg.h | wqk317/mi8_kernel_source | e3482d1a7ea6021de2fc8f3178496b4b043bb727 | [
"MIT"
] | null | null | null | mi8/drivers/staging/qcacld-3.0/core/dp/ol/inc/ol_txrx_dbg.h | wqk317/mi8_kernel_source | e3482d1a7ea6021de2fc8f3178496b4b043bb727 | [
"MIT"
] | null | null | null | mi8/drivers/staging/qcacld-3.0/core/dp/ol/inc/ol_txrx_dbg.h | wqk317/mi8_kernel_source | e3482d1a7ea6021de2fc8f3178496b4b043bb727 | [
"MIT"
] | null | null | null | /*
* Copyright (c) 2011, 2014-2017 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all
* copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
/**
* @file ol_txrx_dbg.h
* @brief Functions provided for visibility and debugging.
*/
#ifndef _OL_TXRX_DBG__H_
#define _OL_TXRX_DBG__H_
#include <athdefs.h> /* A_STATUS, uint64_t */
#include <qdf_lock.h> /* qdf_semaphore_t */
#include <htt.h> /* htt_dbg_stats_type */
#include <ol_txrx_stats.h> /* ol_txrx_stats */
#ifndef TXRX_DEBUG_LEVEL
#define TXRX_DEBUG_LEVEL 0 /* no debug info */
#endif
enum {
TXRX_DBG_MASK_OBJS = 0x01,
TXRX_DBG_MASK_STATS = 0x02,
TXRX_DBG_MASK_PROT_ANALYZE = 0x04,
TXRX_DBG_MASK_RX_REORDER_TRACE = 0x08,
TXRX_DBG_MASK_RX_PN_TRACE = 0x10
};
/*--- txrx printouts ---*/
/*
* Uncomment this to enable txrx printouts with dynamically adjustable
* verbosity. These printouts should not impact performance.
*/
#define TXRX_PRINT_ENABLE 1
/* uncomment this for verbose txrx printouts (may impact performance) */
/* #define TXRX_PRINT_VERBOSE_ENABLE 1 */
/*--- txrx object (pdev, vdev, peer) display debug functions ---*/
#if TXRX_DEBUG_LEVEL > 5
void ol_txrx_pdev_display(ol_txrx_pdev_handle pdev, int indent);
void ol_txrx_vdev_display(ol_txrx_vdev_handle vdev, int indent);
void ol_txrx_peer_display(ol_txrx_peer_handle peer, int indent);
#else
#define ol_txrx_pdev_display(pdev, indent)
#define ol_txrx_vdev_display(vdev, indent)
#define ol_txrx_peer_display(peer, indent)
#endif
/*--- txrx stats display debug functions ---*/
/**
* ol_txrx_stats_display() - display tx rx stats
* @pdev: pdev handle
* @level: verbosity level for logs
*
* Return: none
*/
void ol_txrx_stats_display(ol_txrx_pdev_handle pdev,
enum qdf_stats_verbosity_level level);
void ol_txrx_stats_clear(ol_txrx_pdev_handle pdev);
/*--- txrx protocol analyzer debug feature ---*/
/* uncomment this to enable the protocol analzyer feature */
/* #define ENABLE_TXRX_PROT_ANALYZE 1 */
#if defined(ENABLE_TXRX_PROT_ANALYZE)
void ol_txrx_prot_ans_display(ol_txrx_pdev_handle pdev);
#else
#define ol_txrx_prot_ans_display(pdev)
#endif /* ENABLE_TXRX_PROT_ANALYZE */
/*--- txrx sequence number trace debug feature ---*/
/* uncomment this to enable the rx reorder trace feature */
/* #define ENABLE_RX_REORDER_TRACE 1 */
#define ol_txrx_seq_num_trace_display(pdev) \
ol_rx_reorder_trace_display(pdev, 0, 0)
#if defined(ENABLE_RX_REORDER_TRACE)
void
ol_rx_reorder_trace_display(ol_txrx_pdev_handle pdev, int just_once, int limit);
#else
#define ol_rx_reorder_trace_display(pdev, just_once, limit)
#endif /* ENABLE_RX_REORDER_TRACE */
/*--- txrx packet number trace debug feature ---*/
/* uncomment this to enable the rx PN trace feature */
/* #define ENABLE_RX_PN_TRACE 1 */
#define ol_txrx_pn_trace_display(pdev) ol_rx_pn_trace_display(pdev, 0)
#if defined(ENABLE_RX_PN_TRACE)
void ol_rx_pn_trace_display(ol_txrx_pdev_handle pdev, int just_once);
#else
#define ol_rx_pn_trace_display(pdev, just_once)
#endif /* ENABLE_RX_PN_TRACE */
/*--- tx queue log debug feature ---*/
/* uncomment this to enable the tx queue log feature */
/* #define ENABLE_TX_QUEUE_LOG 1 */
#if defined(DEBUG_HL_LOGGING) && defined(CONFIG_HL_SUPPORT)
void
ol_tx_queue_log_display(ol_txrx_pdev_handle pdev);
void ol_tx_queue_log_clear(ol_txrx_pdev_handle pdev);
#else
static inline
void ol_tx_queue_log_display(ol_txrx_pdev_handle pdev)
{
}
static inline
void ol_tx_queue_log_clear(ol_txrx_pdev_handle pdev)
{
}
#endif /* defined(DEBUG_HL_LOGGING) && defined(CONFIG_HL_SUPPORT) */
/*----------------------------------------*/
#endif /* _OL_TXRX_DBG__H_ */
| 27.675159 | 80 | 0.751899 | [
"object"
] |
4394defe17820b88a4d36fd23454ec641a0a3c1b | 281 | h | C | BlockAlertsDemo/ToAddToYourProjects/RetentionCenter.h | drosenstark/BlockAlertsAnd-ActionSheets | 8a98c3ae51c29d6d71f46ef26a5cb8879cf7445b | [
"MIT"
] | null | null | null | BlockAlertsDemo/ToAddToYourProjects/RetentionCenter.h | drosenstark/BlockAlertsAnd-ActionSheets | 8a98c3ae51c29d6d71f46ef26a5cb8879cf7445b | [
"MIT"
] | 21 | 2017-04-21T01:10:05.000Z | 2017-04-24T02:08:48.000Z | BlockAlertsDemo/ToAddToYourProjects/RetentionCenter.h | drosenstark/BlockAlertsAnd-ActionSheets | 8a98c3ae51c29d6d71f46ef26a5cb8879cf7445b | [
"MIT"
] | null | null | null | //
// RetentionCenter.h
// BlockAlertsDemo
//
// Created by drosenstark on 8/1/12 to handle legacy retains and releases in an ARCy way.
#import <Foundation/Foundation.h>
@interface RetentionCenter : NSObject
+ (void) retainMe:(id)object;
+ (void) releaseMe:(id)object;
@end
| 18.733333 | 90 | 0.72242 | [
"object"
] |
4396607284ea17143d2f60fd8c8463359ee784f7 | 710 | h | C | LJOrm/LJOrm/LJOrm/LJOrmDBServer.h | LiuJinGH/LJOrm | 886e8789986382f2a559f214644934f6ad11a6ba | [
"MIT"
] | null | null | null | LJOrm/LJOrm/LJOrm/LJOrmDBServer.h | LiuJinGH/LJOrm | 886e8789986382f2a559f214644934f6ad11a6ba | [
"MIT"
] | null | null | null | LJOrm/LJOrm/LJOrm/LJOrmDBServer.h | LiuJinGH/LJOrm | 886e8789986382f2a559f214644934f6ad11a6ba | [
"MIT"
] | null | null | null | //
// LJOrmDBServer.h
// LJOrm
//
// Created by 刘瑾 on 2017/11/29.
// Copyright © 2017年 刘瑾. All rights reserved.
//
/**
ORM 数据库服务器
1. 通过FMDB创建ORM数据库，并建议连接。
2. 根据ORM Model 创建或删除数据库表。
3. 执行相关SQL语句。
*/
#import <Foundation/Foundation.h>
#import "FMDB.h"
#import "LJOrmConfiguration.h"
@interface LJOrmDBServer : NSObject
+(instancetype) sharedInstance;
/**
ORM数据库表
*/
@property (nonatomic, strong) NSArray<LJOrmDBTable *> *tables;
/**
创建数据库表
@param table 数据库表信息
@return 是否创建成功
*/
-(BOOL) creataTable:(LJOrmDBTable *)table;
/**
对某个ORM数据库表进行清空操作
@param tableName 数据库表名
*/
-(void)clearAllWithTable:(NSString *)tableName;
/**
对所有ORM数据库表进行清空操作
*/
-(void)clearAllWithAllTables;
@end
| 12.909091 | 62 | 0.688732 | [
"model"
] |
439888d2ed44a1a852cdd622d2ca6fe5db7552d5 | 299,600 | c | C | decompiled_scripts/fbi4_prep1.c | BitDEVil2K16-Club/GTA-V-Decompiled-Scripts | bcb95d3b95482713fe0ab389edb90aea3941affd | [
"Unlicense"
] | null | null | null | decompiled_scripts/fbi4_prep1.c | BitDEVil2K16-Club/GTA-V-Decompiled-Scripts | bcb95d3b95482713fe0ab389edb90aea3941affd | [
"Unlicense"
] | null | null | null | decompiled_scripts/fbi4_prep1.c | BitDEVil2K16-Club/GTA-V-Decompiled-Scripts | bcb95d3b95482713fe0ab389edb90aea3941affd | [
"Unlicense"
] | null | null | null | #region Local Var
var uLocal_0 = 0;
var uLocal_1 = 0;
int iLocal_2 = 0;
int iLocal_3 = 0;
int iLocal_4 = 0;
int iLocal_5 = 0;
int iLocal_6 = 0;
int iLocal_7 = 0;
int iLocal_8 = 0;
int iLocal_9 = 0;
int iLocal_10 = 0;
int iLocal_11 = 0;
var uLocal_12 = 0;
var uLocal_13 = 0;
float fLocal_14 = 0f;
var uLocal_15 = 0;
var uLocal_16 = 0;
int iLocal_17 = 0;
var uLocal_18 = 0;
var uLocal_19 = 0;
char* sLocal_20 = NULL;
float fLocal_21 = 0f;
var uLocal_22 = 0;
var uLocal_23 = 0;
var uLocal_24 = 0;
float fLocal_25 = 0f;
float fLocal_26 = 0f;
var uLocal_27 = 0;
bool bLocal_28 = 0;
var uLocal_29 = 0;
var uLocal_30 = 0;
float fLocal_31 = 0f;
float fLocal_32 = 0f;
float fLocal_33 = 0f;
var uLocal_34 = 0;
var uLocal_35 = 0;
int iLocal_36 = 0;
int iLocal_37 = 0;
struct<4> Local_38[10];
bool bLocal_79 = 0;
var uLocal_80 = 0;
int iLocal_81 = 0;
struct<27> Local_82 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
int iLocal_109 = 0;
var uLocal_110 = 0;
struct<11> Local_111[2];
struct<25> Local_134[21];
float fLocal_660 = 0f;
int iLocal_661 = 0;
bool bLocal_662 = 0;
bool bLocal_663 = 0;
bool bLocal_664 = 0;
bool bLocal_665 = 0;
int iLocal_666 = 0;
struct<3> Local_667 = { 0, 0, 0 } ;
int iLocal_670 = 0;
var uLocal_671 = 0;
var uLocal_672 = 0;
var uLocal_673 = -1;
var uLocal_674 = 0;
var uLocal_675 = 0;
var uLocal_676 = 0;
var uLocal_677 = 0;
var uLocal_678 = 0;
var uLocal_679 = 0;
var uLocal_680 = 1000;
var uLocal_681 = 1000;
var uLocal_682 = 0;
int iLocal_683 = 0;
int iLocal_684 = 0;
int iLocal_685 = 0;
int iLocal_686 = 0;
var uLocal_687 = 0;
struct<8> Local_688[3];
var uLocal_713 = 15;
var uLocal_714 = 0;
var uLocal_715 = 0;
var uLocal_716 = 0;
var uLocal_717 = 0;
var uLocal_718 = 0;
var uLocal_719 = 0;
var uLocal_720 = 0;
var uLocal_721 = 0;
var uLocal_722 = 0;
var uLocal_723 = 0;
var uLocal_724 = 0;
var uLocal_725 = 0;
var uLocal_726 = 0;
var uLocal_727 = 0;
var uLocal_728 = 0;
var uLocal_729 = 0;
var uLocal_730 = 0;
var uLocal_731 = 0;
var uLocal_732 = 0;
var uLocal_733 = 0;
var uLocal_734 = 0;
var uLocal_735 = 0;
var uLocal_736 = 0;
var uLocal_737 = 0;
var uLocal_738 = 0;
var uLocal_739 = 0;
var uLocal_740 = 0;
var uLocal_741 = 0;
var uLocal_742 = 0;
var uLocal_743 = 0;
var uLocal_744 = 0;
var uLocal_745 = 0;
var uLocal_746 = 0;
var uLocal_747 = 0;
var uLocal_748 = 0;
var uLocal_749 = 0;
var uLocal_750 = 0;
var uLocal_751 = 0;
var uLocal_752 = 0;
var uLocal_753 = 0;
var uLocal_754 = 0;
var uLocal_755 = 0;
var uLocal_756 = 0;
var uLocal_757 = 0;
var uLocal_758 = 0;
var uLocal_759 = 0;
var uLocal_760 = 0;
var uLocal_761 = 0;
var uLocal_762 = 0;
var uLocal_763 = 0;
var uLocal_764 = 0;
var uLocal_765 = 15;
var uLocal_766 = 0;
var uLocal_767 = 0;
var uLocal_768 = 0;
var uLocal_769 = 0;
var uLocal_770 = 0;
var uLocal_771 = 0;
var uLocal_772 = 0;
var uLocal_773 = 0;
var uLocal_774 = 0;
var uLocal_775 = 0;
var uLocal_776 = 0;
var uLocal_777 = 0;
var uLocal_778 = 0;
var uLocal_779 = 0;
var uLocal_780 = 0;
var uLocal_781 = 0;
var uLocal_782 = 0;
var uLocal_783 = 0;
var uLocal_784 = 0;
var uLocal_785 = 0;
var uLocal_786 = 0;
var uLocal_787 = 0;
var uLocal_788 = 0;
var uLocal_789 = 0;
var uLocal_790 = 0;
var uLocal_791 = 0;
var uLocal_792 = 0;
var uLocal_793 = 0;
var uLocal_794 = 0;
var uLocal_795 = 0;
var uLocal_796 = 0;
var uLocal_797 = 0;
var uLocal_798 = 0;
var uLocal_799 = 0;
var uLocal_800 = 0;
var uLocal_801 = 0;
var uLocal_802 = 0;
var uLocal_803 = 0;
var uLocal_804 = 0;
var uLocal_805 = 0;
var uLocal_806 = 0;
var uLocal_807 = 0;
var uLocal_808 = 0;
var uLocal_809 = 0;
var uLocal_810 = 0;
var uLocal_811 = 0;
var uLocal_812 = 0;
var uLocal_813 = 0;
var uLocal_814 = 0;
var uLocal_815 = 0;
var uLocal_816 = 0;
int iLocal_817 = 0;
char* sLocal_818 = NULL;
char* sLocal_819 = NULL;
int iLocal_820 = 0;
int iLocal_821 = 0;
int iLocal_822 = 0;
var uLocal_823 = 0;
struct<3> Local_824 = { 0, 0, 0 } ;
struct<3> Local_827 = { 0, 0, 0 } ;
int iLocal_830 = 0;
int iLocal_831 = 0;
int iLocal_832 = 0;
bool bLocal_833 = 0;
int iLocal_834 = 0;
int iLocal_835 = 0;
int iLocal_836 = 0;
int iLocal_837 = 0;
int iLocal_838 = 0;
int iLocal_839 = 0;
struct<14> Local_840 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
struct<14> Local_854 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
struct<6> Local_868 = { 0, 0, 0, 0, 0, 0 } ;
int iLocal_874 = 0;
var uLocal_875 = 0;
var uLocal_876 = 0;
int iLocal_877 = 0;
char[] cLocal_878[8] = 0;
var uLocal_879 = 16;
var uLocal_880 = 0;
var uLocal_881 = 0;
var uLocal_882 = 0;
var uLocal_883 = 0;
var uLocal_884 = 0;
var uLocal_885 = 0;
var uLocal_886 = 0;
var uLocal_887 = 0;
var uLocal_888 = 0;
var uLocal_889 = 0;
var uLocal_890 = 0;
var uLocal_891 = 0;
var uLocal_892 = 0;
var uLocal_893 = 0;
var uLocal_894 = 0;
var uLocal_895 = 0;
var uLocal_896 = 0;
var uLocal_897 = 0;
var uLocal_898 = 0;
var uLocal_899 = 0;
var uLocal_900 = 0;
var uLocal_901 = 0;
var uLocal_902 = 0;
var uLocal_903 = 0;
var uLocal_904 = 0;
var uLocal_905 = 0;
var uLocal_906 = 0;
var uLocal_907 = 0;
var uLocal_908 = 0;
var uLocal_909 = 0;
var uLocal_910 = 0;
var uLocal_911 = 0;
var uLocal_912 = 0;
var uLocal_913 = 0;
var uLocal_914 = 0;
var uLocal_915 = 0;
var uLocal_916 = 0;
var uLocal_917 = 0;
var uLocal_918 = 0;
var uLocal_919 = 0;
var uLocal_920 = 0;
var uLocal_921 = 0;
var uLocal_922 = 0;
var uLocal_923 = 0;
var uLocal_924 = 0;
var uLocal_925 = 0;
var uLocal_926 = 0;
var uLocal_927 = 0;
var uLocal_928 = 0;
var uLocal_929 = 0;
var uLocal_930 = 0;
var uLocal_931 = 0;
var uLocal_932 = 0;
var uLocal_933 = 0;
var uLocal_934 = 0;
var uLocal_935 = 0;
var uLocal_936 = 0;
var uLocal_937 = 0;
var uLocal_938 = 0;
var uLocal_939 = 0;
var uLocal_940 = 0;
var uLocal_941 = 0;
var uLocal_942 = 0;
var uLocal_943 = 0;
var uLocal_944 = 0;
var uLocal_945 = 0;
var uLocal_946 = 0;
var uLocal_947 = 0;
var uLocal_948 = 0;
var uLocal_949 = 0;
var uLocal_950 = 0;
var uLocal_951 = 0;
var uLocal_952 = 0;
var uLocal_953 = 0;
var uLocal_954 = 0;
var uLocal_955 = 0;
var uLocal_956 = 0;
var uLocal_957 = 0;
var uLocal_958 = 0;
var uLocal_959 = 0;
var uLocal_960 = 0;
var uLocal_961 = 0;
var uLocal_962 = 0;
var uLocal_963 = 0;
var uLocal_964 = 0;
var uLocal_965 = 0;
var uLocal_966 = 0;
var uLocal_967 = 0;
var uLocal_968 = 0;
var uLocal_969 = 0;
var uLocal_970 = 0;
var uLocal_971 = 0;
var uLocal_972 = 0;
var uLocal_973 = 0;
var uLocal_974 = 0;
var uLocal_975 = 0;
var uLocal_976 = 0;
var uLocal_977 = 0;
var uLocal_978 = 0;
var uLocal_979 = 0;
var uLocal_980 = 0;
var uLocal_981 = 0;
var uLocal_982 = 0;
var uLocal_983 = 0;
var uLocal_984 = 0;
var uLocal_985 = 0;
var uLocal_986 = 0;
var uLocal_987 = 0;
var uLocal_988 = 0;
var uLocal_989 = 0;
var uLocal_990 = 0;
var uLocal_991 = 0;
var uLocal_992 = 0;
var uLocal_993 = 0;
var uLocal_994 = 0;
var uLocal_995 = 0;
var uLocal_996 = 0;
var uLocal_997 = 0;
var uLocal_998 = 0;
var uLocal_999 = 0;
var uLocal_1000 = 0;
var uLocal_1001 = 0;
var uLocal_1002 = 0;
var uLocal_1003 = 0;
var uLocal_1004 = 0;
var uLocal_1005 = 0;
var uLocal_1006 = 0;
var uLocal_1007 = 0;
var uLocal_1008 = 0;
var uLocal_1009 = 0;
var uLocal_1010 = 0;
var uLocal_1011 = 0;
var uLocal_1012 = 0;
var uLocal_1013 = 0;
var uLocal_1014 = 0;
var uLocal_1015 = 0;
var uLocal_1016 = 0;
var uLocal_1017 = 0;
var uLocal_1018 = 0;
var uLocal_1019 = 0;
var uLocal_1020 = 0;
var uLocal_1021 = 0;
var uLocal_1022 = 0;
var uLocal_1023 = 0;
var uLocal_1024 = 0;
var uLocal_1025 = 0;
var uLocal_1026 = 0;
var uLocal_1027 = 0;
var uLocal_1028 = 0;
var uLocal_1029 = 0;
var uLocal_1030 = 0;
var uLocal_1031 = 0;
var uLocal_1032 = 0;
var uLocal_1033 = 0;
var uLocal_1034 = 0;
var uLocal_1035 = 0;
var uLocal_1036 = 0;
var uLocal_1037 = 0;
var uLocal_1038 = 0;
var uLocal_1039 = 0;
var uLocal_1040 = 0;
var uLocal_1041 = 0;
var uLocal_1042 = 0;
var uLocal_1043 = 0;
char[] cLocal_1044[8] = 0;
var uLocal_1045 = 0;
var uLocal_1046 = 0;
var uLocal_1047 = 0;
int iLocal_1048[3] = { 0, 0, 0 };
int iLocal_1052 = 0;
#endregion
void __EntryFunction__()
{
iLocal_2 = 1;
iLocal_3 = 134;
iLocal_4 = 134;
iLocal_5 = 1;
iLocal_6 = 1;
iLocal_7 = 1;
iLocal_8 = 134;
iLocal_9 = 1;
iLocal_10 = 12;
iLocal_11 = 12;
fLocal_14 = 0.001f;
iLocal_17 = -1;
sLocal_20 = "NULL";
fLocal_21 = 0f;
fLocal_25 = -0.0375f;
fLocal_26 = 0.17f;
fLocal_31 = 80f;
fLocal_32 = 140f;
fLocal_33 = 180f;
iLocal_36 = 3;
iLocal_81 = 21;
fLocal_660 = -1f;
Local_667 = { 0f, 0f, 0f };
iLocal_670 = -1;
sLocal_819 = "FBIPRA";
Local_824 = { 0f, 0f, 0f };
Local_827 = { 1381.472f, -2072.245f, 50.9981f };
cLocal_878 = "FIBP1AU";
iLocal_1052 = -1;
unk_0xC189FA1CE4E3B2A5(1);
if (unk_0x4210287E2833D44B(19))
{
sLocal_818 = 0;
func_387();
func_375();
}
func_358();
if (func_357())
{
func_356(918.8851f, -269.789f, 67.2145f, 68.2149f, 1, 0);
}
func_342();
while (true)
{
unk_0xE9F487B66E055135("M_TrT", 0);
if (func_341(unk_0x7D2B9E6A64637269()))
{
func_337();
func_333();
unk_0x6906086484B6A5CE(unk_0x1146A9AE09CE2B14());
unk_0xCAFB54B99BF4F907(0.8f);
switch (iLocal_683)
{
case 0:
func_270();
break;
case 1:
func_239();
break;
case 2:
func_221();
break;
case 3:
func_108();
break;
case 4:
func_39();
break;
case 5:
func_1();
break;
}
if (iLocal_683 != 5)
{
if (iLocal_683 >= 0 && !bLocal_28)
{
}
}
}
SYSTEM::WAIT(0);
}
}
void func_1()
{
int iVar0;
switch (iLocal_684)
{
case 0:
unk_0x1036762BD3781C84();
unk_0x66AE54CE92457FEE(1);
func_38();
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
iVar0 = unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0);
if (func_37(iVar0) && unk_0x6471F4759775FCA4(iVar0) == joaat("towtruck"))
{
func_36(iVar0, 2);
}
}
if (!unk_0xAB6A270F84A8781E(sLocal_818))
{
func_34(sLocal_818);
}
else
{
func_18(0);
}
iLocal_684 = 1;
break;
case 1:
if (func_17())
{
if (func_16())
{
func_11();
}
func_2();
unk_0x6AF7EE4DD9F8B944(unk_0xD6E677FAD7521410(unk_0x7D2B9E6A64637269(), 1), 30f, 1, 0, 0, 0);
func_375();
}
break;
}
}
void func_2()
{
func_9(&Local_868);
func_9(&uLocal_875);
func_9(&iLocal_874);
func_8(&Local_840);
func_8(&Local_854);
func_9(&uLocal_876);
func_3();
}
void func_3()
{
func_7(&(Local_111[0 /*11*/].f_4));
func_7(&(Local_111[1 /*11*/].f_4));
func_6(&iLocal_109);
func_5(&(Local_111[0 /*11*/]), 1, 0, 1);
func_5(&(Local_111[1 /*11*/]), 1, 0, 1);
func_4(&(Local_134[iLocal_661 /*25*/].f_17), 0);
unk_0x45881466B05A8703(uLocal_80);
unk_0xF9135F131C423364("missfbi4prepp1");
unk_0x513390158FC17713("missfbi4prepp1_garbageman");
}
void func_4(var uParam0, bool bParam1)
{
if (unk_0x419E13582192CFEA(*uParam0))
{
if (unk_0xD79E16EA1337F8F9(*uParam0))
{
unk_0x3211C35423263392(*uParam0, 1, 1);
}
if (!bParam1)
{
unk_0x39E572BDDBA714A2(uParam0);
}
else
{
unk_0xF0BD1DDC919E4BA7(*uParam0);
}
}
}
void func_5(var uParam0, int iParam1, int iParam2, int iParam3)
{
if (unk_0x419E13582192CFEA(*uParam0))
{
if (!unk_0xECEC7528A52B4EE8(*uParam0))
{
unk_0x46EDFC827DC67D89(*uParam0, 0, 1);
if (iParam3 == 0)
{
unk_0xB154967CB3B9C1CF(*uParam0);
}
unk_0x504B26425DFF773C(*uParam0, iParam1);
if (iParam2 == 1)
{
unk_0xBE91B077ADADE97F(*uParam0, false);
}
}
unk_0x0F3BD19FF11738D3(uParam0);
}
}
void func_6(var uParam0)
{
if (unk_0x419E13582192CFEA(*uParam0))
{
unk_0xE50EB54E0F21BED0(*uParam0, 0);
if (unk_0xEE1D92A39CF8E1E6(*uParam0) && unk_0x9984C023D4E57C2E(*uParam0, 1))
{
unk_0x795957CD3A0042C8(uParam0);
}
}
}
void func_7(int iParam0)
{
if (unk_0x575B7C28D81C0B4D(*iParam0))
{
unk_0x13CC211F9F7ACE7F(*iParam0, 0);
unk_0x1AD5BCFEC31BB8D9(iParam0);
}
}
void func_8(int iParam0)
{
if (unk_0x419E13582192CFEA(*iParam0))
{
if (!unk_0xE50EB54E0F21BED0(*iParam0, 0))
{
unk_0x46EDFC827DC67D89(*iParam0, 0, 1);
}
if (!unk_0xEE1D92A39CF8E1E6(*iParam0))
{
unk_0x4985CD0720AFD468(*iParam0, 1, 0);
}
unk_0xC606AE2A3209945E(iParam0);
}
}
void func_9(var uParam0)
{
if (unk_0x419E13582192CFEA(*uParam0))
{
if (!unk_0xEE1D92A39CF8E1E6(*uParam0))
{
unk_0x4985CD0720AFD468(*uParam0, 1, 0);
}
if (func_37(*uParam0))
{
if (unk_0xEE1D92A39CF8E1E6(*uParam0) && unk_0x9984C023D4E57C2E(*uParam0, 1))
{
if (func_10(unk_0x7D2B9E6A64637269()))
{
if (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), *uParam0, 0))
{
unk_0x795957CD3A0042C8(uParam0);
return;
}
}
unk_0x5420D0D520CF44D0(uParam0);
}
}
else
{
if (func_10(unk_0x7D2B9E6A64637269()))
{
if (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), *uParam0, 0))
{
unk_0x795957CD3A0042C8(uParam0);
return;
}
}
unk_0x5420D0D520CF44D0(uParam0);
}
}
}
int func_10(int iParam0)
{
if (unk_0x419E13582192CFEA(iParam0))
{
if (!unk_0xE50EB54E0F21BED0(iParam0, 0))
{
return 1;
}
}
return 0;
}
void func_11()
{
func_14(918.8851f, -269.789f, 67.2145f, 325.9081f);
func_12(917.5291f, -263.8595f, 67.3489f, 188.0605f);
}
void func_12(struct<3> Param0, float fParam3)
{
func_13(&(Global_105842.f_2890), Param0, fParam3);
}
void func_13(var uParam0, struct<3> Param1, var uParam4)
{
*uParam0 = { Param1 };
uParam0->f_6 = uParam4;
}
void func_14(struct<3> Param0, float fParam3)
{
if (func_15(Global_77488, 0f, 0f, 0f, 0))
{
Global_77488 = { Param0 };
Global_77491 = fParam3;
}
}
bool func_15(struct<3> Param0, struct<3> Param3, bool bParam6)
{
if (bParam6)
{
return (Param0.x == Param3.x && Param0.f_1 == Param3.f_1);
}
return ((Param0.x == Param3.x && Param0.f_1 == Param3.f_1) && Param0.f_2 == Param3.f_2);
}
int func_16()
{
if (Global_99370 == 7)
{
return 1;
}
return 0;
}
int func_17()
{
if (Global_3)
{
return 1;
}
if (Global_99370 == 7 || Global_99370 == 8)
{
return 1;
}
return 0;
}
void func_18(int iParam0)
{
int iVar0;
if (Global_112293.f_9083 || func_33(0))
{
iVar0 = func_32();
if (!func_19(iVar0))
{
return;
}
unk_0x191DDA30577F440A(&(Global_90122[iVar0 /*5*/].f_1), 5);
Global_99406 = iParam0;
}
}
int func_19(int iParam0)
{
int iVar0;
int iVar1;
func_24();
if (unk_0xCAD1755E530A6012(unk_0x1146A9AE09CE2B14()))
{
unk_0xD91B27582ECB3B74(5000);
}
iVar0 = Global_90122[iParam0 /*5*/];
iVar1 = Global_77517.f_109[iVar0 /*4*/];
func_23(iVar1, 1);
unk_0xEB25B6CFBE0FD35C(unk_0x1146A9AE09CE2B14(), 0);
unk_0x06DFF0CF48AB014E(unk_0x1146A9AE09CE2B14(), 0);
func_20(&(Global_112293.f_2361.f_539), iVar1);
if (Global_93545 == Global_99407)
{
Global_112293.f_9083.f_330[iVar1 /*6*/].f_1++;
}
if (!unk_0x234B68AC2E35ED5A(Global_90158[iVar1 /*34*/].f_15, 1))
{
if (!unk_0xCAD1755E530A6012(unk_0x1146A9AE09CE2B14()))
{
unk_0x79B648063E94A67F(0);
}
}
Global_112293.f_9083.f_330[iVar1 /*6*/].f_2++;
Global_93545 = Global_99407;
if (iParam0 == -1)
{
if (Global_112293.f_9083)
{
}
return 0;
}
if (unk_0x234B68AC2E35ED5A(Global_90122[iParam0 /*5*/].f_1, 4))
{
return 0;
}
if (unk_0x234B68AC2E35ED5A(Global_90122[iParam0 /*5*/].f_1, 5))
{
return 0;
}
return 1;
}
void func_20(var uParam0, int iParam1)
{
int iVar0;
int iVar1;
struct<3> Var2;
float fVar5;
if (iParam1 == 94)
{
return;
}
iVar0 = 0;
while (iVar0 < 3)
{
iVar1 = Global_112293.f_18531[iVar0];
if ((((iVar1 == 8 || iVar1 == 9) || iVar1 == 10) || (((iVar1 == 11 || iVar1 == 34) || iVar1 == 72) || iVar1 == 73)) && !unk_0x234B68AC2E35ED5A(Global_112293.f_9083.f_99.f_219[0], 9))
{
}
else
{
Var2 = { 0f, 0f, 0f };
fVar5 = 0f;
if (!func_22(Global_112293.f_18531[iVar0], &Var2, &fVar5))
{
Global_112293.f_18531[iVar0] = 318;
func_21(&(uParam0->f_2296[iVar0]));
uParam0->f_2300[iVar0 /*3*/] = { 0f, 0f, 0f };
uParam0->f_2310[iVar0] = 0f;
uParam0->f_2314[iVar0] = 0;
uParam0->f_2318[iVar0 /*3*/] = { 0f, 0f, 0f };
uParam0->f_2328[iVar0] = 0;
Global_96760[iVar0 /*29*/] = { 0f, 0f, 0f };
Global_96760[iVar0 /*29*/].f_9 = 0f;
Global_96760[iVar0 /*29*/].f_12 = 0f;
Global_96760[iVar0 /*29*/].f_3 = { 0f, 0f, 0f };
Global_96760[iVar0 /*29*/].f_10 = 0f;
Global_96760[iVar0 /*29*/].f_13 = 0f;
Global_96760[iVar0 /*29*/].f_6 = { 0f, 0f, 0f };
Global_96760[iVar0 /*29*/].f_11 = 0f;
Global_96760[iVar0 /*29*/].f_14 = 0f;
Global_96760[iVar0 /*29*/].f_17 = { 0f, 0f, 0f };
Global_96760[iVar0 /*29*/].f_26 = 0f;
Global_96760[iVar0 /*29*/].f_20 = { 0f, 0f, 0f };
Global_96760[iVar0 /*29*/].f_27 = 0f;
Global_96760[iVar0 /*29*/].f_23 = { 0f, 0f, 0f };
Global_96760[iVar0 /*29*/].f_28 = 0f;
}
}
iVar0++;
}
}
void func_21(var uParam0)
{
*uParam0 = -15;
}
int func_22(int iParam0, var uParam1, float fParam2)
{
switch (iParam0)
{
case 11:
*uParam1 = { 115.1569f, -1286.684f, 28.2613f };
*fParam2 = 111f;
return 1;
break;
case 8:
*uParam1 = { -90.0089f, -1324.195f, 28.3203f };
*fParam2 = 194.1887f;
return 1;
break;
case 9:
return func_22(8, uParam1, fParam2);
break;
case 10:
return func_22(8, uParam1, fParam2);
break;
case 13:
*uParam1 = { -807.2979f, -48.4004f, 36.8173f };
*fParam2 = 201.6328f;
return 1;
break;
case 14:
*uParam1 = { 1432.34f, -1887.383f, 70.5768f };
*fParam2 = 350.0509f;
return 1;
break;
case 15:
*uParam1 = { 1666.204f, 1967.25f, 143.3213f };
*fParam2 = 0.7896f;
return 1;
break;
case 12:
*uParam1 = { -1440.22f, -127.02f, 50f };
*fParam2 = 42f;
return 1;
break;
case 16:
*uParam1 = { 135.055f, -1759.64f, 27.8957f };
*fParam2 = -129f;
return 1;
break;
case 17:
*uParam1 = { 687.6992f, -1744.03f, 28.3624f };
*fParam2 = 267.1409f;
return 1;
break;
case 18:
*uParam1 = { 56.5117f, -744.6122f, 43.1356f };
*fParam2 = 340.0526f;
return 1;
break;
case 19:
*uParam1 = { 506.485f, -1884.967f, 24.764f };
*fParam2 = 22.9566f;
return 1;
break;
case 20:
*uParam1 = { 1555.958f, 953.6136f, 77.2063f };
*fParam2 = 152.8118f;
return 1;
break;
case 21:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 22:
*uParam1 = { 220.72f, -64.4177f, 68.2922f };
*fParam2 = (250.4535f - 360f);
return 1;
break;
case 74:
*uParam1 = { 2048.07f, 3840.84f, 34.2238f };
*fParam2 = 119.603f;
return 1;
break;
case 23:
*uParam1 = { -464.22f, -1592.98f, 38.73f };
*fParam2 = 168f;
return 1;
break;
case 24:
*uParam1 = { (744.79f + 0.0186f), (-465.86f - 0.0114f), 36.6399f };
*fParam2 = 51.7279f;
return 1;
break;
case 67:
*uParam1 = { -9f, 508.1f, 173.6278f };
*fParam2 = 151.2504f;
return 1;
break;
case 25:
*uParam1 = { 72.2278f, -1464.68f, 28.2915f };
*fParam2 = 156.8827f;
return 1;
break;
case 27:
*uParam1 = { 763f, -906f, 24.2312f };
*fParam2 = 7.2736f;
return 1;
break;
case 26:
*uParam1 = { 257.9167f, -1120.786f, 28.3684f };
*fParam2 = 97.2736f;
return 1;
break;
case 28:
*uParam1 = { 422.5858f, -978.6332f, 69.7073f };
*fParam2 = 4f;
return 1;
break;
case 29:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 30:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 31:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 32:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 33:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 34:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 35:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 36:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 37:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 58:
*uParam1 = { 294.8521f, 882.9366f, 197.8527f };
*fParam2 = 162.693f;
return 1;
break;
case 59:
*uParam1 = { -1771.802f, 794.4316f, 138.4211f };
*fParam2 = 128.9946f;
return 1;
break;
case 60:
*uParam1 = { 1495.595f, -1848.821f, 70.2075f };
*fParam2 = 32.2721f;
return 1;
break;
case 38:
*uParam1 = { 2897.554f, 4032.241f, 50.1419f };
*fParam2 = 192.8091f;
return 1;
break;
case 39:
*uParam1 = { 1973.355f, 3818.204f, 32.005f };
*fParam2 = 32f;
return 1;
break;
case 40:
*uParam1 = { 1973.355f, 3818.204f, 32.005f };
*fParam2 = 32f;
return 1;
break;
case 41:
*uParam1 = { 1397f, 3725.8f, 33.0673f };
*fParam2 = -3.7534f;
return 1;
break;
case 42:
*uParam1 = { Vector(4.0205f, -2975.341f, 798.4536f) + Vector(1f, 0f, 0f) };
*fParam2 = 90f;
return 1;
break;
case 43:
*uParam1 = { 709.0244f, -2916.479f, 5.0589f };
*fParam2 = 355.326f;
return 1;
break;
case 44:
*uParam1 = { 643.5248f, -2917.325f, 5.1337f };
*fParam2 = 334.1068f;
return 1;
break;
case 45:
*uParam1 = { 595.2742f, -2819.183f, 5.0559f };
*fParam2 = 46.8853f;
return 1;
break;
case 46:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 47:
*uParam1 = { 314.4171f, 965.207f, 208.4024f };
*fParam2 = 165.9421f;
return 1;
break;
case 49:
*uParam1 = { 3321.537f, 4975.455f, 25.9097f };
*fParam2 = 221.228f;
return 1;
break;
case 48:
*uParam1 = { -111.1318f, 6316.479f, 30.4904f };
*fParam2 = (42f + 180f);
return 1;
break;
case 50:
*uParam1 = { -731.3261f, 106.68f, 54.7169f };
*fParam2 = 98.9764f;
return 1;
break;
case 51:
*uParam1 = { -1257.5f, -526.9999f, 30.2361f };
*fParam2 = 220.9554f;
return 1;
break;
case 52:
*uParam1 = { 736.9869f, -2050.678f, 28.2718f };
*fParam2 = 83.9922f;
return 1;
break;
case 66:
*uParam1 = { 262.5499f, -2540.15f, 4.8433f };
*fParam2 = -64.1366f;
return 1;
break;
case 53:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 55:
*uParam1 = { -315.7789f, 6201.355f, 30.4322f };
*fParam2 = 127.7547f;
return 1;
break;
case 56:
*uParam1 = { 118.0988f, -1264.916f, 32.3637f };
*fParam2 = -63f;
return 1;
break;
case 57:
*uParam1 = { 37.5988f, -1351.52f, 28.2954f };
*fParam2 = 90.0339f;
return 1;
break;
case 61:
*uParam1 = { -558.2693f, 261.1167f, 82.07f };
*fParam2 = 84.6231f;
return 1;
break;
case 62:
*uParam1 = { -196.9999f, 507.9999f, 132.477f };
*fParam2 = 99.6049f;
return 1;
break;
case 63:
*uParam1 = { 1312.01f, -1645.87f, 51.2f };
*fParam2 = 120f;
return 1;
break;
case 68:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 69:
*uParam1 = { -818.7374f, 6.4824f, 41.2432f };
*fParam2 = 211.8223f;
return 1;
break;
case 64:
*uParam1 = { 2091.258f, 4714.852f, 40.1936f };
*fParam2 = 136.0867f;
return 1;
break;
case 54:
*uParam1 = { 1762.59f, 3247.212f, 40.735f };
*fParam2 = 27.0648f;
return 1;
break;
case 65:
*uParam1 = { 1764.013f, 3252.902f, 40.735f };
*fParam2 = 27.0648f;
return 1;
break;
case 70:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 71:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 72:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
case 73:
*uParam1 = { 0f, 0f, 0f };
*fParam2 = 0f;
return 1;
break;
default:
break;
}
return 0;
}
void func_23(int iParam0, bool bParam1)
{
if (bParam1)
{
if ((iParam0 != 88 && iParam0 != 89) && iParam0 != 92)
{
Global_93355[iParam0 /*2*/] = 1;
}
}
else
{
Global_93355[iParam0 /*2*/] = 0;
}
}
void func_24()
{
Global_99405 = 1;
if (unk_0x4766CFEFD1C88C1A(unk_0x1146A9AE09CE2B14(), 1))
{
if (unk_0xAB6A270F84A8781E(&Global_77480))
{
switch (func_25())
{
case 0:
StringCopy(&Global_77480, "CMN_MARRE", 16);
break;
case 1:
StringCopy(&Global_77480, "CMN_FARRE", 16);
break;
case 2:
StringCopy(&Global_77480, "CMN_TARRE", 16);
break;
}
StringCopy(&Global_77484, "", 16);
}
Global_99405 = 0;
}
else if (!unk_0xCAD1755E530A6012(unk_0x1146A9AE09CE2B14()))
{
if (unk_0xAB6A270F84A8781E(&Global_77480))
{
switch (func_25())
{
case 0:
StringCopy(&Global_77480, "CMN_MDIED", 16);
break;
case 1:
StringCopy(&Global_77480, "CMN_FDIED", 16);
break;
case 2:
StringCopy(&Global_77480, "CMN_TDIED", 16);
break;
}
StringCopy(&Global_77484, "", 16);
}
Global_99405 = 0;
unk_0x191DDA30577F440A(&(Global_99370.f_20), 25);
}
}
int func_25()
{
func_26();
return Global_112293.f_2361.f_539.f_4321;
}
void func_26()
{
int iVar0;
if (unk_0x419E13582192CFEA(unk_0x7D2B9E6A64637269()))
{
if (func_30(Global_112293.f_2361.f_539.f_4321) != unk_0x6471F4759775FCA4(unk_0x7D2B9E6A64637269()))
{
iVar0 = func_29(unk_0x7D2B9E6A64637269());
if (func_28(iVar0) && (!func_27(14) || Global_111244))
{
if (Global_112293.f_2361.f_539.f_4321 != iVar0 && func_28(Global_112293.f_2361.f_539.f_4321))
{
Global_112293.f_2361.f_539.f_4322 = Global_112293.f_2361.f_539.f_4321;
}
Global_112293.f_2361.f_539.f_4323 = iVar0;
Global_112293.f_2361.f_539.f_4321 = iVar0;
return;
}
}
else
{
if (Global_112293.f_2361.f_539.f_4321 != 145)
{
Global_112293.f_2361.f_539.f_4323 = Global_112293.f_2361.f_539.f_4321;
}
return;
}
}
Global_112293.f_2361.f_539.f_4321 = 145;
}
bool func_27(int iParam0)
{
return Global_42009 == iParam0;
}
bool func_28(int iParam0)
{
return iParam0 < 3;
}
int func_29(int iParam0)
{
int iVar0;
int iVar1;
if (unk_0x419E13582192CFEA(iParam0))
{
iVar1 = unk_0x6471F4759775FCA4(iParam0);
iVar0 = 0;
while (iVar0 <= 2)
{
if (func_30(iVar0) == iVar1)
{
return iVar0;
}
iVar0++;
}
}
return 145;
}
int func_30(int iParam0)
{
if (func_28(iParam0))
{
return func_31(iParam0);
}
else if (iParam0 != 145)
{
}
return 0;
}
var func_31(int iParam0)
{
return Global_1878[iParam0 /*29*/];
}
int func_32()
{
int iVar0;
iVar0 = 0;
iVar0 = 0;
while (iVar0 < 7)
{
if (unk_0x234B68AC2E35ED5A(Global_90122[iVar0 /*5*/].f_1, 2))
{
return iVar0;
}
iVar0++;
}
return -1;
}
bool func_33(bool bParam0)
{
if (!bParam0 && unk_0x636F1F53CC61D2C9(joaat("benchmark")) > 0)
{
return 1;
}
return unk_0x234B68AC2E35ED5A(Global_77496, 0);
}
void func_34(char* sParam0)
{
func_35(sParam0);
func_18(0);
}
void func_35(char* sParam0)
{
if (!unk_0xAB6A270F84A8781E(sParam0))
{
if (unk_0xA3A3E3B836DB6D5B(sParam0) <= 16)
{
StringCopy(&Global_77480, sParam0, 16);
StringCopy(&Global_77484, "", 16);
if (unk_0x2D54F00919E36B63())
{
unk_0xAD9DFA8200EA2A8A();
}
}
}
}
void func_36(int iParam0, int iParam1)
{
Global_99370.f_22[iParam1] = iParam0;
}
int func_37(int iParam0)
{
if (func_10(iParam0))
{
if (unk_0xBFCE58B2B3249999(iParam0, 0))
{
if (!unk_0x2AB8EC6521549BAD(iParam0))
{
return 1;
}
}
}
return 0;
}
void func_38()
{
func_7(&iLocal_821);
}
void func_39()
{
int iVar0;
switch (iLocal_684)
{
case 0:
iLocal_684 = 1;
break;
case 1:
if (!func_107(unk_0x7D2B9E6A64637269(), Local_827, 270f))
{
iLocal_684 = 2;
}
else if (!func_106("PRA_LEVAREA", 0, 0))
{
func_105("PRA_LEVAREA", 60000, 0);
}
break;
case 2:
iVar0 = func_25();
if (func_106("PRA_LEVAREA", 0, 0))
{
unk_0x1036762BD3781C84();
}
if (iVar0 == 0)
{
if (func_67(&uLocal_687, &cLocal_1044, &uLocal_879))
{
func_63();
func_58();
}
}
else
{
func_53(func_57(iVar0), -621899663, -621899663, 5, 0, iVar0, func_56(iVar0), 0, 6000, 6000, -1, 0, 0);
func_63();
func_58();
}
break;
case 3:
func_40(1, 1, 1);
iLocal_684 = 2;
break;
}
}
void func_40(int iParam0, int iParam1, int iParam2)
{
func_42(0, 0, iParam2, 1);
if (iParam0 == 1)
{
unk_0x3A13FD2813C8251F(0f, 1065353216);
unk_0xDF23DCD7A3E1B7A5(0f);
}
if (iParam1 == 1)
{
func_41(500, 0);
}
}
void func_41(int iParam0, bool bParam1)
{
if (unk_0x8B6A925F148E0E94() || unk_0x4E38E404B98F3D9A())
{
if (!unk_0x07BE48DF95787FCB())
{
unk_0x6E1E3A5B1F9AB95B(iParam0);
}
}
if (bParam1)
{
while (!unk_0xE0A6F16F546C8274())
{
SYSTEM::WAIT(0);
}
}
}
void func_42(int iParam0, int iParam1, int iParam2, int iParam3)
{
var uVar0;
uVar0 = unk_0x638BDC79E655C1C2();
unk_0xD0F4606D5A7F6B9A(uVar0, 0);
unk_0xF99B8860747709DD(uVar0, iParam3, 0);
func_43(0, 1, 0, 0, 0, 0, 0);
if (iParam2 == 1)
{
unk_0xDD7C2F9844E745B1(1);
unk_0x4200138CBB376D4D(1);
}
unk_0x66AE54CE92457FEE(1);
if (iParam0 == 1)
{
unk_0x2CA971FF57ACA369(0, 0);
}
if (iParam1 == 1)
{
if ((iLocal_37 != 0 && iLocal_37 != joaat("object")) && iLocal_37 != joaat("gadget_parachute"))
{
if (func_10(unk_0x7D2B9E6A64637269()))
{
if (unk_0x6CEA35622FBD9702(unk_0x7D2B9E6A64637269(), iLocal_37, 0))
{
unk_0x2FF622571073AA69(unk_0x7D2B9E6A64637269(), iLocal_37, 0);
}
}
}
}
if (func_341(unk_0x7D2B9E6A64637269()))
{
unk_0x6C59944A0530A574(unk_0x7D2B9E6A64637269(), 0, 0);
}
}
void func_43(bool bParam0, bool bParam1, int iParam2, int iParam3, bool bParam4, bool bParam5, bool bParam6)
{
if (bParam0)
{
unk_0x5359E9154EC8BC8F(unk_0x1146A9AE09CE2B14(), 0);
unk_0x76E35164CB4968C4(unk_0x1146A9AE09CE2B14(), 1);
unk_0x987940DFD4A807FF(unk_0x1146A9AE09CE2B14(), 1);
func_52(1);
unk_0x8F639D0D922F6888();
unk_0x97B846780E2A8C66();
if (Global_19798.f_1 > 3 && !bParam6)
{
if (unk_0x8820F6FCD373F9F7())
{
unk_0x75B41F5020877259(0);
}
if (!func_51())
{
Global_19798.f_1 = 3;
}
Global_21125 = 5;
}
func_50(1, iParam3, iParam2, 0);
Global_62104 = 1;
Global_74431 = 1;
Global_77246 = 1;
}
else
{
func_52(0);
unk_0xE1AA8B5D9066529D();
Global_62104 = 0;
if (bParam1)
{
unk_0xDFEA7BB6BBCCEC80();
}
unk_0x76E35164CB4968C4(unk_0x1146A9AE09CE2B14(), 0);
unk_0x987940DFD4A807FF(unk_0x1146A9AE09CE2B14(), 0);
func_50(0, iParam3, iParam2, 0);
if (unk_0x02BFF15CAA701972())
{
if (((((!unk_0xECEC7528A52B4EE8(unk_0x7D2B9E6A64637269()) && !func_48(unk_0x1146A9AE09CE2B14())) && !func_45(unk_0x1146A9AE09CE2B14(), 0)) && !func_44()) && !bParam4) && !bParam5)
{
unk_0x8F160110753EB17B(unk_0x7D2B9E6A64637269(), 0);
}
}
else if (((!unk_0xECEC7528A52B4EE8(unk_0x7D2B9E6A64637269()) && !func_48(unk_0x1146A9AE09CE2B14())) && !bParam4) && !bParam5)
{
unk_0x8F160110753EB17B(unk_0x7D2B9E6A64637269(), 0);
}
Global_77246 = 0;
}
}
bool func_44()
{
return unk_0x234B68AC2E35ED5A(Global_1590908[unk_0x1146A9AE09CE2B14() /*874*/].f_36.f_18, 14);
}
bool func_45(int iParam0, int iParam1)
{
bool bVar0;
if (iParam0 == unk_0x1146A9AE09CE2B14())
{
bVar0 = func_46(-1, 0) == 8;
}
else
{
bVar0 = Global_1590908[iParam0 /*874*/].f_205 == 8;
}
if (iParam1 == 1)
{
if (unk_0x8CFC2F41A749E236(iParam0))
{
bVar0 = unk_0x7C3E030BC3ED6671(iParam0) == 8;
}
}
return bVar0;
}
int func_46(int iParam0, bool bParam1)
{
int iVar0;
int iVar1;
iVar1 = iParam0;
if (iVar1 == -1)
{
iVar1 = func_47();
}
if (Global_1312882[iVar1] == 1)
{
if (bParam1)
{
}
iVar0 = 8;
}
else
{
iVar0 = Global_1312757[iVar1];
if (bParam1)
{
}
}
return iVar0;
}
int func_47()
{
return Global_1312763;
}
int func_48(int iParam0)
{
if (func_45(iParam0, 0))
{
return 1;
}
if (func_49())
{
if (iParam0 == unk_0x1146A9AE09CE2B14())
{
return 1;
}
}
if (unk_0x234B68AC2E35ED5A(Global_2426865[iParam0 /*449*/].f_199, 2))
{
return 1;
}
return 0;
}
bool func_49()
{
return unk_0x234B68AC2E35ED5A(Global_2359302, 3);
}
int func_50(int iParam0, var uParam1, var uParam2, int iParam3)
{
int iVar0;
iVar0 = 0;
if (unk_0x3640D836D145B814())
{
if (unk_0xFBB350E73795834E() != iParam0 && uParam2)
{
unk_0x31F2EFD33130D530(iParam0, uParam1, 1, iParam3);
iVar0 = 1;
}
}
return iVar0;
}
int func_51()
{
if (Global_19798.f_1 == 1 || Global_19798.f_1 == 0)
{
return 1;
}
return 0;
}
void func_52(int iParam0)
{
if (iParam0 == 1)
{
unk_0x191DDA30577F440A(&Global_7668, 13);
}
else
{
unk_0xC664C0067EEAB8D1(&Global_7668, 13);
}
}
int func_53(var uParam0, int iParam1, int iParam2, int iParam3, int iParam4, int iParam5, int iParam6, int iParam7, int iParam8, int iParam9, int iParam10, int iParam11, int iParam12)
{
struct<15> Var0;
int iVar15;
if (func_33(0))
{
return 0;
}
if (iParam8 < 0)
{
return 0;
}
if (iParam9 < 0)
{
return 0;
}
if (iParam10 == 76)
{
return 0;
}
if (iParam11 == 235)
{
return 0;
}
if (iParam6 == iParam5)
{
return 0;
}
if (((iParam5 != 144 && iParam5 != 0) && iParam5 != 1) && iParam5 != 2)
{
return 0;
}
if (Global_112293.f_7686.f_136 < 9)
{
Var0 = uParam0;
Var0.f_10 = iParam1;
Var0.f_11 = iParam2;
Var0.f_9 = iParam3;
if (Global_112293.f_7686.f_911 == Var0)
{
Global_112293.f_7686.f_911 = -1;
}
Var0.f_3 = func_55(iParam4);
Var0.f_5 = iParam9;
Var0.f_4 = (unk_0xDFB7BFA6482FEE1E() + iParam8);
Var0.f_1 = iParam12;
iVar15 = 0;
unk_0x191DDA30577F440A(&iVar15, iParam5);
Var0.f_2 = iVar15;
Var0.f_6 = iParam6;
Var0.f_14 = iParam7;
Var0.f_7 = iParam10;
Var0.f_8 = iParam11;
unk_0x191DDA30577F440A(&(Var0.f_1), 0);
unk_0x191DDA30577F440A(&(Var0.f_1), 13);
unk_0xC664C0067EEAB8D1(&(Var0.f_1), 1);
if (iParam4 == 0)
{
unk_0x191DDA30577F440A(&(Var0.f_1), 10);
}
Global_112293.f_7686[Global_112293.f_7686.f_136 /*15*/] = { Var0 };
Global_112293.f_7686.f_136++;
func_54(iParam5);
return 1;
}
return 0;
}
void func_54(int iParam0)
{
int iVar0;
int iVar1;
int iVar2;
iVar1 = 0;
if (!func_28(iParam0))
{
return;
}
iVar0 = 0;
while (iVar0 < Global_112293.f_7686.f_136)
{
if (unk_0x234B68AC2E35ED5A(Global_112293.f_7686[iVar0 /*15*/].f_2, iParam0))
{
if (Global_112293.f_7686[iVar0 /*15*/].f_3 > iVar1)
{
iVar1 = Global_112293.f_7686[iVar0 /*15*/].f_3;
}
}
iVar0++;
}
iVar2 = 0;
while (iVar2 < Global_112293.f_7686.f_764)
{
if (unk_0x234B68AC2E35ED5A(Global_112293.f_7686.f_651[iVar2 /*14*/].f_2, iParam0))
{
if (Global_112293.f_7686.f_651[iVar2 /*14*/].f_3 == 5)
{
iVar1 = 5;
}
}
iVar2++;
}
Global_112293.f_7686.f_919[iParam0] = iVar1;
}
int func_55(int iParam0)
{
switch (iParam0)
{
case 0:
case 4:
return 5;
break;
case 7:
return 4;
break;
case 2:
return 3;
break;
case 1:
return 2;
break;
case 3:
return 1;
break;
case 5:
case 6:
return 0;
break;
}
return 7;
}
int func_56(int iParam0)
{
if (iParam0 == 1)
{
return 9;
}
return 8;
}
int func_57(int iParam0)
{
if (iParam0 == 1)
{
return -714760066;
}
return -1198055521;
}
void func_58()
{
unk_0x1036762BD3781C84();
func_61();
func_59(0, 0);
func_375();
}
void func_59(bool bParam0, int iParam1)
{
int iVar0;
int iVar1;
var uVar2;
if (!Global_62100)
{
Global_62100 = iParam1;
}
if (bParam0)
{
if ((func_33(0) && Global_77494.f_1 == 1) && func_60(Global_77494))
{
}
else
{
Global_62098 = 1;
}
}
if (Global_112293.f_9083 || func_33(0))
{
iVar0 = func_32();
iVar1 = Global_90122[iVar0 /*5*/];
uVar2 = Global_77517.f_109[iVar1 /*4*/];
if (iVar0 == -1)
{
if (Global_112293.f_9083)
{
}
return;
}
if (unk_0x234B68AC2E35ED5A(Global_90122[iVar0 /*5*/].f_1, 4))
{
return;
}
if (unk_0x234B68AC2E35ED5A(Global_90122[iVar0 /*5*/].f_1, 5))
{
return;
}
unk_0x191DDA30577F440A(&(Global_90122[iVar0 /*5*/].f_1), 4);
unk_0x191DDA30577F440A(&Global_77496, 1);
Global_77512 = uVar2;
Global_77513 = unk_0xDFB7BFA6482FEE1E();
}
}
int func_60(int iParam0)
{
switch (iParam0)
{
case 71:
return 1;
break;
case 86:
return 1;
break;
case 91:
return 1;
break;
default:
return 0;
break;
}
return 0;
}
void func_61()
{
Global_19991 = 0;
func_62();
}
void func_62()
{
unk_0xBA3738C78262143F();
Global_22136 = 0;
if ((unk_0x8820F6FCD373F9F7() || Global_19798.f_1 == 9) || Global_19797 == 1)
{
unk_0x75B41F5020877259(0);
Global_21125 = 6;
Global_19798.f_1 = 3;
return;
}
if (unk_0x6C2F471E0CF8D4CF())
{
unk_0x75B41F5020877259(1);
Global_21125 = 6;
return;
}
}
void func_63()
{
func_66(0, -1);
func_65(0, 318);
func_64(1, 320);
}
void func_64(bool bParam0, int iParam1)
{
int iVar0;
if (Global_62106)
{
}
Global_62106 = 0;
if (bParam0)
{
Global_62107 = 1;
}
iVar0 = 0;
if (iParam1 == -1)
{
iVar0 = 0;
while (iVar0 < Global_74193)
{
if (Global_62323[Global_74194[iVar0 /*9*/] /*13*/] == 4)
{
Global_74194[iVar0 /*9*/].f_5 = 0;
return;
}
iVar0++;
}
}
else
{
iVar0 = 0;
while (iVar0 < Global_74193)
{
if (Global_74194[iVar0 /*9*/] > 0)
{
if (Global_74194[iVar0 /*9*/] == iParam1)
{
Global_74194[iVar0 /*9*/].f_5 = 0;
return;
}
}
iVar0++;
}
}
}
void func_65(int iParam0, int iParam1)
{
int iVar0;
Global_62111 = iParam0;
iVar0 = 0;
while (iVar0 < Global_74193)
{
if (iParam1 == -1 || Global_74194[iVar0 /*9*/] == iParam1)
{
if (Global_74194[iVar0 /*9*/].f_6 != iParam0)
{
Global_74194[iVar0 /*9*/].f_6 = iParam0;
Global_74194[iVar0 /*9*/].f_7 = 1;
Global_74194[iVar0 /*9*/].f_8 = 0;
}
}
iVar0++;
}
}
void func_66(int iParam0, int iParam1)
{
Global_62109 = iParam0;
Global_62110 = iParam1;
}
int func_67(var uParam0, char* sParam1, var uParam2)
{
switch (*uParam0)
{
case 0:
if (func_103())
{
if ((func_102(74) || func_102(75)) && func_101())
{
if (func_25() == 0)
{
func_100(1);
func_99(46, 1);
*uParam0 = 4;
}
else
{
func_98(uParam2, 0, 0, "MICHAEL", 0, 1);
if (func_82(uParam2, func_97(), func_25(), "FBIPRAU", func_96(), 9, 1, 0, 0, 0))
{
*sParam1 = { func_81(1) };
func_99(46, 1);
*uParam0 = 1;
}
}
}
else if (func_25() == 0)
{
func_100(0);
*uParam0 = 4;
}
else
{
func_98(uParam2, 0, 0, "MICHAEL", 0, 1);
if (func_82(uParam2, func_97(), func_25(), "FBIPRAU", func_96(), 9, 1, 0, 0, 0))
{
*sParam1 = { func_81(0) };
*uParam0 = 1;
}
}
}
else
{
func_74();
*uParam0 = 4;
}
break;
case 1:
if (func_73())
{
if (unk_0x9618CA3AB2A82C04() >= 0)
{
func_72("FBIPRAU", sParam1);
func_71(1);
*uParam0 = 3;
}
}
if (func_70())
{
*uParam0 = 3;
}
break;
case 2:
break;
case 3:
if (!func_73())
{
if (!func_69(0))
{
if (!func_102(3) && func_103())
{
func_68(50, 0);
}
return 1;
}
}
break;
case 4:
return 1;
break;
}
return 0;
}
void func_68(int iParam0, int iParam1)
{
if (iParam0 == 235 || iParam0 == 0)
{
return;
}
Global_112293.f_8611[iParam0] = 1;
Global_112293.f_8611.f_236[iParam0] = (unk_0xDFB7BFA6482FEE1E() + iParam1);
}
int func_69(int iParam0)
{
if (iParam0 == 1)
{
if (Global_19798.f_1 > 3)
{
if (unk_0x234B68AC2E35ED5A(Global_7668, 14))
{
return 1;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
if (unk_0x636F1F53CC61D2C9(joaat("cellphone_flashhand")) > 0)
{
return 1;
}
if (Global_19798.f_1 > 3)
{
return 1;
}
return 0;
}
int func_70()
{
if (Global_21174 == 1 || Global_22141 == 1)
{
return 1;
}
return 0;
}
void func_71(bool bParam0)
{
unk_0x75B41F5020877259(bParam0);
if (bParam0)
{
}
}
void func_72(char* sParam0, char* sParam1)
{
if (unk_0x8820F6FCD373F9F7())
{
Global_21182 = 1;
StringCopy(&Global_21189, sParam0, 24);
StringCopy(&Global_21183, sParam1, 24);
}
}
int func_73()
{
if (Global_21125 == 4)
{
if (unk_0x8820F6FCD373F9F7())
{
return 1;
}
else
{
return 0;
}
}
return 0;
}
void func_74()
{
int iVar0;
int iVar1;
iVar0 = 0;
while (iVar0 < 3)
{
iVar1 = func_79(iVar0);
if (!unk_0xECEC7528A52B4EE8(iVar1))
{
if (func_78(iVar1, 0))
{
return;
}
}
iVar0++;
}
func_75(func_76(), 0, func_25(), func_97(), 9, 6000, 6000, -1, 0, -1, 0);
}
int func_75(int iParam0, int iParam1, int iParam2, int iParam3, int iParam4, int iParam5, int iParam6, int iParam7, int iParam8, int iParam9, int iParam10)
{
struct<15> Var0;
int iVar15;
if (func_33(0))
{
return 0;
}
if (iParam5 < 0)
{
return 0;
}
if (iParam6 < 0)
{
return 0;
}
if (iParam7 == 76)
{
return 0;
}
if (iParam8 == 235)
{
return 0;
}
if (iParam3 == iParam2)
{
return 0;
}
if (((iParam2 != 144 && iParam2 != 0) && iParam2 != 1) && iParam2 != 2)
{
return 0;
}
if (Global_112293.f_7686.f_136 < 9)
{
Var0 = iParam0;
if (Global_112293.f_7686.f_911 == Var0)
{
Global_112293.f_7686.f_911 = -1;
}
Var0.f_3 = func_55(iParam1);
Var0.f_5 = iParam6;
Var0.f_4 = (unk_0xDFB7BFA6482FEE1E() + iParam5);
Var0.f_1 = iParam10;
iVar15 = 0;
unk_0x191DDA30577F440A(&iVar15, iParam2);
Var0.f_2 = iVar15;
Var0.f_6 = iParam3;
Var0.f_14 = iParam4;
Var0.f_10 = -1;
Var0.f_11 = -1;
Var0.f_7 = iParam7;
Var0.f_8 = iParam8;
Var0.f_9 = iParam9;
unk_0x191DDA30577F440A(&(Var0.f_1), 0);
unk_0xC664C0067EEAB8D1(&(Var0.f_1), 1);
if (iParam1 == 0)
{
unk_0x191DDA30577F440A(&(Var0.f_1), 10);
}
Global_112293.f_7686[Global_112293.f_7686.f_136 /*15*/] = { Var0 };
Global_112293.f_7686.f_136++;
func_54(iParam2);
return 1;
}
return 0;
}
int func_76()
{
switch (func_77())
{
case 33:
switch (func_25())
{
case 0:
return -1847734803;
break;
case 1:
return -714760066;
break;
case 2:
return -1198055521;
break;
}
break;
case 34:
switch (func_25())
{
case 0:
return 1374342572;
break;
case 1:
return 530956160;
break;
case 2:
return 240475766;
break;
}
break;
case 36:
switch (func_25())
{
case 0:
return 580731697;
break;
case 1:
return 728176806;
break;
case 2:
return 910240872;
break;
}
break;
case 37:
switch (func_25())
{
case 0:
return 74540475;
break;
case 1:
return -1200353264;
break;
case 2:
return 801340541;
break;
}
break;
}
return -1;
}
int func_77()
{
return Global_77510;
}
int func_78(int iParam0, int iParam1)
{
int iVar0;
return 0;
if (!unk_0xECEC7528A52B4EE8(iParam0))
{
iVar0 = func_29(iParam0);
if (iVar0 > 3)
{
return 0;
}
if (func_79(iVar0) != iParam0)
{
return 0;
}
if (iParam1 == 0)
{
if (iParam0 == unk_0x7D2B9E6A64637269())
{
return 0;
}
}
if (unk_0x234B68AC2E35ED5A(Global_95223, iVar0))
{
return 1;
}
}
return 0;
}
int func_79(int iParam0)
{
if (iParam0 > 3)
{
return 0;
}
if (iParam0 == func_25())
{
return unk_0x7D2B9E6A64637269();
}
return Global_96848[func_80(iParam0)];
}
int func_80(int iParam0)
{
if (iParam0 == 0)
{
return 0;
}
else if (iParam0 == 2)
{
return 2;
}
else if (iParam0 == 1)
{
return 1;
}
else if (iParam0 == 145)
{
return 3;
}
return 4;
}
struct<4> func_81(bool bParam0)
{
struct<4> Var0;
if (bParam0)
{
switch (func_25())
{
case 1:
StringCopy(&Var0, "FBI4_ISAGO", 16);
break;
case 2:
StringCopy(&Var0, "FBI4_ISAGO", 16);
break;
}
}
else
{
switch (func_25())
{
case 1:
StringCopy(&Var0, "FBI4_THATSIT", 16);
break;
case 2:
StringCopy(&Var0, "FBI4_THATSIT", 16);
break;
}
}
return Var0;
}
bool func_82(var uParam0, int iParam1, int iParam2, char* sParam3, char* sParam4, int iParam5, int iParam6, int iParam7, int iParam8, bool bParam9)
{
func_95(uParam0, iParam1, sParam3, iParam7, iParam8, 0);
Global_6986 = iParam2;
Global_21173 = 0;
Global_21132 = 1;
Global_21139 = 0;
Global_21134 = 0;
Global_22116 = 0;
Global_22118 = 0;
Global_22122 = 0;
Global_21139 = 0;
Global_21130 = 1;
Global_21177 = 0;
Global_21179 = 0;
if (iParam6 == 1)
{
Global_21137 = 1;
}
else
{
Global_21137 = 0;
}
Global_2621441 = 0;
return func_83(sParam4, iParam5, bParam9);
}
int func_83(char* sParam0, int iParam1, bool bParam2)
{
Global_21126 = 0;
if (Global_21125 == 0 || Global_21127 == 2)
{
if (Global_21125 != 0)
{
if (iParam1 > Global_21127)
{
if (Global_21132 == 0)
{
unk_0x75B41F5020877259(false);
Global_19798.f_1 = 3;
Global_21125 = 0;
Global_21126 = 1;
Global_21178 = 0;
Global_21121 = 0;
Global_21122 = 0;
Global_21136 = 0;
Global_21135 = 0;
Global_19797 = 0;
}
else
{
func_62();
return 0;
}
}
else
{
return 0;
}
}
if (unk_0x6C2F471E0CF8D4CF())
{
return 0;
}
if (func_94(8, -1))
{
return 0;
}
Global_21201 = { Global_21195 };
func_93();
Global_20414 = { Global_20579 };
Global_21131 = Global_21132;
Global_21138 = Global_21139;
Global_2621442 = Global_2621441;
Global_21140 = { Global_21156 };
Global_21133 = Global_21134;
Global_22115 = Global_22116;
Global_22123 = { Global_22129 };
Global_22117 = Global_22118;
Global_22119 = Global_22120;
Global_22121 = Global_22122;
Global_20744.f_370 = Global_22114;
Global_20744.f_368 = Global_22112;
Global_20744.f_369 = Global_22113;
Global_21121 = Global_21122;
if (Global_21131)
{
unk_0xC664C0067EEAB8D1(&Global_7668, 20);
unk_0xC664C0067EEAB8D1(&Global_7669, 17);
unk_0xC664C0067EEAB8D1(&Global_7670, 0);
if (bParam2)
{
func_92();
if (Global_8473[Global_19798 /*2811*/][0 /*281*/].f_259 == 2)
{
if (iParam1 == 13)
{
}
else
{
return 0;
}
}
if (Global_19798.f_1 > 3)
{
return 0;
}
}
if (Global_19764 == 1)
{
return 0;
}
if (unk_0xCAD1755E530A6012(unk_0x1146A9AE09CE2B14()))
{
if (unk_0x97AEEA04505AFDC3(unk_0x7D2B9E6A64637269()))
{
return 0;
}
if (func_91())
{
return 0;
}
if (unk_0xB800560AF60FDD2E(unk_0x7D2B9E6A64637269()))
{
return 0;
}
if (unk_0x6B9E71121F5B8154(unk_0x7D2B9E6A64637269()))
{
return 0;
}
if (unk_0xA115FBF153CD1608(unk_0x7D2B9E6A64637269()))
{
return 0;
}
if (unk_0xF6AD8282F4B81331(unk_0x7D2B9E6A64637269(), joaat("gadget_parachute")))
{
return 0;
}
if (!Global_77248)
{
if (unk_0x0297E633EADA2182(unk_0x7D2B9E6A64637269()))
{
return 0;
}
if (unk_0xF4D8C7957C89929B(unk_0x1146A9AE09CE2B14()))
{
return 0;
}
if (unk_0x8A92595B8AA1D4E9(unk_0x7D2B9E6A64637269()))
{
return 0;
}
if (unk_0x3C4ADC6B88FA8A08(unk_0x1146A9AE09CE2B14(), 0))
{
return 0;
}
}
}
if (func_51())
{
return 0;
}
else
{
switch (Global_19798.f_1)
{
case 7:
return 0;
break;
case 8:
return 0;
break;
case 9:
break;
case 10:
break;
default:
break;
}
if (unk_0x234B68AC2E35ED5A(Global_7668, 9))
{
return 0;
}
}
func_90();
Global_21135 = bParam2;
}
Global_21127 = iParam1;
StringCopy(&Global_20744, sParam0, 24);
Global_19991 = 0;
func_89();
func_84();
return 1;
}
if (Global_21125 == 5)
{
return 0;
}
if (iParam1 < Global_21127 || iParam1 == Global_21127)
{
return 0;
}
if (iParam1 == 2)
{
}
else
{
func_62();
}
return 0;
}
void func_84()
{
if (!func_85())
{
return;
}
if (Global_21131)
{
MemCopy(&(Global_1710127.f_1), {Global_20744}, 4);
Global_1710127 = Global_6983;
Global_1710127.f_6 = Global_21135;
}
}
int func_85()
{
if (!Global_262145.f_28376)
{
return 0;
}
if (!Global_77248)
{
return 0;
}
if (unk_0x1146A9AE09CE2B14() == func_88())
{
return 0;
}
if (func_86(unk_0x1146A9AE09CE2B14()))
{
return 0;
}
if (unk_0x234B68AC2E35ED5A(Global_1630816[unk_0x1146A9AE09CE2B14() /*597*/].f_1, 7))
{
return 0;
}
if (unk_0xE45310E861787FC2())
{
return 0;
}
return 1;
}
bool func_86(int iParam0)
{
return func_87(iParam0, 20);
}
bool func_87(int iParam0, int iParam1)
{
return unk_0x234B68AC2E35ED5A(Global_1630816[iParam0 /*597*/].f_11.f_4, iParam1);
}
int func_88()
{
return -1;
}
void func_89()
{
int iVar0;
iVar0 = 0;
while (iVar0 <= 69)
{
StringCopy(&(Global_19993[iVar0 /*6*/]), "", 24);
iVar0++;
}
unk_0x75B41F5020877259(false);
Global_21125 = 1;
}
void func_90()
{
Global_21178 = Global_21177;
Global_21172 = Global_21173;
Global_21219 = { Global_21207 };
Global_21225 = { Global_21213 };
Global_21180 = Global_21179;
Global_21249 = { Global_21231 };
Global_21255 = { Global_21237 };
Global_21261 = { Global_21243 };
Global_21267 = { Global_21273 };
Global_6983 = Global_6984;
Global_6985 = Global_6986;
Global_21136 = Global_21137;
Global_21138 = Global_21139;
Global_21140 = { Global_21156 };
Global_21129 = Global_21130;
Global_22141 = 0;
Global_21174 = 0;
Global_21175 = 0;
unk_0xC664C0067EEAB8D1(&Global_7669, 16);
}
int func_91()
{
int iVar0;
int iVar1;
if (Global_77248)
{
iVar0 = 0;
unk_0xBDC364B886846D11(unk_0x7D2B9E6A64637269(), &iVar1, 1);
if (unk_0xCAD1755E530A6012(unk_0x1146A9AE09CE2B14()))
{
if ((iVar1 == joaat("weapon_sniperrifle") || iVar1 == joaat("weapon_heavysniper")) || iVar1 == joaat("weapon_remotesniper"))
{
iVar0 = 1;
}
}
if (unk_0xC1DFA5E3535B69F6() && iVar0 == 1)
{
return 1;
}
else
{
return 0;
}
}
if (unk_0xCAD1755E530A6012(unk_0x1146A9AE09CE2B14()))
{
if (unk_0xC4D136140D260163(unk_0x7D2B9E6A64637269(), 78, 1))
{
return 1;
}
else
{
return 0;
}
}
return 1;
}
void func_92()
{
if (func_27(14))
{
if (!unk_0xE50EB54E0F21BED0(unk_0x7D2B9E6A64637269(), 0))
{
if (unk_0x6471F4759775FCA4(unk_0x7D2B9E6A64637269()) == Global_112293.f_28048[0 /*29*/])
{
Global_19798 = 0;
}
else if (unk_0x6471F4759775FCA4(unk_0x7D2B9E6A64637269()) == Global_112293.f_28048[1 /*29*/])
{
Global_19798 = 1;
}
else if (unk_0x6471F4759775FCA4(unk_0x7D2B9E6A64637269()) == Global_112293.f_28048[2 /*29*/])
{
Global_19798 = 2;
}
else
{
Global_19798 = 0;
}
}
}
else
{
Global_19798 = func_25();
if (Global_19798 == 145)
{
Global_19798 = 3;
}
if (Global_77248)
{
Global_19798 = 3;
}
if (Global_19798 > 3)
{
Global_19798 = 3;
}
}
}
void func_93()
{
int iVar0;
iVar0 = 0;
while (iVar0 <= 15)
{
Global_20414[iVar0 /*10*/] = 0;
StringCopy(&(Global_20414[iVar0 /*10*/].f_1), "", 24);
Global_20414[iVar0 /*10*/].f_7 = 0;
Global_20414[iVar0 /*10*/].f_8 = 0;
iVar0++;
}
Global_20414.f_161 = -99;
Global_20414.f_162 = { 0f, 0f, 0f };
}
bool func_94(int iParam0, int iParam1)
{
switch (iParam0)
{
case 5:
if (iParam1 > -1)
{
return Global_1379108.f_203[iParam1];
}
break;
}
return unk_0x234B68AC2E35ED5A(Global_1379108.f_1048, iParam0);
}
void func_95(var uParam0, int iParam1, char* sParam2, int iParam3, int iParam4, int iParam5)
{
Global_20579 = { *uParam0 };
Global_6984 = iParam1;
StringCopy(&Global_21195, sParam2, 24);
Global_22114 = iParam5;
if (iParam3 == 0)
{
Global_22112 = 1;
Global_22110 = 0;
}
else
{
Global_22112 = 0;
Global_22110 = 1;
}
if (iParam4 == 0)
{
Global_22113 = 1;
Global_22111 = 0;
}
else
{
Global_22113 = 0;
Global_22111 = 1;
}
}
char* func_96()
{
char* sVar0;
switch (func_77())
{
case 33:
switch (func_25())
{
case 0:
sVar0 = "FBIP1_MENDC";
break;
case 1:
sVar0 = "FBIP1_FENDC";
break;
case 2:
sVar0 = "FBIP1_TENDC";
break;
}
break;
case 34:
switch (func_25())
{
case 0:
sVar0 = "FBIP2_MENDC";
break;
case 1:
sVar0 = "FBIP2_FENDC";
break;
case 2:
sVar0 = "FBIP2_TENDC";
break;
}
break;
case 36:
switch (func_25())
{
case 0:
sVar0 = "FBIP4_MENDC";
break;
case 1:
sVar0 = "FBIP4_FENDC";
break;
case 2:
sVar0 = "FBIP4_TENDC";
break;
}
break;
case 37:
switch (func_25())
{
case 0:
sVar0 = "FBIP5_MENDC";
break;
case 1:
sVar0 = "FBIP5_FENDC";
break;
case 2:
sVar0 = "FBIP5_TENDC";
break;
}
break;
}
return sVar0;
}
int func_97()
{
int iVar0;
switch (func_25())
{
case 0:
iVar0 = 5;
break;
case 1:
iVar0 = 9;
break;
case 2:
iVar0 = 8;
break;
}
return iVar0;
}
void func_98(var uParam0, int iParam1, int iParam2, char* sParam3, int iParam4, int iParam5)
{
if ((uParam0[iParam1 /*10*/])->f_7 == 1)
{
}
(*uParam0)[iParam1 /*10*/] = iParam2;
StringCopy(&((uParam0[iParam1 /*10*/])->f_1), sParam3, 24);
(uParam0[iParam1 /*10*/])->f_7 = 1;
(uParam0[iParam1 /*10*/])->f_8 = iParam4;
(uParam0[iParam1 /*10*/])->f_9 = iParam5;
if (!Global_77248)
{
if (!unk_0xECEC7528A52B4EE8(iParam2))
{
if ((uParam0[iParam1 /*10*/])->f_8 == 0)
{
unk_0x9CF2691831C7455F(iParam2, 0);
}
else
{
unk_0x9CF2691831C7455F(iParam2, 1);
}
}
if (!unk_0xECEC7528A52B4EE8(iParam2))
{
if ((uParam0[iParam1 /*10*/])->f_9 == 0)
{
unk_0x354924FCEF0851C8(iParam2, 0);
}
else
{
unk_0x354924FCEF0851C8(iParam2, 1);
}
}
}
}
void func_99(int iParam0, int iParam1)
{
if (iParam0 == 146 || iParam0 == -1)
{
return;
}
if (Global_112293.f_9083.f_99.f_58[iParam0] == iParam1)
{
return;
}
Global_112293.f_9083.f_99.f_58[iParam0] = iParam1;
}
void func_100(bool bParam0)
{
if (bParam0)
{
func_75(1527885205, 0, func_25(), 23, 3, 6000, 6000, -1, 0, -1, 0);
}
else if (!func_102(3))
{
func_75(-224691627, 0, func_25(), 23, 3, 6000, 6000, -1, 50, -1, 0);
}
else
{
func_75(-224691627, 0, func_25(), 23, 3, 6000, 6000, -1, 0, -1, 0);
}
}
int func_101()
{
if ((func_102(41) && func_102(3)) && func_102(21))
{
return 1;
}
return 0;
}
int func_102(int iParam0)
{
if (iParam0 == 94 || iParam0 == -1)
{
return 0;
}
return Global_112293.f_9083.f_330[iParam0 /*6*/];
}
int func_103()
{
int iVar0;
int iVar1;
iVar0 = 0;
iVar1 = 33;
while (iVar1 <= 37)
{
if (func_102(iVar1))
{
iVar0++;
}
iVar1++;
}
if (func_104(45))
{
iVar0++;
}
if (iVar0 == 4)
{
return 1;
}
return 0;
}
int func_104(int iParam0)
{
if (iParam0 == 146 || iParam0 == -1)
{
return 0;
}
return Global_112293.f_9083.f_99.f_58[iParam0];
}
void func_105(char* sParam0, int iParam1, int iParam2)
{
iParam2 = iParam2;
unk_0x6D19CF57DC2F3E74(sParam0);
unk_0x49648AD747832803(iParam1, 1);
}
bool func_106(char* sParam0, int iParam1, int iParam2)
{
unk_0x40542ED8EFC7D2D7(sParam0);
if (iParam1 == 1)
{
unk_0x1896EC0B030A48A2(iParam2);
}
return unk_0xB4BAEA083E2652CB();
}
bool func_107(int iParam0, struct<3> Param1, float fParam4)
{
return SYSTEM::VDIST2(unk_0xD6E677FAD7521410(iParam0, 1), Param1) <= (fParam4 * fParam4);
}
void func_108()
{
func_215(&iLocal_874, &uLocal_875, &iLocal_686, &iLocal_822, &iLocal_821, Local_827, Local_868, 0, 1090519040);
func_214();
func_155();
switch (iLocal_684)
{
case 0:
if (func_122(iLocal_683, bLocal_28))
{
if (unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) == 0)
{
if (func_37(iLocal_874))
{
if (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), iLocal_874, 0))
{
func_121("PRA_LEVVEH", &iLocal_820);
}
}
}
iLocal_684 = 1;
}
break;
case 1:
func_120(&iLocal_821, Local_827, &iLocal_685, iLocal_686, &iLocal_820, &iLocal_838);
if (func_113(iLocal_874, Local_827, &iLocal_821, iLocal_686, iLocal_685, &iLocal_836, &iLocal_839, &iLocal_835, &iLocal_834, &iLocal_820, 1090519040))
{
if (!func_112())
{
if (func_67(&uLocal_687, &cLocal_1044, &uLocal_879))
{
func_63();
func_58();
}
}
else
{
func_99(46, 1);
func_63();
func_110(0);
}
}
break;
case 3:
if (func_37(Local_868))
{
if (!unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), Local_868, 0))
{
unk_0xB1D85A6C23F2F945(unk_0x7D2B9E6A64637269(), Local_868, -1);
}
else
{
func_109(Local_868, Local_827, 126.0705f, 0, 1);
func_40(1, 1, 1);
iLocal_684 = 1;
}
}
break;
}
}
int func_109(int iParam0, struct<3> Param1, float fParam4, bool bParam5, int iParam6)
{
bool bVar0;
float fVar1;
bVar0 = false;
if (func_10(iParam0))
{
if (bParam5 == 1)
{
fVar1 = 0f;
bVar0 = unk_0x7956E831D8C0C17C(Param1, &fVar1, 0, 0);
if (bVar0)
{
Param1.f_2 = fVar1;
}
}
unk_0x78CDDD1E6367978D(iParam0, Param1, 1, 0, 0, iParam6);
unk_0xCD37A28258D70638(iParam0, fParam4);
if (bParam5)
{
return bVar0;
}
return 1;
}
return 0;
}
void func_110(bool bParam0)
{
func_111(iLocal_683);
iLocal_817 = iLocal_683;
if (!bParam0)
{
iLocal_683 = iLocal_817 + 1;
}
else if (iLocal_817 > 0)
{
iLocal_683 = (iLocal_817 - 1);
}
iLocal_820 = 0;
iLocal_684 = 0;
}
void func_111(int iParam0)
{
switch (iParam0)
{
case 0:
break;
}
}
int func_112()
{
if (func_103())
{
if ((func_102(74) || func_102(75)) && func_101())
{
return 1;
}
}
return 0;
}
int func_113(int iParam0, struct<3> Param1, int iParam4, int iParam5, int iParam6, int iParam7, int iParam8, int iParam9, int iParam10, int iParam11, float fParam12)
{
float fVar0;
if ((iParam5 == 1 || iParam5 == 2) || iParam5 == 3)
{
if (iParam6 == 0)
{
if (func_37(iParam0))
{
if (!unk_0x020175C59CBE79DB(iParam0))
{
func_121(func_119(func_77()), iParam11);
}
}
if (!unk_0x591190E69BE43117(unk_0x7D2B9E6A64637269(), Param1, fParam12, fParam12, 2f, 0, 1, 2))
{
unk_0x591190E69BE43117(unk_0x7D2B9E6A64637269(), Param1, fParam12, fParam12, 2f, 1, 1, 2);
if (func_106(func_119(func_77()), 0, 0))
{
unk_0xAA18C87A1A6C1FAE(func_119(func_77()));
}
*iParam7 = 1;
func_117(iParam4, Param1, 1);
}
else
{
if (*iParam7)
{
fVar0 = (fParam12 / 2f);
if (func_107(unk_0x7D2B9E6A64637269(), Param1, fVar0))
{
*iParam7 = 0;
func_116(1077936128, 1);
}
}
func_7(iParam4);
}
}
}
else if (unk_0x591190E69BE43117(iParam0, Param1, fParam12, fParam12, 2f, 0, 1, 2))
{
if (*iParam9 == -1)
{
unk_0x5C052A30B9FCA449(iParam0, 2);
return 1;
}
if (!*iParam10)
{
if (func_106(func_119(func_77()), 0, 0))
{
unk_0x1036762BD3781C84();
}
*iParam9 = unk_0xDFB7BFA6482FEE1E();
*iParam10 = 1;
unk_0x5C052A30B9FCA449(iParam0, 2);
}
else if ((unk_0xDFB7BFA6482FEE1E() - *iParam9) > 3000)
{
return 1;
}
}
else
{
if (unk_0xAFD2714E8B5AEB9F(iParam0) == 2)
{
unk_0x5C052A30B9FCA449(iParam0, 1);
}
if (!*iParam8)
{
if (func_106(func_115(func_77(), 0), 0, 0))
{
unk_0xAA18C87A1A6C1FAE(func_115(func_77(), 0));
}
if (!func_106(func_114(func_77()), 0, 0))
{
func_105(func_114(func_77()), 7500, 0);
*iParam8 = 1;
}
}
*iParam7 = 1;
}
return 0;
}
char* func_114(int iParam0)
{
char* sVar0;
switch (iParam0)
{
case 33:
sVar0 = "PRA_RETVEH";
break;
case 34:
sVar0 = "PRB_RETVEH";
break;
case 78:
sVar0 = "PR_RETVEH";
break;
case 80:
case 81:
case 82:
sVar0 = "PRF_RETVEH";
break;
}
return sVar0;
}
char* func_115(int iParam0, bool bParam1)
{
char* sVar0;
switch (iParam0)
{
case 33:
sVar0 = "PRA_TAKBACK";
break;
case 34:
sVar0 = "PRB_TAKBACK";
break;
case 78:
sVar0 = "PR_TAKBACK";
break;
case 80:
case 81:
case 82:
if (!bParam1)
{
sVar0 = "PRF_TAKBACK";
}
else
{
sVar0 = "PRF_GARAGE";
}
break;
}
return sVar0;
}
int func_116(float fParam0, int iParam1)
{
int iVar0;
if (!unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
return 1;
}
iVar0 = unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0);
if (unk_0xBFCE58B2B3249999(iVar0, 0))
{
if (unk_0x27FC1B0077581B37(iVar0, -1, 0) == unk_0x7D2B9E6A64637269())
{
if (!unk_0x8879B2803A5F8682(iVar0))
{
unk_0x101C61FF49B27BB8(iVar0, fParam0, iParam1, 0);
return 0;
}
}
else
{
return 1;
}
}
if (unk_0xE6046EB2291D084D(unk_0x7D2B9E6A64637269()))
{
return 1;
}
if (unk_0xBFCE58B2B3249999(iVar0, 0))
{
if (unk_0x8879B2803A5F8682(iVar0))
{
return 1;
}
}
return 0;
}
void func_117(int iParam0, struct<3> Param1, int iParam4)
{
if (!unk_0x575B7C28D81C0B4D(*iParam0))
{
*iParam0 = func_118(Param1, 5, iParam4);
}
}
int func_118(struct<3> Param0, int iParam3, int iParam4)
{
int iVar0;
iVar0 = 0;
iVar0 = unk_0x27E44C95E1D1461C(Param0);
unk_0xC5BBAB0F8336ECB7(iVar0, iParam3);
unk_0xDD205B87CDFD0C1B(iVar0, 1f);
unk_0x13CC211F9F7ACE7F(iVar0, iParam4);
return iVar0;
}
char* func_119(int iParam0)
{
char* sVar0;
switch (iParam0)
{
case 33:
sVar0 = "PRA_LEVVEH";
break;
case 34:
sVar0 = "PRB_LEVVEH";
break;
case 78:
sVar0 = "PR_LEVVEH";
break;
case 80:
case 81:
case 82:
sVar0 = "PRF_LEAVE";
break;
}
return sVar0;
}
void func_120(int iParam0, struct<3> Param1, int iParam4, int iParam5, int iParam6, int iParam7)
{
switch (*iParam4)
{
case 0:
if (unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) > 0)
{
*iParam4 = 1;
}
break;
case 1:
func_7(iParam0);
if ((iParam5 == 1 || iParam5 == 2) || iParam5 == 3)
{
unk_0x1036762BD3781C84();
func_105("LOSE_WANTED", 7500, 0);
*iParam4 = 2;
}
break;
case 2:
if (unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) == 0)
{
unk_0x1036762BD3781C84();
if ((iParam5 == 1 || iParam5 == 2) || iParam5 == 3)
{
func_121(func_115(func_77(), 0), iParam6);
func_117(iParam0, Param1, 1);
}
else if (iParam5 == 0 && !*iParam7)
{
func_105(func_114(func_77()), 7500, 0);
*iParam7 = 1;
}
*iParam4 = 0;
}
break;
}
}
void func_121(char* sParam0, int iParam1)
{
if (!*iParam1)
{
func_105(sParam0, 7500, 0);
*iParam1 = 1;
}
}
int func_122(int iParam0, bool bParam1)
{
int iVar0;
switch (iParam0)
{
case 0:
if (bParam1)
{
bLocal_28 = false;
func_40(1, 1, 1);
}
else if (func_149(1, Local_824, 0))
{
if (func_148())
{
func_147(33);
unk_0x16C6E55F8C91ED24(joaat("trash"), 1);
unk_0x16C6E55F8C91ED24(joaat("towtruck"), 1);
unk_0x16C6E55F8C91ED24(joaat("s_m_y_garbage"), 1);
iLocal_683 = 2;
func_7(&iLocal_821);
func_145(&uLocal_671, 0, 0);
func_144(190, 1244.338f, -339.3197f, 68.0823f);
func_142();
unk_0x911ACE3851C77474("DRIVE", 0);
unk_0x911ACE3851C77474("WORLD_VEHICLE_ATTRACTOR", 0);
unk_0x911ACE3851C77474("WORLD_VEHICLE_DRIVE_PASSENGERS", 0);
unk_0x911ACE3851C77474("WORLD_VEHICLE_DRIVE_SOLO", 0);
return 1;
}
else if (((func_149(2, Local_868.f_1, Local_868.f_4) && func_149(3, Local_840.f_1, Local_840.f_4)) && func_149(4, Local_854.f_1, Local_854.f_4)) && func_141(0))
{
func_142();
func_147(33);
if (func_341(Local_840))
{
func_140(Local_840);
}
if (func_341(Local_854))
{
func_139(Local_854);
}
func_138(Local_868);
if (func_341(Local_854) && func_341(Local_840))
{
func_127(iLocal_830, 1, 0, 1);
}
unk_0x16C6E55F8C91ED24(joaat("trash"), 1);
unk_0x16C6E55F8C91ED24(joaat("towtruck"), 1);
unk_0x16C6E55F8C91ED24(joaat("s_m_y_garbage"), 1);
if (unk_0xDBB89442BDC45F07(Local_868) != 0)
{
iVar0 = unk_0xDBB89442BDC45F07(Local_868);
unk_0xAE9FE38DB6527FDA(1);
func_7(&iVar0);
unk_0xAE9FE38DB6527FDA(0);
}
func_125(&iLocal_821, Local_868, 1);
func_144(190, 1244.338f, -339.3197f, 68.0823f);
unk_0x911ACE3851C77474("DRIVE", 0);
unk_0x911ACE3851C77474("WORLD_VEHICLE_ATTRACTOR", 0);
unk_0x911ACE3851C77474("WORLD_VEHICLE_DRIVE_PASSENGERS", 0);
unk_0x911ACE3851C77474("WORLD_VEHICLE_DRIVE_SOLO", 0);
return 1;
}
}
break;
case 1:
if (bParam1)
{
if ((func_149(2, Local_868.f_1, Local_868.f_4) && func_149(3, Local_840.f_1, Local_840.f_4)) && func_149(4, Local_854.f_1, Local_854.f_4))
{
func_124(unk_0x7D2B9E6A64637269(), 1197.861f, -353.011f, 68.0929f, 278.9647f);
func_123();
bLocal_28 = false;
unk_0x911ACE3851C77474("DRIVE", 0);
unk_0x911ACE3851C77474("WORLD_VEHICLE_ATTRACTOR", 0);
unk_0x911ACE3851C77474("WORLD_VEHICLE_DRIVE_PASSENGERS", 0);
unk_0x911ACE3851C77474("WORLD_VEHICLE_DRIVE_SOLO", 0);
func_40(1, 1, 1);
}
}
else
{
func_142();
return 1;
}
break;
case 2:
if (bParam1)
{
if (func_149(2, Local_868.f_1, Local_868.f_4))
{
func_123();
func_142();
unk_0xB1D85A6C23F2F945(unk_0x7D2B9E6A64637269(), Local_868, -1);
bLocal_28 = false;
func_40(1, 1, 1);
}
}
else
{
return 1;
}
break;
case 3:
if (bParam1)
{
if (func_149(2, Local_827, Local_868.f_4))
{
func_123();
unk_0xB1D85A6C23F2F945(unk_0x7D2B9E6A64637269(), Local_868, -1);
func_142();
bLocal_28 = false;
func_40(1, 1, 1);
}
}
else
{
return 1;
}
break;
}
return 0;
}
void func_123()
{
if (iLocal_683 == 1)
{
func_140(Local_840);
func_139(Local_854);
func_138(Local_868);
func_127(iLocal_830, 1, 0, 1);
}
iLocal_877 = 0;
iLocal_838 = 0;
iLocal_839 = 0;
iLocal_834 = 0;
iLocal_835 = 0;
iLocal_836 = 0;
}
void func_124(int iParam0, struct<3> Param1, float fParam4)
{
if (func_341(uParam0))
{
unk_0xCA089CD1A17D76DF(uParam0);
}
func_109(iParam0, Param1, fParam4, 0, 1);
}
void func_125(int iParam0, int iParam1, int iParam2)
{
if (!unk_0x575B7C28D81C0B4D(*iParam0))
{
*iParam0 = func_126(iParam1, iParam2, 5);
}
}
int func_126(int iParam0, var uParam1, int iParam2)
{
int iVar0;
iVar0 = 0;
if (func_10(uParam0))
{
iVar0 = unk_0xB20BB447C131B310(uParam0);
unk_0xB592493CDC7124C3(iVar0, uParam1);
unk_0xC5BBAB0F8336ECB7(iVar0, iParam2);
unk_0xDD205B87CDFD0C1B(iVar0, 1f);
}
return iVar0;
}
void func_127(int iParam0, int iParam1, int iParam2, int iParam3)
{
int iVar0;
iLocal_81 = iParam0;
bLocal_663 = iParam1;
bLocal_662 = iParam2;
bLocal_664 = iParam3;
Local_111[0 /*11*/].f_1 = 0;
Local_111[1 /*11*/].f_1 = 0;
iVar0 = 0;
while (iVar0 <= (iLocal_81 - 1))
{
Local_134[iVar0 /*25*/].f_18 = 0;
iVar0++;
}
fLocal_660 = 0f;
func_129();
Local_111[1 /*11*/].f_7 = 3;
Local_111[1 /*11*/].f_5 = 0;
Local_111[1 /*11*/].f_10 = 1;
Local_111[1 /*11*/].f_2 = 1500;
Local_111[1 /*11*/].f_3 = 500;
Local_111[0 /*11*/].f_5 = 0;
Local_111[0 /*11*/].f_10 = 0;
Local_111[0 /*11*/].f_2 = 1000;
Local_111[0 /*11*/].f_3 = 100;
unk_0xF479CA7199C54C8F("Enemies", &uLocal_80);
unk_0x2271ED1E65FB75EE(Local_111[0 /*11*/], uLocal_80);
unk_0x2271ED1E65FB75EE(Local_111[1 /*11*/], uLocal_80);
unk_0xEA44C65D5434D223(Local_111[0 /*11*/], 1, 0);
unk_0xEA44C65D5434D223(Local_111[1 /*11*/], 1, 0);
func_128(1.9f, 1.9f, 8f, 0f, 0f, 0f);
}
void func_128(struct<3> Param0, struct<3> Param3)
{
Local_82.f_8 = { Param0 };
Local_82.f_11 = { Param3 };
Local_82.f_1 = 4;
}
void func_129()
{
if (!unk_0xF41EB7643E61A928(Local_111[0 /*11*/], iLocal_109, 0))
{
unk_0x45B1B4E55BF15523(Local_111[0 /*11*/], unk_0x9E695CE384C77EF0(iLocal_109, func_137(1)), 1f, -1, 1048576000, 0, 1193033728);
Local_111[0 /*11*/].f_7 = 1;
}
else
{
func_130(1);
}
}
void func_130(bool bParam0)
{
if (!unk_0x9B73EB6255D4AE81(iLocal_109, 0, 0))
{
func_131(bParam0);
if (iLocal_661 != (iLocal_81 - 1))
{
if (iLocal_661 == 4)
{
unk_0xB95DDD9ED08D971C(Local_111[0 /*11*/], iLocal_109, Local_134[iLocal_661 /*25*/], 15f, 2883755, Local_134[iLocal_661 /*25*/].f_6);
}
else
{
unk_0xE946751408DFA71B(Local_111[0 /*11*/], iLocal_109, Local_134[iLocal_661 /*25*/], 15f, 0, 0, 2883755, Local_134[iLocal_661 /*25*/].f_6, Local_134[iLocal_661 /*25*/].f_7);
}
Local_111[0 /*11*/].f_8 = Local_111[0 /*11*/].f_7;
Local_111[0 /*11*/].f_7 = 4;
}
else
{
unk_0x0509CE092AC81B7C(Local_111[0 /*11*/], iLocal_109, 15f, 786599);
Local_111[0 /*11*/].f_8 = Local_111[0 /*11*/].f_7;
Local_111[0 /*11*/].f_7 = 10;
}
}
else
{
Local_111[0 /*11*/].f_8 = Local_111[0 /*11*/].f_7;
Local_111[0 /*11*/].f_7 = 7;
}
}
void func_131(bool bParam0)
{
if (iLocal_661 != -1)
{
if (!func_136(Local_134[iLocal_661 /*25*/].f_11) && !func_136(Local_134[iLocal_661 /*25*/].f_14))
{
unk_0x86DA8A407ED8A381(Local_134[iLocal_661 /*25*/].f_11 - Local_134[iLocal_661 /*25*/].f_14, Local_134[iLocal_661 /*25*/].f_11 + Local_134[iLocal_661 /*25*/].f_14, 1, 1);
}
}
if (!bParam0)
{
func_134();
}
else
{
iLocal_661 = func_132();
}
if (iLocal_661 != -1)
{
if (!func_136(Local_134[iLocal_661 /*25*/].f_11) && !func_136(Local_134[iLocal_661 /*25*/].f_14))
{
unk_0x86DA8A407ED8A381(Local_134[iLocal_661 /*25*/].f_11 - Local_134[iLocal_661 /*25*/].f_14, Local_134[iLocal_661 /*25*/].f_11 + Local_134[iLocal_661 /*25*/].f_14, 0, 1);
}
}
}
int func_132()
{
int iVar0;
struct<3> Var1;
int iVar4;
int iVar5;
float fVar6[21];
float fVar28;
float fVar29;
float fVar30;
int iVar31;
if (func_37(iLocal_109))
{
Var1 = { unk_0xD6E677FAD7521410(iLocal_109, 1) };
iVar4 = 0;
while (iVar4 <= (iLocal_81 - 1))
{
fVar28 = unk_0x0BABEFEA577FCFA4(Var1, Local_134[iVar4 /*25*/], 1);
if (!func_136(Local_134[iVar4 /*25*/]) && fVar28 > 25f)
{
fVar6[iVar4] = fVar28;
}
else
{
fVar6[iVar4] = -1f;
}
iVar4++;
}
fVar29 = fVar6[0];
iVar4 = 0;
while (iVar4 <= (iLocal_81 - 1))
{
if (fVar6[iVar4] != -1f)
{
if (fVar6[iVar4] < fVar29)
{
fVar29 = fVar6[iVar4];
iVar0 = iVar4;
}
}
iVar4++;
}
fVar30 = func_133(Local_134[iVar0 /*25*/] - Var1, unk_0x557C9CA8FCC667DF(iLocal_109));
iVar5 = iVar0;
iVar31 = 0;
while (fVar30 < 0f && iVar31 < 40)
{
iVar5++;
if (iVar5 >= 21)
{
iVar5 = 0;
}
Var1 = { unk_0xD6E677FAD7521410(iLocal_109, 1) };
fVar30 = func_133(Local_134[iVar5 /*25*/] - Var1, unk_0x557C9CA8FCC667DF(iLocal_109));
iVar31++;
}
if (iVar31 >= 40)
{
iVar5 = (iLocal_81 - 1);
}
}
iVar0 = iVar5;
return iVar0;
}
float func_133(struct<3> Param0, struct<3> Param3)
{
return (((Param0.x * Param3.x) + (Param0.f_1 * Param3.f_1)) + (Param0.f_2 * Param3.f_2));
}
void func_134()
{
int iVar0;
int iVar1;
iVar0 = 0;
if (bLocal_663)
{
while (Local_134[iLocal_661 /*25*/].f_18 && iVar0 != -1)
{
iLocal_661++;
if (iLocal_661 >= (iLocal_81 - 1))
{
iVar0 = -1;
iLocal_661 = (iLocal_81 - 1);
}
}
if (iLocal_661 == (iLocal_81 - 1))
{
if (bLocal_662)
{
iLocal_661 = 0;
iVar0 = 0;
while (iVar0 <= (iLocal_81 - 1))
{
Local_134[iVar0 /*25*/].f_18 = 0;
iVar0++;
}
}
else
{
iLocal_661 = (iLocal_81 - 1);
return;
}
}
}
else
{
iVar1 = 0;
iVar0 = 0;
while (iVar0 <= (iLocal_81 - 1))
{
if (Local_134[iVar0 /*25*/].f_18)
{
iVar1++;
}
iVar0++;
}
if (iVar1 == (iLocal_81 - 1))
{
iLocal_661 = (iLocal_81 - 1);
}
else if (iVar1 == iLocal_81)
{
if (bLocal_662)
{
iVar0 = 0;
while (iVar0 <= (iLocal_81 - 1))
{
Local_134[iVar0 /*25*/].f_18 = 0;
iVar0++;
}
iLocal_661 = func_135();
}
else
{
iLocal_661 = -1;
return;
}
}
else
{
iLocal_661 = func_135();
}
}
}
int func_135()
{
int iVar0;
iVar0 = unk_0xB36B8558948EA7A8(0, (iLocal_81 - 1));
while (Local_134[iVar0 /*25*/].f_18)
{
iVar0 = unk_0xB36B8558948EA7A8(0, (iLocal_81 - 1));
}
return iVar0;
}
int func_136(struct<3> Param0)
{
if ((Param0.x == 0f && Param0.f_1 == 0f) && Param0.f_2 == 0f)
{
return 1;
}
return 0;
}
Vector3 func_137(bool bParam0)
{
struct<3> Var0;
var uVar3;
if (!bParam0)
{
uVar3 = unk_0xED5AD56E2C551D1E(iLocal_109, "wheel_rf");
}
else
{
uVar3 = unk_0xED5AD56E2C551D1E(iLocal_109, "wheel_lf");
}
Var0 = { unk_0xE8E46B75F88C4ACC(iLocal_109, uVar3) };
Var0 = { unk_0x8EB57098C563AB39(iLocal_109, Var0) };
if (!bParam0)
{
Var0 = { Var0 + Vector(0.5f, 0f, 1f) };
}
else
{
Var0 = { Var0 + Vector(0.5f, 0f, -1f) };
}
return Var0;
}
void func_138(int iParam0)
{
if (func_37(iParam0))
{
iLocal_109 = iParam0;
}
}
void func_139(var uParam0)
{
if (func_341(uParam0))
{
Local_111[1 /*11*/] = uParam0;
}
}
void func_140(var uParam0)
{
if (func_341(uParam0))
{
Local_111[0 /*11*/] = uParam0;
}
}
int func_141(bool bParam0)
{
unk_0x068BDE31F7D112BB("missfbi4prepp1");
unk_0x4FF5AF70CF79B316("missfbi4prepp1_garbageman");
if (bParam0)
{
while (!unk_0x0EC2B29D4172D225("missfbi4prepp1") && !unk_0xD8DCEA7B6A249141("missfbi4prepp1_garbageman"))
{
SYSTEM::WAIT(0);
}
return 1;
}
else if (unk_0x0EC2B29D4172D225("missfbi4prepp1") && unk_0xD8DCEA7B6A249141("missfbi4prepp1_garbageman"))
{
return 1;
}
return 0;
}
void func_142()
{
func_143(&uLocal_879);
}
void func_143(var uParam0)
{
int iVar0;
char* sVar1;
switch (func_25())
{
case 0:
iVar0 = 0;
sVar1 = "MICHAEL";
break;
case 1:
iVar0 = 1;
sVar1 = "FRANKLIN";
break;
case 2:
iVar0 = 2;
sVar1 = "TREVOR";
break;
}
func_98(uParam0, iVar0, unk_0x7D2B9E6A64637269(), sVar1, 0, 1);
}
void func_144(int iParam0, struct<3> Param1)
{
int iVar0;
iVar0 = iParam0;
if ((iVar0 < 0 || iVar0 >= 263) || iParam0 == 263)
{
return;
}
if ((Param1.x == Global_31724[iVar0 /*23*/][0 /*3*/] && Param1.f_1 == Global_31724[iVar0 /*23*/][0 /*3*/].f_1) && Param1.f_2 == Global_31724[iVar0 /*23*/][0 /*3*/].f_2)
{
return;
}
Global_31721 = 1;
unk_0x191DDA30577F440A(&(Global_31724[iVar0 /*23*/].f_11), 18);
Global_31724[iVar0 /*23*/][0 /*3*/] = { Param1 };
Global_37774 = 1;
}
void func_145(var uParam0, int iParam1, int iParam2)
{
char* sVar0;
if (unk_0x02BFF15CAA701972())
{
if (unk_0x234B68AC2E35ED5A(Global_2544210.f_4658, 26))
{
return;
}
}
if (unk_0x79CC60D128756F16())
{
unk_0xD20D31BC4E3A72D3(iParam2);
unk_0xBAF2F13FE4D19AA9("FocusIn");
unk_0xC0BBE340BE2AA02D("HINT_CAM_SCENE");
if (uParam0->f_11)
{
unk_0x9673FB069F90F6B9("FocusOut", 0, 0);
unk_0x9B0169E27978C1A2(-1, "FocusOut", "HintCamSounds", 1);
uParam0->f_11 = 0;
}
}
unk_0xD6ABECE3CBB224B0(1);
uParam0->f_1 = 0;
*uParam0 = 0;
uParam0->f_2 = -1;
uParam0->f_8 = 0;
uParam0->f_5 = 0;
uParam0->f_6 = 0;
sVar0 = iParam1;
if (unk_0x4030103C8B148AFC(sVar0))
{
if (!unk_0x02BFF15CAA701972())
{
sVar0 = "CMN_HINT";
}
else
{
sVar0 = "FM_IHELP_HNT";
}
}
if (!unk_0x4030103C8B148AFC(uParam0->f_3))
{
if (func_146(uParam0->f_3))
{
unk_0x66AE54CE92457FEE(1);
}
}
if (!unk_0x4030103C8B148AFC(sVar0))
{
if (func_146(sVar0))
{
unk_0x66AE54CE92457FEE(1);
}
}
}
bool func_146(char* sParam0)
{
unk_0x4A4799828818A508(sParam0);
return unk_0x0222F263F70347A8(0);
}
void func_147(int iParam0)
{
if (Global_96292 != -1)
{
if (iParam0 == Global_96292)
{
Global_96296 = 1;
return;
}
}
}
int func_148()
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if (unk_0xEACFC87E44438F24(unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0), joaat("trash")))
{
unk_0x4985CD0720AFD468(unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0), 1, 0);
iLocal_874 = unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0);
if (func_37(iLocal_874))
{
return 1;
}
}
}
return 0;
}
int func_149(int iParam0, struct<3> Param1, float fParam4)
{
switch (iParam0)
{
case 0:
if (func_154(Param1, Local_824, 1056964608, 0) && fParam4 == 0f)
{
return 1;
}
break;
case 1:
unk_0xBB3CDAB62C8773C8(sLocal_819, 0);
if (unk_0x080D38ACEC5DC1A2(0))
{
return 1;
}
break;
case 2:
if (func_37(Global_95867[0]))
{
unk_0x4985CD0720AFD468(Global_95867[0], 1, 1);
Local_868 = Global_95867[0];
if (func_37(Local_868))
{
func_36(Local_868, 0);
unk_0xD4DF29F3D7B97053(Local_868, 1);
unk_0x8B58E7AC53EED9F1(Local_868, 1);
return 1;
}
}
else if (func_153(&Local_868, Local_868.f_5, Local_868.f_1, Local_868.f_4, 1))
{
func_36(Local_868, 0);
unk_0xD4DF29F3D7B97053(Local_868, 1);
unk_0x8B58E7AC53EED9F1(Local_868, 1);
return 1;
}
break;
case 3:
if (unk_0x419E13582192CFEA(Global_95867.f_9[0]))
{
if (!unk_0xC6D04E4B28753F77(Global_95867.f_9[0], 1))
{
unk_0x4985CD0720AFD468(Global_95867.f_9[0], 1, 1);
Local_840 = Global_95867.f_9[0];
if (func_341(Local_840))
{
unk_0xBE91B077ADADE97F(Local_840, true);
unk_0x7B28A83A0D3DD0F9(Local_840, 170, 0);
unk_0x82D2BB48A39F1E88(Local_840, 65536, 1);
unk_0xA415F00D0E0DFBCE(Local_840, 50, 1);
return 1;
}
}
else
{
return 1;
}
}
else if (func_150(&Local_840, Local_840.f_5, Local_840.f_1, Local_840.f_4, 1, 0, 1, 1))
{
if (func_37(Local_868))
{
unk_0xB1D85A6C23F2F945(Local_840, Local_868, -1);
unk_0xBE91B077ADADE97F(Local_840, true);
unk_0x7B28A83A0D3DD0F9(Local_840, 170, 0);
unk_0x82D2BB48A39F1E88(Local_840, 65536, 1);
unk_0xA415F00D0E0DFBCE(Local_840, 50, 1);
return 1;
}
}
break;
case 4:
if (unk_0x419E13582192CFEA(Global_95867.f_9[1]))
{
if (!unk_0xC6D04E4B28753F77(Global_95867.f_9[1], 1))
{
unk_0x4985CD0720AFD468(Global_95867.f_9[1], 1, 1);
Local_854 = Global_95867.f_9[1];
if (func_341(Local_854))
{
unk_0x7B28A83A0D3DD0F9(Local_854, 170, 0);
unk_0x82D2BB48A39F1E88(Local_854, 65536, 1);
unk_0xA415F00D0E0DFBCE(Local_854, 50, 1);
unk_0xBE91B077ADADE97F(Local_854, true);
unk_0x46EDFC827DC67D89(Local_854, 1, 1);
return 1;
}
}
else
{
return 1;
}
}
else if (func_150(&Local_854, Local_854.f_5, Local_854.f_1, Local_854.f_4, 1, 0, 1, 1))
{
if (func_37(Local_868))
{
unk_0xB1D85A6C23F2F945(Local_854, Local_868, 0);
unk_0x7B28A83A0D3DD0F9(Local_854, 170, 0);
unk_0x82D2BB48A39F1E88(Local_854, 65536, 1);
unk_0xA415F00D0E0DFBCE(Local_854, 50, 1);
unk_0xBE91B077ADADE97F(Local_854, true);
unk_0x46EDFC827DC67D89(Local_854, 1, 1);
return 1;
}
}
break;
}
return 0;
}
int func_150(var uParam0, var uParam1, struct<3> Param2, var uParam5, bool bParam6, bool bParam7, bool bParam8, bool bParam9)
{
if (!unk_0x419E13582192CFEA(*uParam0))
{
if (func_152(uParam1, "Loading", 0))
{
*uParam0 = unk_0x0FDCFECB2EF2BC1C(26, uParam1, Param2, uParam5, 1, 1);
if (func_341(*uParam0))
{
if (bParam7)
{
unk_0xA2C015B68CE01357(*uParam0, 1);
}
if (bParam8)
{
unk_0xBE91B077ADADE97F(*uParam0, bParam8);
}
if (!bParam9)
{
unk_0x1D7A4E9E23D306D6(*uParam0, bParam9);
}
if (bParam6)
{
func_151(uParam1, 1);
}
return 1;
}
}
}
else if (func_341(*uParam0))
{
return 1;
}
return 0;
}
void func_151(var uParam0, bool bParam1)
{
if (bParam1)
{
if (unk_0xA9C0BBFB9CBB66F1(uParam0))
{
unk_0x824F744352C8BC82(uParam0);
}
}
else
{
unk_0x824F744352C8BC82(uParam0);
}
}
int func_152(var uParam0, char* sParam1, int iParam2)
{
unk_0x16E516CA9C88FF48(uParam0);
if (!unk_0xAB6A270F84A8781E(sParam1) && iParam2 != -1)
{
}
if (unk_0xA9C0BBFB9CBB66F1(uParam0))
{
return 1;
}
return 0;
}
int func_153(var uParam0, int iParam1, struct<3> Param2, float fParam5, bool bParam6)
{
if (!unk_0x419E13582192CFEA(*uParam0))
{
if (func_152(iParam1, "Loading", 0))
{
*uParam0 = unk_0x170478CC84C8AE2F(iParam1, Param2, fParam5, 1, 1, 0);
if (unk_0x419E13582192CFEA(*uParam0))
{
if (!unk_0xEE1D92A39CF8E1E6(*uParam0))
{
unk_0x4985CD0720AFD468(*uParam0, 1, 0);
}
unk_0x47D0DDD8833C5E5F(*uParam0, 1084227584);
if (bParam6)
{
func_151(iParam1, 1);
}
return 1;
}
}
}
else
{
if (func_37(*uParam0))
{
unk_0x78CDDD1E6367978D(*uParam0, Param2, 1, 0, 0, 1);
unk_0xCD37A28258D70638(*uParam0, fParam5);
}
if (!unk_0xEE1D92A39CF8E1E6(*uParam0))
{
unk_0x4985CD0720AFD468(*uParam0, 1, 0);
return 1;
}
else
{
return 1;
}
}
return 0;
}
int func_154(struct<3> Param0, struct<3> Param3, float fParam6, bool bParam7)
{
if (fParam6 < 0f)
{
fParam6 = 0f;
}
if (!bParam7)
{
if (unk_0x0BCA9ADE67DF9DD8((Param0.x - Param3.x)) <= fParam6)
{
if (unk_0x0BCA9ADE67DF9DD8((Param0.f_1 - Param3.f_1)) <= fParam6)
{
if (unk_0x0BCA9ADE67DF9DD8((Param0.f_2 - Param3.f_2)) <= fParam6)
{
return 1;
}
}
}
}
else if (unk_0x0BCA9ADE67DF9DD8((Param0.x - Param3.x)) <= fParam6)
{
if (unk_0x0BCA9ADE67DF9DD8((Param0.f_1 - Param3.f_1)) <= fParam6)
{
return 1;
}
}
return 0;
}
void func_155()
{
int iVar0;
iVar0 = 0;
while (iVar0 <= (2 - 1))
{
func_156(&(Local_111[iVar0 /*11*/]), iVar0);
iVar0++;
}
}
void func_156(var uParam0, int iParam1)
{
if (func_341(*uParam0))
{
func_202(uParam0, iParam1, 0);
if (unk_0x698F51FB33ADAF7B(*uParam0, "missfbi4prepp1", "_bag_drop_garbage_man", 3))
{
if (unk_0x4598B7969D5B0A28(*uParam0, "missfbi4prepp1", "_bag_drop_garbage_man") >= 0.172f)
{
if (func_10(Local_134[iLocal_661 /*25*/].f_17) && unk_0x5976053523EA16C8(Local_134[iLocal_661 /*25*/].f_17))
{
unk_0x87FB9C4434EDF1A5(*uParam0, 1048576000);
unk_0x1C53495E38DE08B7(*uParam0);
if (iLocal_661 <= 20 && iLocal_661 != -1)
{
Local_134[iLocal_661 /*25*/].f_18 = 1;
uParam0->f_9 = 0;
}
unk_0x3211C35423263392(Local_134[iLocal_661 /*25*/].f_17, 1, 0);
unk_0x0A6448DF4E471932(Local_134[iLocal_661 /*25*/].f_17, 1, unk_0x557C9CA8FCC667DF(*uParam0), 0, 1, 1, 0);
}
}
}
switch (uParam0->f_5)
{
case 0:
if (iParam1 == 0)
{
func_199();
func_198(uParam0);
}
func_185(uParam0);
break;
case 1:
func_158(uParam0);
break;
}
}
else
{
if (func_10(Local_134[iLocal_661 /*25*/].f_17))
{
if (unk_0x5976053523EA16C8(Local_134[iLocal_661 /*25*/].f_17))
{
unk_0x3211C35423263392(Local_134[iLocal_661 /*25*/].f_17, 1, 0);
unk_0x0A6448DF4E471932(Local_134[iLocal_661 /*25*/].f_17, 1, unk_0x557C9CA8FCC667DF(*uParam0), 0, 1, 1, 0);
}
}
func_7(&(uParam0->f_4));
if (unk_0x419E13582192CFEA(*uParam0))
{
if (!func_157(unk_0x7D2B9E6A64637269(), *uParam0, 150f, 1) && !bLocal_665)
{
func_5(uParam0, 1, 0, 1);
}
}
}
}
bool func_157(int iParam0, int iParam1, float fParam2, int iParam3)
{
return SYSTEM::VDIST2(unk_0xD6E677FAD7521410(iParam0, iParam3), unk_0xD6E677FAD7521410(iParam1, iParam3)) <= (fParam2 * fParam2);
}
void func_158(var uParam0)
{
var uVar0;
var uVar1;
switch (uParam0->f_6)
{
case 5:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) > uParam0->f_3)
{
if (func_184(*uParam0, 780511057))
{
unk_0xCA089CD1A17D76DF(*uParam0);
}
unk_0x1DC2BF231DE6A016(*uParam0, unk_0x7D2B9E6A64637269(), 30f, -1, 0, 0);
uParam0->f_6 = 6;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
break;
case 21:
if (unk_0x24A466C655E8588A(unk_0x7D2B9E6A64637269(), 6))
{
if (func_177(*uParam0, unk_0x7D2B9E6A64637269(), 1126825984, 1, 250, 7))
{
func_176(uParam0, 1);
return;
}
}
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) > uParam0->f_3)
{
if (!unk_0xC49311A2A500FF09(*uParam0, 0))
{
unk_0xFD232B7DCAA5A304(*uParam0, unk_0x7D2B9E6A64637269(), 8f, -1f, 10f, 0);
}
else
{
unk_0x5C679902079A7E80(&uVar0);
unk_0xCC5ED49CF9C9215F(0, 0, 0);
unk_0x9DA29013F33252A6(0, unk_0x7D2B9E6A64637269(), 0, 16);
unk_0x1BBD0A5729AB1226(uVar0);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar0);
unk_0x8D5B447F21217223(&uVar0);
}
if (!unk_0x575B7C28D81C0B4D(uParam0->f_4))
{
uParam0->f_4 = func_173(*uParam0, 1, 145);
}
uParam0->f_6 = 22;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
break;
case 10:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) > uParam0->f_3)
{
if (unk_0xC49311A2A500FF09(*uParam0, 0))
{
unk_0xD991F7672CE8EAD3(*uParam0, 120, 1);
uParam0->f_6 = 12;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
else if (!func_184(*uParam0, 474215631))
{
if (func_184(*uParam0, 780511057))
{
unk_0xCA089CD1A17D76DF(*uParam0);
}
unk_0x37DE87D06B5C195D(*uParam0, -1);
uParam0->f_6 = 12;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
break;
case 3:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) > uParam0->f_3)
{
unk_0x1D87FC6C9DC6D4B1(*uParam0, 1, 1);
unk_0x1DC2BF231DE6A016(*uParam0, unk_0x7D2B9E6A64637269(), 500f, -1, 0, 1);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_6 = 4;
uParam0->f_5 = 1;
}
break;
case 11:
func_172(uParam0);
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) > 5000)
{
if (!func_184(*uParam0, 713668775))
{
if (unk_0x419E13582192CFEA(Local_111[func_171(uParam0->f_10) /*11*/]))
{
unk_0x45B1B4E55BF15523(*uParam0, Local_667, 1f, -1, 2f, 0, 1193033728);
}
}
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_6 = 23;
uParam0->f_5 = 1;
}
break;
case 18:
if (!func_184(*uParam0, -2017877118))
{
unk_0x5C679902079A7E80(&uVar1);
if (func_170(unk_0xD6E677FAD7521410(*uParam0, 1), unk_0xD6E677FAD7521410(unk_0x7D2B9E6A64637269(), 1)) > 1.5f)
{
unk_0xFBF1F1BE9D437D22(0, unk_0xD6E677FAD7521410(unk_0x7D2B9E6A64637269(), 1), 0);
}
unk_0x8B515AB1F9C6E8CE(0, "WORLD_HUMAN_MOBILE_FILM_SHOCKING", 6000, 1);
unk_0x1BBD0A5729AB1226(uVar1);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar1);
unk_0x8D5B447F21217223(&uVar1);
uParam0->f_5 = 1;
uParam0->f_6 = 20;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
break;
case 19:
func_172(uParam0);
if (!func_184(*uParam0, -2017877118))
{
unk_0x8B515AB1F9C6E8CE(*uParam0, "WORLD_HUMAN_MOBILE_FILM_SHOCKING", 6000, 1);
uParam0->f_5 = 1;
uParam0->f_6 = 20;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
break;
case 1:
if (!unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 0))
{
func_168(uParam0);
}
break;
case 2:
if (!unk_0x530FB711AE9CF518(*uParam0) && (unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) > 3000)
{
func_168(uParam0);
}
break;
case 4:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) > 8000)
{
unk_0x1DC2BF231DE6A016(*uParam0, unk_0x7D2B9E6A64637269(), 500f, -1, 0, 0);
if (!iLocal_666)
{
if (unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) == 0)
{
unk_0xD63E470D46B4F8A5(unk_0x1146A9AE09CE2B14(), 2, 0);
unk_0x87524F5C1E0857AB(unk_0x1146A9AE09CE2B14(), 0);
iLocal_666 = 1;
}
}
unk_0x1D87FC6C9DC6D4B1(*uParam0, 0, 1);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_6 = 8;
}
else if (unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) > 1)
{
unk_0x1D87FC6C9DC6D4B1(*uParam0, 0, 1);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_6 = 8;
}
break;
case 6:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) > uParam0->f_2)
{
if (!func_157(*uParam0, unk_0x7D2B9E6A64637269(), 15f, 1))
{
func_7(&(uParam0->f_4));
uParam0->f_6 = 7;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
break;
case 7:
if (unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 1))
{
if (uParam0->f_6 != 4 && uParam0->f_6 != 1)
{
if (func_166())
{
if (func_341(*uParam0))
{
unk_0xCA089CD1A17D76DF(*uParam0);
unk_0x1DC2BF231DE6A016(*uParam0, unk_0x7D2B9E6A64637269(), 500f, -1, 0, 1);
uParam0->f_6 = 1;
}
}
}
if (!func_157(*uParam0, unk_0x7D2B9E6A64637269(), 120f, 1))
{
func_5(uParam0, 1, 0, 1);
}
}
else
{
func_168(uParam0);
}
break;
case 8:
if (!func_157(*uParam0, unk_0x7D2B9E6A64637269(), 120f, 1))
{
func_5(uParam0, 1, 0, 1);
}
break;
case 9:
if (unk_0xECA23EB9C2A5E83F(*uParam0))
{
func_176(uParam0, 1);
return;
}
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) > uParam0->f_2 || !func_184(*uParam0, 2104565373))
{
func_163(uParam0);
}
break;
case 12:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) >= uParam0->f_2)
{
unk_0x1DC2BF231DE6A016(*uParam0, unk_0x7D2B9E6A64637269(), 500f, -1, 0, 1);
uParam0->f_6 = 5;
}
else
{
unk_0xD991F7672CE8EAD3(*uParam0, 120, 1);
}
break;
case 13:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) >= uParam0->f_2)
{
if (!func_157(*uParam0, unk_0x7D2B9E6A64637269(), 15f, 1))
{
func_163(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
else if (func_177(Local_111[func_171(uParam0->f_10) /*11*/], *uParam0, 1126825984, 1, 250, 7))
{
func_176(uParam0, 0);
}
else
{
func_162(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
break;
case 15:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) >= uParam0->f_2)
{
if (!func_157(*uParam0, unk_0x7D2B9E6A64637269(), 15f, 1))
{
func_163(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
else if (func_177(Local_111[func_171(uParam0->f_10) /*11*/], *uParam0, 1126825984, 1, 250, 7))
{
func_176(uParam0, 0);
}
else
{
func_162(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
break;
case 16:
if (unk_0xECA23EB9C2A5E83F(*uParam0))
{
func_176(uParam0, 1);
return;
}
if ((unk_0xDFB7BFA6482FEE1E() - iLocal_670) >= 9000)
{
if (!func_161(uParam0))
{
func_163(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
else
{
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 1;
uParam0->f_6 = 16;
}
}
else if ((unk_0xDFB7BFA6482FEE1E() - iLocal_670) >= 5000 && (unk_0xDFB7BFA6482FEE1E() - iLocal_670) <= 5500)
{
if (unk_0xC49311A2A500FF09(*uParam0, 0))
{
if (unk_0xA15EA13398B66F93(*uParam0))
{
unk_0xC7411AA70F899F00(*uParam0);
}
}
}
break;
case 14:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) >= uParam0->f_2)
{
if (!func_157(*uParam0, unk_0x7D2B9E6A64637269(), 15f, 1))
{
func_163(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
else if (func_177(Local_111[func_171(uParam0->f_10) /*11*/], *uParam0, 1126825984, 1, 250, 7))
{
func_176(uParam0, 0);
}
else
{
func_162(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
break;
case 17:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) >= uParam0->f_2)
{
if (!func_157(*uParam0, unk_0x7D2B9E6A64637269(), 15f, 1))
{
func_163(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
else if (func_177(Local_111[func_171(uParam0->f_10) /*11*/], *uParam0, 1126825984, 1, 250, 7))
{
func_176(uParam0, 0);
}
else
{
func_162(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
break;
case 20:
if (unk_0x24A466C655E8588A(unk_0x7D2B9E6A64637269(), 6) && !unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if (func_177(*uParam0, unk_0x7D2B9E6A64637269(), 1126825984, 1, 250, 7))
{
func_176(uParam0, 1);
return;
}
}
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) >= 6000)
{
if (!unk_0x8954E9D0A9F6F8CF(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, 5f, 0f, -2f), unk_0xD6E677FAD7521410(iLocal_109, 1) + Vector(2f, 0f, 0f), 9f, 0, 1, 0))
{
func_163(uParam0);
}
else
{
func_168(uParam0);
func_168(&(Local_111[func_171(uParam0->f_10) /*11*/]));
}
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
func_172(uParam0);
break;
case 22:
if (unk_0x24A466C655E8588A(unk_0x7D2B9E6A64637269(), 6))
{
if (func_177(*uParam0, unk_0x7D2B9E6A64637269(), 1126825984, 1, 250, 7))
{
func_176(uParam0, 1);
return;
}
}
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_1) >= uParam0->f_2)
{
if (!func_157(*uParam0, unk_0x7D2B9E6A64637269(), 15f, 1))
{
func_163(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
return;
}
else
{
func_162(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
break;
case 23:
func_202(uParam0, uParam0->f_10, 1);
func_172(uParam0);
if (func_107(*uParam0, Local_667, 2f))
{
if (func_159(*uParam0, Local_667, 1126825984, 0))
{
unk_0xCA089CD1A17D76DF(*uParam0);
uParam0->f_6 = 19;
uParam0->f_5 = 1;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
break;
}
}
int func_159(int iParam0, struct<3> Param1, float fParam4, int iParam5)
{
struct<3> Var0;
struct<3> Var3;
float fVar6;
Var0 = { func_160(Param1 - unk_0xD6E677FAD7521410(iParam0, 1)) };
if (fParam4 < 0.1f || fParam4 > 360f)
{
return 1;
}
if (iParam5 == 0)
{
Var3 = { unk_0x557C9CA8FCC667DF(iParam0) };
}
else
{
Var3 = { func_160(unk_0x885F3A431ECE75E3(iParam0, 31086, 0f, 5f, 0f) - unk_0x885F3A431ECE75E3(iParam0, 31086, 0f, 0f, 0f)) };
}
fVar6 = func_133(Var3, Var0);
if (fVar6 <= SYSTEM::COS((fParam4 / 2f)))
{
return 0;
}
return 1;
}
Vector3 func_160(struct<3> Param0)
{
float fVar0;
float fVar1;
fVar0 = SYSTEM::VMAG(Param0);
if (fVar0 != 0f)
{
fVar1 = (1f / fVar0);
Param0 = { Param0 * Vector(fVar1, fVar1, fVar1) };
}
else
{
Param0.x = 0f;
Param0.f_1 = 0f;
Param0.f_2 = 0f;
}
return Param0;
}
int func_161(var uParam0)
{
if (unk_0x8954E9D0A9F6F8CF(unk_0x7D2B9E6A64637269(), unk_0x9E695CE384C77EF0(iLocal_109, 0f, 10f, -2f), unk_0x9E695CE384C77EF0(iLocal_109, 0f, 3f, 2f), 5f, 0, 1, 0) && unk_0xE6046EB2291D084D(*uParam0))
{
return 1;
}
return 0;
}
void func_162(var uParam0)
{
int iVar0;
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
iVar0 = unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0);
if (func_37(iVar0))
{
if (!unk_0x5F1B1AFB0CA1586A(*uParam0, iVar0, -1, 0, 0))
{
uParam0->f_6 = 18;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
}
}
void func_163(var uParam0)
{
unk_0x78B2DF314748056B(2, uLocal_80, 1862763509);
switch (uParam0->f_8)
{
case 4:
break;
case 10:
break;
case 8:
func_129();
break;
case 3:
if (!func_184(*uParam0, 242628503))
{
if (iLocal_661 <= 20 && iLocal_661 != -1)
{
Local_134[iLocal_661 /*25*/].f_18 = 1;
}
if (!unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 0))
{
if (uParam0->f_10 == 0)
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, func_137(1)), 1f, -1, 1048576000, 0, 1193033728);
uParam0->f_7 = 1;
}
else
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, func_137(0)), 1f, -1, 1048576000, 0, 1193033728);
uParam0->f_7 = 1;
}
}
}
break;
case 2:
if (!unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 0))
{
if (uParam0->f_10 == 0)
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, func_137(1)), 1f, -1, 1048576000, 0, 1193033728);
uParam0->f_7 = 1;
}
else
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, func_137(0)), 1f, -1, 1048576000, 0, 1193033728);
uParam0->f_7 = 1;
}
}
break;
case 9:
if (!Local_134[iLocal_661 /*25*/].f_18)
{
if (uParam0->f_9 == 1)
{
func_164(uParam0);
}
else if (uParam0->f_10 == 0)
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, func_137(1)), 1f, -1, 1048576000, 0, 1193033728);
uParam0->f_7 = 1;
}
else
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, func_137(0)), 1f, -1, 1048576000, 0, 1193033728);
uParam0->f_7 = 1;
}
}
else if (!unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 0))
{
if (uParam0->f_10 == 0)
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, func_137(1)), 1f, -1, 1048576000, 0, 1193033728);
uParam0->f_7 = 1;
}
else
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, func_137(0)), 1f, -1, 1048576000, 0, 1193033728);
uParam0->f_7 = 1;
}
}
break;
default:
break;
}
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 0;
}
void func_164(var uParam0)
{
if (!func_184(*uParam0, -71340211))
{
if (Local_134[iLocal_661 /*25*/].f_23 != 0)
{
if (func_10(Local_134[iLocal_661 /*25*/].f_17))
{
unk_0x1BA17238F2579830(*uParam0, Local_134[iLocal_661 /*25*/].f_17, -1, 0f, 180f, 1f, 0);
}
}
else
{
unk_0x45B1B4E55BF15523(*uParam0, Local_134[iLocal_661 /*25*/].f_19, 1f, 20000, -1f, 0, func_165(Local_134[iLocal_661 /*25*/].f_19, unk_0xD6E677FAD7521410(*uParam0, 1), 1));
}
if (func_37(iLocal_109))
{
unk_0x94F15E506D091111(iLocal_109, 5, 0, 0);
}
uParam0->f_8 = uParam0->f_7;
uParam0->f_7 = 9;
uParam0->f_9 = 1;
}
}
float func_165(struct<2> Param0, var uParam2, struct<2> Param3, Vector3 vParam5, int iParam6)
{
float fVar0;
float fVar1;
float fVar2;
fVar1 = (Param3 - Param0);
fVar2 = (Param3.f_1 - Param0.f_1);
if (fVar2 != 0f)
{
fVar0 = unk_0xF0AE30F012D1FD8C(fVar1, fVar2);
}
else if (fVar1 < 0f)
{
fVar0 = -90f;
}
else
{
fVar0 = 90f;
}
if (iParam6 == 1)
{
fVar0 = (fVar0 * -1f);
if (fVar0 < 0f)
{
fVar0 = (fVar0 + 360f);
}
}
return fVar0;
}
int func_166()
{
if (func_37(iLocal_109) && func_341(unk_0x7D2B9E6A64637269()))
{
if (unk_0xA6E8FBD68548675F(iLocal_109, unk_0x7D2B9E6A64637269(), 1))
{
unk_0xA5030CC1B9A0FDA6(iLocal_109);
if (func_167() || unk_0x5E7C0A485B91DB87(iLocal_109) < 851)
{
return 1;
}
}
}
return 0;
}
int func_167()
{
int iVar0;
int iVar1;
iVar1 = 0;
iVar0 = 0;
while (iVar0 <= 5)
{
if (unk_0x3095B0C5EB2CFFEC(iLocal_109, iVar0, 0))
{
iVar1++;
}
iVar0++;
}
if (iVar1 >= 3)
{
return 1;
}
return 0;
}
void func_168(var uParam0)
{
if (uParam0->f_6 != 3 && uParam0->f_6 != 4)
{
func_169(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_6 = 3;
uParam0->f_5 = 1;
}
}
void func_169(var uParam0)
{
if (uParam0->f_7 == 9)
{
if (uParam0->f_9 >= 2)
{
if (!unk_0xECEC7528A52B4EE8(*uParam0))
{
unk_0x87FB9C4434EDF1A5(*uParam0, 1048576000);
unk_0x1C53495E38DE08B7(*uParam0);
unk_0x4261814A9A26E86F(*uParam0, "missfbi4prepp1", "_bag_drop_garbage_man", 8f, -8f, -1, 56, 0, 0, 0, 0);
}
}
}
}
float func_170(struct<2> Param0, Vector3 vParam2, struct<2> Param3, Vector3 vParam5)
{
return unk_0x832AD84AA258AE80((Param3 - Param0), (Param3.f_1 - Param0.f_1));
}
int func_171(int iParam0)
{
if (iParam0 == 0)
{
return 1;
}
return 0;
}
void func_172(var uParam0)
{
if (func_37(iLocal_109) && (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), iLocal_109, 0) && !unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 0)))
{
if (unk_0x4DDAC4C80BACF92C(iLocal_109) > 0f)
{
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_8 = uParam0->f_7;
uParam0->f_5 = 1;
uParam0->f_6 = 21;
}
}
}
var func_173(int iParam0, bool bParam1, int iParam2)
{
var uVar0;
uVar0 = func_174(iParam0, !bParam1, 0);
if ((iParam2 != 145 && unk_0x575B7C28D81C0B4D(uVar0)) && unk_0x49875FC4498CDA9A(&(Global_1878[iParam2 /*29*/].f_3)))
{
unk_0xDD944E3FD2028A48(uVar0, &(Global_1878[iParam2 /*29*/].f_3));
}
return uVar0;
}
int func_174(int iParam0, bool bParam1, bool bParam2)
{
int iVar0;
if (!unk_0x419E13582192CFEA(iParam0))
{
return 0;
}
iVar0 = unk_0xB20BB447C131B310(iParam0);
if (unk_0x55F5BD4ABD80B211(iParam0))
{
unk_0xDD205B87CDFD0C1B(iVar0, func_175(unk_0x02BFF15CAA701972(), 1f, 1f));
if (!bParam2)
{
unk_0xB592493CDC7124C3(iVar0, bParam1);
}
else
{
unk_0xFA3E6ADC3E5D386E(iVar0, 2);
}
}
else if (unk_0xA2CCAAC7F5CA3F49(iParam0))
{
unk_0xDD205B87CDFD0C1B(iVar0, func_175(unk_0x02BFF15CAA701972(), 0.7f, 0.7f));
unk_0xB592493CDC7124C3(iVar0, bParam1);
}
else if (unk_0x50997FC21D62251F(iParam0))
{
unk_0xDD205B87CDFD0C1B(iVar0, func_175(unk_0x02BFF15CAA701972(), 0.7f, 0.7f));
}
return iVar0;
}
float func_175(bool bParam0, float fParam1, float fParam2)
{
if (bParam0)
{
return fParam1;
}
return fParam2;
}
void func_176(var uParam0, int iParam1)
{
func_169(uParam0);
if ((unk_0x24A466C655E8588A(unk_0x7D2B9E6A64637269(), 6) || iParam1) || uParam0->f_6 == 23)
{
if (!func_157(unk_0x7D2B9E6A64637269(), *uParam0, 10f, 1))
{
if (!func_184(*uParam0, 1805844857))
{
uParam0->f_6 = 5;
uParam0->f_5 = 1;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
else
{
uParam0->f_6 = 10;
uParam0->f_5 = 1;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
else if (uParam0->f_5 != 1)
{
if (!func_184(*uParam0, 780511057) && !func_184(*uParam0, -71340211))
{
uParam0->f_5 = 1;
uParam0->f_6 = 21;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
}
bool func_177(int iParam0, int iParam1, float fParam2, int iParam3, int iParam4, int iParam5)
{
var uVar0;
struct<3> Var1;
int iVar4;
iVar4 = func_183(iParam0, iParam1);
if (!func_10(iParam0) || !func_10(iParam1))
{
if (iVar4 != -1)
{
func_182(&(Local_38[iVar4 /*4*/]));
}
return 0;
}
if (!func_181(iParam0, iParam1, fParam2, iParam3))
{
return 0;
}
if (iVar4 == -1)
{
iVar4 = func_180();
if (iVar4 == -1)
{
return 0;
}
Local_38[iVar4 /*4*/].f_1 = iParam0;
Local_38[iVar4 /*4*/].f_2 = iParam1;
}
Var1 = { unk_0x885F3A431ECE75E3(iParam0, 31086, 0f, 0f, 0f) };
uVar0 = func_178(&(Local_38[iVar4 /*4*/]), Var1, iParam1, &(Local_38[iVar4 /*4*/].f_3), iParam0, iParam5);
return (uVar0 || (unk_0xDFB7BFA6482FEE1E() - Local_38[iVar4 /*4*/].f_3) < iParam4);
}
int func_178(var uParam0, struct<3> Param1, int iParam4, var uParam5, int iParam6, int iParam7)
{
var uVar0;
struct<3> Var1;
var uVar4;
int iVar7;
int iVar8;
iVar7 = 0;
if (!func_10(iParam4))
{
*uParam0 = 0;
return 0;
}
if (*uParam0 == 0)
{
Var1 = { func_179(iParam4, iParam7) };
*uParam0 = unk_0x3F7B472B49D4D2AC(Param1, Var1 + Var1 - Param1 * Vector(0.1f, 0.1f, 0.1f), 511, iParam6, 7);
return 0;
}
iVar8 = unk_0xA2B3B271E2AE7A08(*uParam0, &uVar0, &Var1, &uVar4, &iVar7);
if (iVar8 == 0)
{
*uParam0 = 0;
return 0;
}
else if (iVar8 == 1)
{
return 0;
}
*uParam0 = 0;
if (unk_0xA2CCAAC7F5CA3F49(iVar7))
{
func_10(iVar7);
if (unk_0xFAA5505029C4B5A6(iVar7) == iParam4)
{
if (bLocal_79)
{
unk_0x52A935C3774D2C0B(Param1, unk_0xD6E677FAD7521410(iParam4, 1), 255, 0, 0, 255, 0, 0, 255, 255);
}
*uParam5 = unk_0xDFB7BFA6482FEE1E();
return 1;
}
return 0;
}
if (unk_0x55F5BD4ABD80B211(iVar7))
{
func_10(iVar7);
if (unk_0xC49311A2A500FF09(iParam4, 0))
{
if (unk_0x611CD1312FD3CA66(iVar7) == unk_0x75B58B38E45C6F9A(iParam4, 0))
{
if (bLocal_79)
{
unk_0x52A935C3774D2C0B(Param1, unk_0xD6E677FAD7521410(iParam4, 1), 255, 0, 0, 255, 0, 0, 255, 255);
}
*uParam5 = unk_0xDFB7BFA6482FEE1E();
return 1;
}
}
return 0;
}
return 0;
}
Vector3 func_179(int iParam0, int iParam1)
{
int iVar0;
if (iParam1 == 7)
{
iVar0 = unk_0xB36B8558948EA7A8(0, 7);
iParam1 = iVar0;
}
if (iParam1 == 0)
{
return unk_0xD6E677FAD7521410(iParam0, 1);
}
else if (iParam1 == 1)
{
return unk_0x885F3A431ECE75E3(iParam0, 31086, 0f, 0f, 0f);
}
else if (iParam1 == 2)
{
return unk_0x885F3A431ECE75E3(iParam0, 39317, 0f, 0f, 0f);
}
else if (iParam1 == 3)
{
return unk_0x885F3A431ECE75E3(iParam0, 18905, 0f, 0f, 0f);
}
else if (iParam1 == 4)
{
return unk_0x885F3A431ECE75E3(iParam0, 57005, 0f, 0f, 0f);
}
else if (iParam1 == 5)
{
return unk_0x885F3A431ECE75E3(iParam0, 63931, 0f, 0f, 0f);
}
else if (iParam1 == 6)
{
return unk_0x885F3A431ECE75E3(iParam0, 36864, 0f, 0f, 0f);
}
return unk_0xD6E677FAD7521410(iParam0, 1);
}
int func_180()
{
int iVar0;
iVar0 = 0;
while (iVar0 < Local_38)
{
if ((Local_38[iVar0 /*4*/] == 0 && Local_38[iVar0 /*4*/].f_1 == 0) && Local_38[iVar0 /*4*/].f_2 == 0)
{
return iVar0;
}
iVar0++;
}
return -1;
}
int func_181(int iParam0, int iParam1, float fParam2, int iParam3)
{
struct<3> Var0;
struct<3> Var3;
float fVar6;
Var0 = { func_160(unk_0xD6E677FAD7521410(iParam1, 1) - unk_0xD6E677FAD7521410(iParam0, 1)) };
if (fParam2 < 0.1f || fParam2 > 360f)
{
return 1;
}
if (iParam3 == 0)
{
Var3 = { unk_0x557C9CA8FCC667DF(iParam0) };
}
else
{
Var3 = { func_160(unk_0x885F3A431ECE75E3(iParam0, 31086, 0f, 5f, 0f) - unk_0x885F3A431ECE75E3(iParam0, 31086, 0f, 0f, 0f)) };
}
fVar6 = func_133(Var3, Var0);
if (fVar6 <= SYSTEM::COS((fParam2 / 2f)))
{
return 0;
}
return 1;
}
void func_182(var uParam0)
{
*uParam0 = 0;
uParam0->f_1 = 0;
uParam0->f_2 = 0;
uParam0->f_3 = 0;
}
int func_183(int iParam0, int iParam1)
{
int iVar0;
iVar0 = 0;
while (iVar0 < Local_38)
{
if (Local_38[iVar0 /*4*/].f_1 == iParam0 && Local_38[iVar0 /*4*/].f_2 == iParam1)
{
return iVar0;
}
iVar0++;
}
return -1;
}
int func_184(int iParam0, int iParam1)
{
if (func_341(uParam0))
{
if (unk_0x4E8DA737B686529A(uParam0, iParam1) == 1 || unk_0x4E8DA737B686529A(iParam0, iParam1) == 0)
{
return 1;
}
}
return 0;
}
void func_185(var uParam0)
{
float fVar0;
if (uParam0->f_9 == 0 && uParam0->f_10 == 1)
{
}
switch (uParam0->f_7)
{
case 1:
if (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), iLocal_109, 1))
{
func_176(uParam0, 0);
return;
}
if (uParam0->f_10 == 0)
{
func_196(uParam0, 1);
}
else
{
func_196(uParam0, 0);
}
break;
case 2:
if (unk_0x2C10A11A684CFE96(*uParam0, iLocal_109))
{
if (!func_184(*uParam0, -1794415470))
{
if (uParam0->f_10 == 0)
{
func_130(0);
}
else
{
uParam0->f_7 = 3;
}
}
}
else if (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), iLocal_109, 1))
{
func_176(uParam0, 0);
return;
}
break;
case 3:
if (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), iLocal_109, 1))
{
func_176(uParam0, 0);
return;
}
if (bLocal_664)
{
if (iLocal_661 <= 20 && iLocal_661 != -1)
{
if (!Local_134[iLocal_661 /*25*/].f_18)
{
if (func_107(*uParam0, Local_134[iLocal_661 /*25*/], 20f))
{
if (Local_134[iLocal_661 /*25*/].f_9 && unk_0x8879B2803A5F8682(iLocal_109))
{
func_195();
}
}
}
}
else
{
uParam0->f_7 = 10;
}
}
break;
case 4:
if (func_107(*uParam0, Local_134[iLocal_661 /*25*/], 25f))
{
if (Local_134[iLocal_661 /*25*/].f_9)
{
func_194(uParam0);
}
else
{
Local_134[iLocal_661 /*25*/].f_18 = 1;
func_130(0);
}
}
break;
case 5:
if (func_37(iLocal_109))
{
unk_0x101C61FF49B27BB8(iLocal_109, 25f, 10, 0);
fVar0 = unk_0x4DDAC4C80BACF92C(iLocal_109);
if (fVar0 < 8f)
{
func_194(uParam0);
}
}
break;
case 6:
if (!func_184(*uParam0, 242628503) && unk_0x8879B2803A5F8682(iLocal_109))
{
if (bLocal_664)
{
uParam0->f_8 = uParam0->f_7;
uParam0->f_7 = 7;
}
else
{
unk_0xCC5ED49CF9C9215F(*uParam0, 0, 0);
uParam0->f_8 = uParam0->f_7;
uParam0->f_7 = 8;
}
}
break;
case 7:
if (func_341(Local_111[1 /*11*/]))
{
if (unk_0xF41EB7643E61A928(Local_111[1 /*11*/], iLocal_109, 0) && Local_111[1 /*11*/].f_7 == 3)
{
func_130(0);
}
}
break;
case 8:
if (!unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 0))
{
func_164(uParam0);
}
break;
case 9:
func_186(uParam0);
break;
}
}
void func_186(var uParam0)
{
var uVar0;
var uVar1;
if (uParam0->f_9 >= 1 && uParam0->f_9 != 0)
{
}
switch (uParam0->f_9)
{
case 1:
if (!func_184(*uParam0, -2015108952))
{
unk_0x5C679902079A7E80(&uVar0);
if (func_170(unk_0xD6E677FAD7521410(*uParam0, 1), Local_134[iLocal_661 /*25*/].f_19) > 1.5f)
{
unk_0xFBF1F1BE9D437D22(0, Local_134[iLocal_661 /*25*/].f_19, 0);
}
unk_0x4261814A9A26E86F(0, "missfbi4prepp1", "_bag_pickup_garbage_man", 8f, -16f, -1, 528384, 0, 0, 0, 0);
unk_0x1BBD0A5729AB1226(uVar0);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar0);
unk_0x8D5B447F21217223(&uVar0);
uParam0->f_9 = 2;
}
else if (func_191(Local_134[iLocal_661 /*25*/].f_19, *uParam0, 1f, 1f, 8f))
{
func_190(uParam0);
return;
}
unk_0x7979149EE8FE954D(*uParam0, 0.2f);
break;
case 2:
if (func_184(*uParam0, 242628503))
{
if (unk_0x698F51FB33ADAF7B(*uParam0, "missfbi4prepp1", "_bag_pickup_garbage_man", 3))
{
if (unk_0x4598B7969D5B0A28(*uParam0, "missfbi4prepp1", "_bag_pickup_garbage_man") >= 0.333f)
{
unk_0xC63C967EC1D348E4(*uParam0, "missfbi4prepp1_garbageman", 0f);
unk_0xBCF9CFE51F223AF8(*uParam0, "missfbi4prepp1_garbageman");
if (func_10(Local_134[iLocal_661 /*25*/].f_17) && !unk_0x5976053523EA16C8(Local_134[iLocal_661 /*25*/].f_17))
{
unk_0x0F1058706D5A58B4(Local_134[iLocal_661 /*25*/].f_17, *uParam0, unk_0xA79DFB802C09F5F5(*uParam0, 28422), 0f, 0f, 0f, 0f, 0f, 0f, 1, 1, 0, 0, 2, 1);
}
}
}
if (func_191(Local_134[iLocal_661 /*25*/].f_19, *uParam0, 1f, 1f, 8f))
{
func_190(uParam0);
return;
}
}
else if (!func_184(*uParam0, 713668775))
{
if (func_37(iLocal_109))
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, 0f, -4.8f, 0f), 1f, -1, 0.25f, 0, unk_0xA8D713A937F31250(iLocal_109));
}
uParam0->f_9 = 3;
}
unk_0x7979149EE8FE954D(*uParam0, 0.2f);
break;
case 3:
if (func_37(iLocal_109))
{
if (!func_191(unk_0x9E695CE384C77EF0(iLocal_109, 0f, -5.5f, 0f), iLocal_109, 1.9f, 1.9f, 8f))
{
if (unk_0x591190E69BE43117(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, 0f, -5.5f, 0f), 0.9f, 0.9f, 2f, 0, 1, 0))
{
if (!func_184(*uParam0, 713668775))
{
unk_0x5C679902079A7E80(&uVar1);
if (func_170(unk_0xD6E677FAD7521410(*uParam0, 1), unk_0xD6E677FAD7521410(iLocal_109, 1)) > 3f)
{
unk_0x12D312F073772E84(0, unk_0xA8D713A937F31250(iLocal_109), 0);
}
unk_0x4261814A9A26E86F(0, "missfbi4prepp1", "_bag_throw_garbage_man", 8f, -8f, -1, 0, 0, 0, 0, 0);
unk_0x1BBD0A5729AB1226(uVar1);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar1);
unk_0x8D5B447F21217223(&uVar1);
uParam0->f_9 = 4;
}
}
else if (!func_184(*uParam0, 713668775))
{
unk_0x45B1B4E55BF15523(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, 0f, -4.8f, 0f), 1f, -1, 0.25f, 0, unk_0xA8D713A937F31250(iLocal_109));
}
}
else
{
func_188(uParam0);
}
}
break;
case 4:
if (!func_191(unk_0x9E695CE384C77EF0(iLocal_109, 0f, -5.5f, 0f), *uParam0, 1.9f, 1.9f, 8f))
{
if (func_184(*uParam0, 242628503))
{
if (unk_0x698F51FB33ADAF7B(*uParam0, "missfbi4prepp1", "_bag_throw_garbage_man", 3))
{
if (unk_0x4598B7969D5B0A28(*uParam0, "missfbi4prepp1", "_bag_throw_garbage_man") >= 0.391f)
{
if (func_10(Local_134[iLocal_661 /*25*/].f_17))
{
if (unk_0x5976053523EA16C8(Local_134[iLocal_661 /*25*/].f_17))
{
unk_0x87FB9C4434EDF1A5(*uParam0, 1048576000);
unk_0x1C53495E38DE08B7(*uParam0);
unk_0x3211C35423263392(Local_134[iLocal_661 /*25*/].f_17, 1, 0);
unk_0x6C7C4EFD3F245591(Local_134[iLocal_661 /*25*/].f_17, 2f, -1f, -1f, -1f, -1f, -1f, -1f, -1f, -1082130432, -1082130432, -1082130432);
unk_0x0A6448DF4E471932(Local_134[iLocal_661 /*25*/].f_17, 1, unk_0x557C9CA8FCC667DF(*uParam0), 0, 1, 1, 0);
}
if (unk_0x83B12E293561B796(Local_134[iLocal_661 /*25*/].f_17, iLocal_109))
{
func_187(&(Local_134[iLocal_661 /*25*/].f_17));
}
}
}
}
}
else
{
uParam0->f_9 = 0;
if (func_37(iLocal_109))
{
unk_0x616B09EEEFED8FAF(iLocal_109, 5, 0);
func_187(&(Local_134[iLocal_661 /*25*/].f_17));
}
func_163(uParam0);
}
}
else
{
func_188(uParam0);
}
break;
case 5:
break;
}
}
void func_187(var uParam0)
{
if (unk_0x419E13582192CFEA(*uParam0))
{
if (unk_0xD79E16EA1337F8F9(*uParam0))
{
unk_0x3211C35423263392(*uParam0, 1, 1);
}
unk_0x04F4D55F2C0C756D(uParam0);
}
}
void func_188(var uParam0)
{
var uVar0;
var uVar1;
unk_0x78B2DF314748056B(5, uLocal_80, 1862763509);
func_169(uParam0);
if (!unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if (!unk_0xC49311A2A500FF09(*uParam0, 0))
{
unk_0xFD232B7DCAA5A304(*uParam0, unk_0x7D2B9E6A64637269(), 8f, -1f, 10f, 0);
}
else
{
unk_0x5C679902079A7E80(&uVar0);
unk_0xCC5ED49CF9C9215F(0, 0, 0);
unk_0x9DA29013F33252A6(0, unk_0x7D2B9E6A64637269(), 0, 16);
unk_0x1BBD0A5729AB1226(uVar0);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar0);
unk_0x8D5B447F21217223(&uVar0);
}
}
else
{
unk_0x5C679902079A7E80(&uVar1);
unk_0xB0C1A43193C25F7A(0, unk_0x7D2B9E6A64637269(), 0);
unk_0x9DA29013F33252A6(0, unk_0x7D2B9E6A64637269(), 0, 16);
unk_0x1BBD0A5729AB1226(uVar1);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar1);
unk_0x8D5B447F21217223(&uVar1);
}
unk_0x87FB9C4434EDF1A5(*uParam0, 1048576000);
unk_0x1C53495E38DE08B7(*uParam0);
func_189();
if (!unk_0x575B7C28D81C0B4D(uParam0->f_4))
{
uParam0->f_4 = func_173(*uParam0, 1, 145);
}
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_8 = uParam0->f_7;
uParam0->f_5 = 1;
uParam0->f_6 = 15;
}
void func_189()
{
Local_82 = 0;
Local_82.f_26 = 0;
Local_82.f_18 = 0;
}
void func_190(var uParam0)
{
var uVar0;
var uVar1;
unk_0x78B2DF314748056B(5, uLocal_80, 1862763509);
func_169(uParam0);
if (!unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if (!unk_0xC49311A2A500FF09(*uParam0, 0))
{
unk_0xFD232B7DCAA5A304(*uParam0, unk_0x7D2B9E6A64637269(), 8f, -1f, 10f, 0);
}
else
{
unk_0x5C679902079A7E80(&uVar0);
unk_0xCC5ED49CF9C9215F(0, 0, 0);
unk_0x9DA29013F33252A6(0, unk_0x7D2B9E6A64637269(), 0, 16);
unk_0x1BBD0A5729AB1226(uVar0);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar0);
unk_0x8D5B447F21217223(&uVar0);
}
}
else
{
unk_0x5C679902079A7E80(&uVar1);
unk_0xB0C1A43193C25F7A(0, unk_0x7D2B9E6A64637269(), 0);
unk_0x9DA29013F33252A6(0, unk_0x7D2B9E6A64637269(), 0, 16);
unk_0x1BBD0A5729AB1226(uVar1);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar1);
unk_0x8D5B447F21217223(&uVar1);
}
unk_0x87FB9C4434EDF1A5(*uParam0, 1048576000);
unk_0x1C53495E38DE08B7(*uParam0);
func_189();
if (!unk_0x575B7C28D81C0B4D(uParam0->f_4))
{
uParam0->f_4 = func_173(*uParam0, 1, 145);
}
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_8 = uParam0->f_7;
uParam0->f_5 = 1;
uParam0->f_6 = 14;
}
int func_191(struct<3> Param0, int iParam3, struct<3> Param4)
{
Local_82.f_2 = { Param0 };
Local_82.f_8 = { Param4 };
func_192(&Local_82, iParam3);
if (Local_82.f_26)
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if (unk_0x55F5BD4ABD80B211(Local_82.f_18))
{
if (func_10(Local_82.f_18))
{
if (unk_0x611CD1312FD3CA66(Local_82.f_18) == unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 1))
{
return 1;
}
}
}
}
else if (unk_0xA2CCAAC7F5CA3F49(Local_82.f_18))
{
if (func_10(Local_82.f_18))
{
if (unk_0xFAA5505029C4B5A6(Local_82.f_18) == unk_0x7D2B9E6A64637269())
{
return 1;
}
}
}
}
return 0;
}
void func_192(var uParam0, var uParam1)
{
int iVar0;
int iVar1;
iVar1 = unk_0xA2B3B271E2AE7A08(*uParam0, &iVar0, &(uParam0->f_20), &(uParam0->f_23), &(uParam0->f_18));
uParam0->f_19 = 2 == iVar1;
if (uParam0->f_19)
{
if (0 == iVar0)
{
uParam0->f_26 = 0;
}
else
{
uParam0->f_26 = 1;
}
}
if (iVar1 != 1)
{
func_193(uParam0, uParam1);
}
}
void func_193(var uParam0, int iParam1)
{
switch (uParam0->f_1)
{
case 0:
break;
case 1:
*uParam0 = unk_0x3F7B472B49D4D2AC(uParam0->f_2, uParam0->f_5, 511, uParam1, 7);
break;
case 2:
*uParam0 = unk_0x4E682F2B3EA9361F(uParam0->f_17, 511, 4);
break;
case 3:
*uParam0 = unk_0x86838FAA1E8A1038(uParam0->f_17, 511, 4);
break;
case 4:
*uParam0 = unk_0x9626157791916A72(uParam0->f_2, uParam0->f_8, uParam0->f_11, uParam0->f_14, 6, iParam1, 4);
break;
case 5:
*uParam0 = unk_0x7AD43B94CD205A49(uParam0->f_2, uParam0->f_5, uParam0->f_15, 511, iParam1, 4);
break;
}
uParam0->f_16 = *uParam0 != 0;
}
void func_194(var uParam0)
{
var uVar0;
if (func_37(iLocal_109))
{
unk_0x5C679902079A7E80(&uVar0);
unk_0xE946751408DFA71B(0, iLocal_109, Local_134[iLocal_661 /*25*/].f_3, 8f, 0, joaat("trash"), 786469, 10f, 15f);
unk_0xE7FD307AF3D07EF7(0, iLocal_109, Local_134[iLocal_661 /*25*/].f_3, Local_134[iLocal_661 /*25*/].f_8, Local_134[iLocal_661 /*25*/].f_10, 5f, 1);
unk_0x1BBD0A5729AB1226(uVar0);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar0);
unk_0x8D5B447F21217223(&uVar0);
uParam0->f_7 = 6;
}
}
void func_195()
{
func_164(&(Local_111[1 /*11*/]));
}
void func_196(var uParam0, bool bParam1)
{
int iVar0;
if (func_191(unk_0x9E695CE384C77EF0(iLocal_109, func_137(bParam1)), iLocal_109, 1.9f, 1.9f, 8f))
{
if (unk_0x8954E9D0A9F6F8CF(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, 5f, 0f, -2f), unk_0xD6E677FAD7521410(iLocal_109, 1) + Vector(2f, 0f, 0f), 9f, 0, 1, 0) && unk_0x8954E9D0A9F6F8CF(unk_0x7D2B9E6A64637269(), unk_0x9E695CE384C77EF0(iLocal_109, 5f, 0f, -2f), unk_0xD6E677FAD7521410(iLocal_109, 1) + Vector(2f, 0f, 0f), 9f, 0, 1, 0))
{
func_197(uParam0);
}
else if (!func_184(*uParam0, 1227113341) && unk_0x8954E9D0A9F6F8CF(unk_0x7D2B9E6A64637269(), unk_0x9E695CE384C77EF0(iLocal_109, 5f, 0f, -2f), unk_0xD6E677FAD7521410(iLocal_109, 1) + Vector(2f, 0f, 0f), 9f, 0, 1, 0))
{
unk_0xCA089CD1A17D76DF(*uParam0);
unk_0xF0ED372419FE0E70(*uParam0, unk_0x7D2B9E6A64637269(), -1, 4f, 1f, 1073741824, 0);
}
}
else if (func_107(*uParam0, unk_0x9E695CE384C77EF0(iLocal_109, func_137(bParam1)), 5f))
{
iVar0 = -1;
if (!bParam1)
{
iVar0 = 0;
}
unk_0x95CA4545D0C61309(*uParam0, iLocal_109, -1, iVar0, 1f, 8388609, 0);
uParam0->f_7 = 2;
}
}
void func_197(var uParam0)
{
var uVar0;
var uVar1;
unk_0x78B2DF314748056B(5, uLocal_80, 1862763509);
func_169(uParam0);
if (!unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if (!unk_0xC49311A2A500FF09(*uParam0, 0))
{
unk_0xFD232B7DCAA5A304(*uParam0, unk_0x7D2B9E6A64637269(), 8f, -1f, 10f, 0);
}
else
{
unk_0x5C679902079A7E80(&uVar0);
unk_0xCC5ED49CF9C9215F(0, 0, 0);
unk_0x9DA29013F33252A6(0, unk_0x7D2B9E6A64637269(), 0, 16);
unk_0x1BBD0A5729AB1226(uVar0);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar0);
unk_0x8D5B447F21217223(&uVar0);
}
}
else
{
unk_0x5C679902079A7E80(&uVar1);
unk_0xB0C1A43193C25F7A(0, unk_0x7D2B9E6A64637269(), 0);
unk_0x9DA29013F33252A6(0, unk_0x7D2B9E6A64637269(), 0, 16);
unk_0x1BBD0A5729AB1226(uVar1);
unk_0x8A1AC8EBC73850C8(*uParam0, uVar1);
unk_0x8D5B447F21217223(&uVar1);
}
unk_0x87FB9C4434EDF1A5(*uParam0, 1048576000);
unk_0x1C53495E38DE08B7(*uParam0);
func_189();
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_8 = uParam0->f_7;
uParam0->f_5 = 1;
uParam0->f_6 = 13;
}
void func_198(var uParam0)
{
if (uParam0->f_5 != 1)
{
if (func_37(iLocal_109) && unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if (!func_184(*uParam0, 2104565373) && unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 0))
{
if (func_157(unk_0x7D2B9E6A64637269(), iLocal_109, 10f, 1))
{
if (unk_0x83B12E293561B796(iLocal_109, unk_0x7D2B9E6A64637269()))
{
unk_0xB17DC325CCB9F8CE(*uParam0, unk_0x7D2B9E6A64637269(), 0, 0f, 0f, 0f, 10f, 100, 1, -957453492);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_6 = 9;
}
}
}
}
}
}
void func_199()
{
int iVar0;
iVar0 = 0;
while (iVar0 <= (iLocal_81 - 1))
{
if (Local_134[iVar0 /*25*/].f_23 != 0)
{
if (Local_134[iVar0 /*25*/].f_24)
{
if ((iVar0 != iLocal_661 && func_10(Local_134[iVar0 /*25*/].f_17)) && func_201(Local_134[iVar0 /*25*/].f_17, unk_0x7D2B9E6A64637269(), 1) > 200f)
{
unk_0x04F4D55F2C0C756D(&(Local_134[iVar0 /*25*/].f_17));
Local_134[iVar0 /*25*/].f_24 = 0;
}
}
else if (Local_134[iVar0 /*25*/].f_23 != 0)
{
if (func_107(unk_0x7D2B9E6A64637269(), Local_134[iVar0 /*25*/], 100f) || func_107(Local_111[0 /*11*/], Local_134[iVar0 /*25*/], 120f))
{
Local_134[iVar0 /*25*/].f_24 = func_200(&(Local_134[iVar0 /*25*/].f_17), Local_134[iVar0 /*25*/].f_23, Local_134[iVar0 /*25*/].f_19, Local_134[iVar0 /*25*/].f_22, 1);
}
}
}
iVar0++;
}
}
int func_200(var uParam0, var uParam1, struct<3> Param2, float fParam5, bool bParam6)
{
if (!unk_0x419E13582192CFEA(*uParam0))
{
if (func_152(uParam1, "Loading", 0))
{
*uParam0 = unk_0x795434E153F90E41(uParam1, Param2, 1, 1, 0);
if (unk_0x419E13582192CFEA(*uParam0))
{
unk_0xCD37A28258D70638(*uParam0, uParam5);
unk_0xC5DE9743D6DA2C15(*uParam0);
if (bParam6)
{
func_151(uParam1, 1);
}
return 1;
}
}
}
else if (func_10(*uParam0))
{
return 1;
}
return 0;
}
float func_201(int iParam0, int iParam1, int iParam2)
{
struct<3> Var0;
struct<3> Var3;
if (!unk_0xE50EB54E0F21BED0(iParam0, 0))
{
Var0 = { unk_0xD6E677FAD7521410(iParam0, 1) };
}
else
{
Var0 = { unk_0xD6E677FAD7521410(iParam0, 0) };
}
if (!unk_0xE50EB54E0F21BED0(iParam1, 0))
{
Var3 = { unk_0xD6E677FAD7521410(iParam1, 1) };
}
else
{
Var3 = { unk_0xD6E677FAD7521410(iParam1, 0) };
}
return unk_0x0BABEFEA577FCFA4(Var0, Var3, iParam2);
}
void func_202(var uParam0, int iParam1, int iParam2)
{
if (uParam0->f_5 != 1 || iParam2)
{
if (!func_341(Local_111[func_171(iParam1) /*11*/]))
{
if (!bLocal_665)
{
if (unk_0x419E13582192CFEA(Local_111[func_171(iParam1) /*11*/]))
{
if (func_181(*uParam0, Local_111[func_171(iParam1) /*11*/], 140f, 0) || func_157(Local_111[func_171(iParam1) /*11*/], *uParam0, 3f, 1))
{
func_176(uParam0, 0);
bLocal_665 = true;
return;
}
else
{
Local_667 = { unk_0xD6E677FAD7521410(Local_111[func_171(iParam1) /*11*/], 1) };
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_8 = uParam0->f_7;
uParam0->f_5 = 1;
uParam0->f_6 = 11;
}
}
else
{
func_176(uParam0, 0);
}
}
}
else if (Local_111[func_171(iParam1) /*11*/].f_6 == 22)
{
if (func_181(*uParam0, Local_111[func_171(iParam1) /*11*/], 140f, 0) && func_157(Local_111[func_171(iParam1) /*11*/], unk_0x7D2B9E6A64637269(), 15f, 1))
{
uParam0->f_5 = 1;
uParam0->f_6 = 21;
}
}
else if (Local_111[func_171(iParam1) /*11*/].f_6 == 5 || Local_111[func_171(iParam1) /*11*/].f_6 == 7)
{
if (func_157(Local_111[func_171(iParam1) /*11*/], *uParam0, 10f, 1))
{
func_176(uParam0, 0);
}
}
if (func_213(*uParam0))
{
func_169(uParam0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_8 = uParam0->f_7;
uParam0->f_5 = 1;
uParam0->f_6 = 21;
}
if (uParam0->f_10 == 0 && uParam0->f_7 == 4)
{
if (func_161(uParam0))
{
if (unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 0))
{
unk_0xB17DC325CCB9F8CE(*uParam0, unk_0x7D2B9E6A64637269(), 0, 0f, 0f, 0f, 10f, 100, 1, -957453492);
unk_0xD5381DFC7ACB5A30(iLocal_109, 2000f);
iLocal_670 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_6 = 16;
uParam0->f_5 = 1;
}
}
}
if (func_204(*uParam0, 1, 70f, 170f, 0, 1, 0, 0) && !func_203(uParam0))
{
if (unk_0x24A466C655E8588A(unk_0x7D2B9E6A64637269(), 6))
{
if (func_37(iLocal_109))
{
if (unk_0xF41EB7643E61A928(*uParam0, iLocal_109, 0))
{
if (unk_0x4DDAC4C80BACF92C(iLocal_109) > 5f)
{
if (iParam1 == 0)
{
unk_0x5B1F7232B835EC44(*uParam0, iLocal_109, unk_0x7D2B9E6A64637269(), 8, 30f, 786469, 300f, 2f, 1);
uParam0->f_6 = 7;
unk_0x37DE87D06B5C195D(Local_111[func_171(iParam1) /*11*/], -1);
Local_111[func_171(iParam1) /*11*/].f_6 = 10;
Local_111[func_171(iParam1) /*11*/].f_5 = 1;
uParam0->f_5 = 1;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
Local_111[func_171(iParam1) /*11*/].f_1 = unk_0xDFB7BFA6482FEE1E();
}
else
{
unk_0x37DE87D06B5C195D(*uParam0, -1);
uParam0->f_6 = 12;
unk_0x5B1F7232B835EC44(Local_111[func_171(iParam1) /*11*/], iLocal_109, unk_0x7D2B9E6A64637269(), 8, 30f, 786469, 300f, 2f, 1);
Local_111[func_171(iParam1) /*11*/].f_6 = 5;
Local_111[func_171(iParam1) /*11*/].f_5 = 1;
uParam0->f_5 = 1;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
Local_111[func_171(iParam1) /*11*/].f_1 = unk_0xDFB7BFA6482FEE1E();
}
}
else
{
func_176(uParam0, 0);
if (unk_0x419E13582192CFEA(Local_111[func_171(iParam1) /*11*/]))
{
if (func_181(Local_111[func_171(iParam1) /*11*/], unk_0x7D2B9E6A64637269(), 1126825984, 0))
{
func_176(&(Local_111[func_171(iParam1) /*11*/]), 0);
}
}
}
unk_0xA5030CC1B9A0FDA6(*uParam0);
}
else
{
func_176(uParam0, 0);
if (unk_0x419E13582192CFEA(Local_111[func_171(iParam1) /*11*/]))
{
if (func_177(Local_111[func_171(iParam1) /*11*/], *uParam0, 1126825984, 1, 250, 7))
{
func_176(&(Local_111[func_171(iParam1) /*11*/]), 0);
}
}
}
}
}
else
{
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_8 = uParam0->f_7;
uParam0->f_5 = 1;
uParam0->f_6 = 21;
unk_0xA5030CC1B9A0FDA6(*uParam0);
if (func_177(Local_111[func_171(iParam1) /*11*/], *uParam0, 1126825984, 1, 250, 7))
{
Local_111[func_171(iParam1) /*11*/].f_1 = unk_0xDFB7BFA6482FEE1E();
Local_111[func_171(iParam1) /*11*/].f_8 = uParam0->f_7;
Local_111[func_171(iParam1) /*11*/].f_5 = 1;
Local_111[func_171(iParam1) /*11*/].f_6 = 21;
unk_0xA5030CC1B9A0FDA6(Local_111[func_171(iParam1) /*11*/]);
}
}
uParam0->f_5 = 1;
}
else if (unk_0xECA23EB9C2A5E83F(*uParam0))
{
func_169(uParam0);
unk_0x1DC2BF231DE6A016(*uParam0, unk_0x7D2B9E6A64637269(), 500f, -1, 0, 1);
uParam0->f_6 = 2;
uParam0->f_5 = 1;
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
}
if (unk_0x6B9E71121F5B8154(*uParam0))
{
if (func_10(Local_134[iLocal_661 /*25*/].f_17))
{
if (unk_0x5976053523EA16C8(Local_134[iLocal_661 /*25*/].f_17))
{
unk_0x3211C35423263392(Local_134[iLocal_661 /*25*/].f_17, 1, 0);
unk_0x0A6448DF4E471932(Local_134[iLocal_661 /*25*/].f_17, 1, unk_0x557C9CA8FCC667DF(*uParam0), 0, 1, 1, 0);
}
}
}
}
if (uParam0->f_5 != 1)
{
if (func_341(Local_111[func_171(iParam1) /*11*/]))
{
if (unk_0xECA23EB9C2A5E83F(Local_111[func_171(iParam1) /*11*/]))
{
func_169(uParam0);
unk_0x1DC2BF231DE6A016(*uParam0, unk_0x7D2B9E6A64637269(), 120f, -1, 0, 0);
uParam0->f_1 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_6 = 7;
uParam0->f_5 = 1;
}
}
}
}
int func_203(var uParam0)
{
if ((unk_0x591190E69BE43117(unk_0x7D2B9E6A64637269(), unk_0x9E695CE384C77EF0(*uParam0, 0f, -2f, 0f), 2f, 3f, 2f, 0, 1, 0) && !unk_0x24A466C655E8588A(unk_0x7D2B9E6A64637269(), 6)) && unk_0xB9B9B15BD0EA06BE(unk_0x7D2B9E6A64637269()))
{
return 1;
}
return 0;
}
int func_204(int iParam0, bool bParam1, float fParam2, float fParam3, bool bParam4, bool bParam5, bool bParam6, bool bParam7)
{
struct<3> Var0;
if (func_10(unk_0x7D2B9E6A64637269()) && func_10(iParam0))
{
if (unk_0xA6E8FBD68548675F(iParam0, unk_0x7D2B9E6A64637269(), 1))
{
return 1;
}
if (func_209(iParam0, bParam1, bParam5, bParam6, bParam7))
{
return 1;
}
if (!unk_0x24A466C655E8588A(unk_0x7D2B9E6A64637269(), 6))
{
if (unk_0x97AEEA04505AFDC3(unk_0x7D2B9E6A64637269()))
{
Var0 = { unk_0xD6E677FAD7521410(unk_0x7D2B9E6A64637269(), 1) - unk_0xD6E677FAD7521410(iParam0, 1) };
if ((((Var0.x * Var0.x) + (Var0.f_1 * Var0.f_1)) + (Var0.f_2 * Var0.f_2)) <= 5f)
{
return func_208(unk_0x7D2B9E6A64637269(), iParam0, fParam2);
}
}
}
if (bParam4)
{
return 0;
}
else if (func_205(iParam0, fParam3))
{
return 1;
}
}
return 0;
}
int func_205(int iParam0, float fParam1)
{
float fVar0;
if (func_10(unk_0x7D2B9E6A64637269()) && func_10(iParam0))
{
if (func_207(iParam0) || unk_0x87BE50F80F3FCEAB(unk_0x1146A9AE09CE2B14(), iParam0))
{
if (unk_0x24A466C655E8588A(unk_0x7D2B9E6A64637269(), 6))
{
fVar0 = 40f;
}
else
{
fVar0 = 3f;
}
if (unk_0xD406352E21A7E1D0(unk_0x7D2B9E6A64637269(), iParam0, fVar0, fVar0, fVar0, 0, 1, 0))
{
if (func_206(iParam0, fParam1))
{
return 1;
}
}
}
}
return 0;
}
bool func_206(int iParam0, float fParam1)
{
return func_177(iParam0, unk_0x7D2B9E6A64637269(), fParam1, 1, 250, 7);
}
int func_207(int iParam0)
{
if (unk_0x4140085B99B17F97(unk_0x1146A9AE09CE2B14(), iParam0) && unk_0x24A466C655E8588A(unk_0x7D2B9E6A64637269(), 6))
{
return 1;
}
return 0;
}
bool func_208(int iParam0, int iParam1, float fParam2)
{
struct<3> Var0;
struct<3> Var3;
Var0 = { unk_0x557C9CA8FCC667DF(iParam0) };
Var3 = { unk_0xD6E677FAD7521410(iParam1, 1) - unk_0xD6E677FAD7521410(iParam0, 1) };
return (((Var0.x * Var3.x) + (Var0.f_1 * Var3.f_1)) / SYSTEM::VDIST(Var3, 0f, 0f, 0f)) > SYSTEM::COS(fParam2);
}
int func_209(int iParam0, bool bParam1, bool bParam2, bool bParam3, bool bParam4)
{
float fVar0;
float fVar1;
int iVar2;
fVar0 = 8f;
fVar1 = 15f;
if (bParam1 == 0)
{
fVar0 = 1.86f;
fVar1 = 1.86f;
}
if (bParam2)
{
fVar0 = 2f;
}
if (func_10(unk_0x7D2B9E6A64637269()) && func_10(iParam0))
{
unk_0xBDC364B886846D11(unk_0x7D2B9E6A64637269(), &iVar2, 1);
if (iVar2 == joaat("weapon_petrolcan"))
{
fVar0 = 3f;
fVar1 = 3f;
}
if (!bParam2)
{
if (func_212(iParam0, bParam1, fVar0, fVar1))
{
return 1;
}
if (func_210(iParam0, fVar1, bParam3, bParam4))
{
return 1;
}
}
else
{
if (unk_0x8E93627D38C90C19(unk_0x7D2B9E6A64637269()))
{
if (unk_0x7F716EA884E75E49(unk_0x7D2B9E6A64637269()))
{
if (unk_0x3E72EB0926A107F9(unk_0xD6E677FAD7521410(iParam0, 1), fVar0, 1))
{
return 1;
}
}
}
else
{
if (bParam1)
{
fVar0 = 1.86f;
fVar1 = 1.86f;
}
if (func_212(iParam0, bParam1, fVar0, fVar1))
{
return 1;
}
}
if (func_210(iParam0, fVar1, bParam3, bParam4))
{
return 1;
}
}
}
return 0;
}
int func_210(int iParam0, float fParam1, bool bParam2, bool bParam3)
{
struct<3> Var0;
struct<3> Var3;
Var0 = { unk_0xD6E677FAD7521410(iParam0, 1) };
Var3 = { Var0 };
Var0.x = (Var0.x - fParam1);
Var0.f_1 = (Var0.f_1 - fParam1);
Var0.f_2 = (Var0.f_2 - fParam1);
Var3.x = (Var3.x + fParam1);
Var3.f_1 = (Var3.f_1 + fParam1);
Var3.f_2 = (Var3.f_2 + fParam1);
if (bParam2)
{
if (((unk_0x24EE3332DFDF21FE(unk_0xD6E677FAD7521410(iParam0, 1), joaat("weapon_grenade"), fParam1, 1) || unk_0x24EE3332DFDF21FE(unk_0xD6E677FAD7521410(iParam0, 1), joaat("weapon_molotov"), fParam1, 1)) || unk_0x24EE3332DFDF21FE(unk_0xD6E677FAD7521410(iParam0, 1), joaat("weapon_smokegrenade"), fParam1, 1)) || unk_0x24EE3332DFDF21FE(unk_0xD6E677FAD7521410(iParam0, 1), joaat("weapon_stickybomb"), 5f, 1))
{
if (bParam3)
{
if (func_211(iParam0, fParam1))
{
return 1;
}
else
{
return 0;
}
}
return 1;
}
}
else
{
if (bParam3)
{
if (func_211(iParam0, fParam1))
{
return 1;
}
else
{
return 0;
}
}
if (unk_0xD7196DD041C06559(Var0, Var3, 1))
{
return 1;
}
}
return 0;
}
int func_211(int iParam0, float fParam1)
{
var uVar0;
struct<3> Var1;
if ((((unk_0xACDE87C3A0618AF7(iParam0, joaat("weapon_grenade"), fParam1, &Var1, &uVar0, 0) || unk_0xACDE87C3A0618AF7(iParam0, joaat("weapon_smokegrenade"), fParam1, &Var1, &uVar0, 0)) || unk_0xACDE87C3A0618AF7(iParam0, joaat("weapon_bzgas"), fParam1, &Var1, &uVar0, 0)) || unk_0xACDE87C3A0618AF7(iParam0, joaat("weapon_stickybomb"), fParam1, &Var1, &uVar0, 0)) || unk_0xACDE87C3A0618AF7(iParam0, joaat("weapon_molotov"), fParam1, &Var1, &uVar0, 0))
{
if (func_159(iParam0, Var1, 90f, 0))
{
return 1;
}
}
return 0;
}
int func_212(int iParam0, bool bParam1, float fParam2, float fParam3)
{
if (bParam1)
{
if (unk_0x7F716EA884E75E49(unk_0x7D2B9E6A64637269()))
{
if (unk_0xD406352E21A7E1D0(unk_0x7D2B9E6A64637269(), iParam0, fParam3, fParam3, fParam3, 0, 1, 0))
{
return 1;
}
}
}
if (unk_0x3E72EB0926A107F9(unk_0xD6E677FAD7521410(iParam0, 1), fParam2, 1))
{
return 1;
}
return 0;
}
int func_213(int iParam0)
{
if (func_157(uParam0, unk_0x7D2B9E6A64637269(), 6f, 1))
{
if (!unk_0xC49311A2A500FF09(uParam0, 0))
{
if (unk_0x83B12E293561B796(iParam0, unk_0x7D2B9E6A64637269()))
{
return 1;
}
}
}
return 0;
}
void func_214()
{
if (func_37(Local_868))
{
if (func_157(unk_0x7D2B9E6A64637269(), Local_868, 100f, 1) && !iLocal_837)
{
unk_0x4DF8E7F8D8FB143A(joaat("trash"), 3);
if (!unk_0x0F4C16D9EAAF22F9(joaat("trash")))
{
iLocal_837 = 1;
}
}
else if (!func_157(unk_0x7D2B9E6A64637269(), Local_868, 120f, 1) && iLocal_837)
{
unk_0xC39EE54ACC066848(joaat("trash"));
iLocal_837 = 0;
}
}
}
void func_215(int iParam0, var uParam1, int iParam2, int iParam3, int iParam4, struct<3> Param5, int iParam8, bool bParam9, int iParam10)
{
if (func_37(*iParam0))
{
switch (*iParam2)
{
case 0:
if (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), *iParam0, 0))
{
func_7(iParam3);
if (func_106(func_114(func_77()), 0, 0))
{
unk_0xAA18C87A1A6C1FAE(func_114(func_77()));
}
if (*iParam0 == iParam8)
{
*iParam2 = 1;
}
else
{
*iParam2 = 2;
}
}
else if (func_220(*iParam0) || func_219(*iParam0))
{
func_7(iParam3);
if (func_106(func_114(func_77()), 0, 0))
{
unk_0xAA18C87A1A6C1FAE(func_114(func_77()));
}
*iParam2 = 3;
}
else
{
if (func_106(func_115(func_77(), bParam9), 0, 0))
{
unk_0xAA18C87A1A6C1FAE(func_115(func_77(), bParam9));
}
if (func_77() != 33)
{
func_217(iParam0);
}
else
{
func_216(iParam0, uParam1);
}
}
break;
case 2:
case 1:
if ((!unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), *iParam0, 0) && !func_220(*iParam0)) && !func_219(*iParam0))
{
func_7(iParam4);
if (!unk_0x591190E69BE43117(*iParam0, Param5, iParam10, iParam10, 2f, 0, 1, 2))
{
func_125(iParam3, *iParam0, 1);
}
*iParam2 = 0;
}
break;
case 3:
if (!func_220(*iParam0) && !func_219(*iParam0))
{
func_7(iParam4);
if (!unk_0x591190E69BE43117(*iParam0, Param5, iParam10, iParam10, 2f, 0, 1, 2))
{
func_125(iParam3, *iParam0, 1);
}
*iParam2 = 0;
}
break;
}
}
else if (func_77() != 33)
{
func_217(iParam0);
}
else
{
func_216(iParam0, uParam1);
}
}
void func_216(var uParam0, var uParam1)
{
int iVar0;
int iVar1;
var uVar2;
if (!bLocal_28)
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
iVar0 = unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0);
if (iVar0 != *uParam0)
{
if (func_37(iVar0))
{
iVar1 = unk_0x6471F4759775FCA4(iVar0);
if (iVar1 == joaat("trash"))
{
*uParam1 = *uParam0;
func_6(uParam0);
*uParam0 = iVar0;
func_36(*uParam0, 1);
func_36(*uParam1, 3);
if (!unk_0xEE1D92A39CF8E1E6(*uParam0))
{
unk_0x4985CD0720AFD468(*uParam0, 1, 1);
}
}
else if (iVar1 == joaat("towtruck"))
{
uVar2 = unk_0x05029439A5245679(unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0));
if (func_10(uVar2))
{
iVar0 = unk_0x611CD1312FD3CA66(uVar2);
if (unk_0x6471F4759775FCA4(iVar0) == joaat("trash"))
{
*uParam1 = *uParam0;
func_6(uParam0);
*uParam0 = iVar0;
func_36(*uParam0, 1);
func_36(*uParam1, 3);
if (!unk_0xEE1D92A39CF8E1E6(*uParam0))
{
unk_0x4985CD0720AFD468(*uParam0, 1, 1);
}
}
}
}
}
}
}
}
}
void func_217(var uParam0)
{
int iVar0;
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
iVar0 = unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0);
if (iVar0 != *uParam0)
{
if (func_37(iVar0))
{
if (unk_0x6471F4759775FCA4(iVar0) == func_218(func_77()))
{
func_6(uParam0);
*uParam0 = iVar0;
func_36(*uParam0, 1);
unk_0x4985CD0720AFD468(*uParam0, 1, 1);
}
}
}
}
}
int func_218(int iParam0)
{
int iVar0;
switch (iParam0)
{
case 33:
iVar0 = joaat("trash");
break;
case 34:
iVar0 = joaat("towtruck");
break;
case 78:
iVar0 = 0;
break;
case 80:
case 81:
case 82:
iVar0 = joaat("gauntlet");
break;
}
return iVar0;
}
int func_219(int iParam0)
{
int iVar0;
int iVar1;
if ((func_341(unk_0x7D2B9E6A64637269()) && unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0)) && func_37(iParam0))
{
iVar0 = unk_0x0BF0F8F3AD0993F6();
if (func_37(iVar0))
{
iVar1 = unk_0x6471F4759775FCA4(iVar0);
if ((iVar1 == joaat("cargobob") || iVar1 == joaat("cargobob2")) || iVar1 == joaat("cargobob3"))
{
if (unk_0xAF76DC34F0718838(iVar0))
{
if (unk_0x64A9C45E797F804E(iVar0, iParam0))
{
return 1;
}
}
}
}
}
return 0;
}
int func_220(int iParam0)
{
int iVar0;
int iVar1;
if ((func_341(unk_0x7D2B9E6A64637269()) && unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0)) && func_37(iParam0))
{
iVar0 = unk_0x0BF0F8F3AD0993F6();
if (func_37(iVar0))
{
iVar1 = unk_0x6471F4759775FCA4(iVar0);
if (iVar1 == joaat("towtruck") || iVar1 == joaat("towtruck2"))
{
if (unk_0xF2C5E5F021DB1E93(iVar0, iParam0))
{
return 1;
}
}
}
}
return 0;
}
void func_221()
{
func_215(&iLocal_874, &uLocal_875, &iLocal_686, &iLocal_822, &iLocal_821, Local_827, Local_868, 0, 1090519040);
func_155();
func_238();
func_214();
switch (iLocal_684)
{
case 0:
if (func_122(iLocal_683, bLocal_28))
{
if (unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) == 0 && !func_237())
{
func_117(&iLocal_821, Local_827, 1);
func_121("PRA_TAKBACK", &iLocal_820);
}
iLocal_684 = 1;
}
break;
case 1:
func_120(&iLocal_821, Local_827, &iLocal_685, iLocal_686, &iLocal_820, &iLocal_838);
func_227();
if (func_225(iLocal_874, Local_827, &iLocal_821, iLocal_685, iLocal_686, &iLocal_820, &iLocal_839, 0, 0, 1086324736))
{
unk_0x2DC2890038BFF758(8f, 5f, 4);
iLocal_684 = 2;
}
break;
case 2:
func_222();
func_7(&iLocal_821);
func_7(&iLocal_822);
if (func_116(1077936128, 1))
{
func_110(0);
}
break;
case 3:
if (func_37(iLocal_874))
{
if (!unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), iLocal_874, 0))
{
unk_0xB1D85A6C23F2F945(unk_0x7D2B9E6A64637269(), iLocal_874, -1);
}
else
{
func_109(iLocal_874, Local_827, 146.5443f, 0, 1);
func_40(1, 1, 1);
iLocal_684 = 1;
}
}
break;
}
}
void func_222()
{
int iVar0;
int iVar1;
iVar0 = 0;
while (iVar0 < 3)
{
iVar1 = func_79(iVar0);
if (!unk_0xECEC7528A52B4EE8(iVar1))
{
if (func_224(iVar1))
{
func_223(iVar1);
}
}
iVar0++;
}
}
int func_223(int iParam0)
{
int iVar0;
return 0;
if (!unk_0xECEC7528A52B4EE8(iParam0))
{
iVar0 = func_29(iParam0);
if (iVar0 > 3)
{
return 0;
}
if (func_79(iVar0) != iParam0)
{
return 0;
}
if (!unk_0x234B68AC2E35ED5A(Global_95224, iVar0))
{
return 0;
}
unk_0xC664C0067EEAB8D1(&Global_95224, iVar0);
return 1;
}
return 0;
}
int func_224(int iParam0)
{
int iVar0;
return 0;
if (!unk_0xECEC7528A52B4EE8(iParam0))
{
iVar0 = func_29(iParam0);
if (iVar0 > 3)
{
return 0;
}
if (func_79(iVar0) != iParam0)
{
return 0;
}
if (unk_0x234B68AC2E35ED5A(Global_95224, iVar0))
{
return 1;
}
}
return 0;
}
int func_225(int iParam0, struct<3> Param1, int iParam4, int iParam5, int iParam6, int iParam7, int iParam8, bool bParam9, bool bParam10, float fParam11)
{
if ((iParam6 == 1 || iParam6 == 2) || iParam6 == 3)
{
if (iParam5 == 0)
{
func_117(iParam4, Param1, 1);
if (!bParam10)
{
if (func_37(iParam0))
{
if (unk_0x591190E69BE43117(iParam0, Param1, fParam11, fParam11, 2f, 1, 1, 0))
{
return 1;
}
}
}
else if (unk_0x591190E69BE43117(unk_0x7D2B9E6A64637269(), Param1, fParam11, fParam11, 2f, 1, 1, 2))
{
return 1;
}
if (func_106(func_114(func_77()), 0, 0))
{
unk_0xAA18C87A1A6C1FAE(func_114(func_77()));
}
if (!func_226())
{
func_121(func_115(func_77(), bParam9), iParam7);
}
}
}
else if (iParam5 == 0)
{
if (!*iParam8)
{
if (func_106(func_115(func_77(), 0), 0, 0))
{
unk_0xAA18C87A1A6C1FAE(func_115(func_77(), 0));
}
func_105(func_114(func_77()), 7500, 0);
*iParam8 = 1;
}
}
return 0;
}
bool func_226()
{
return Global_99422.f_363 > 0;
}
void func_227()
{
int iVar0;
bool bVar1;
int iVar2;
bVar1 = false;
iVar0 = 0;
while (iVar0 < 3)
{
iVar2 = func_79(iVar0);
if (!unk_0xECEC7528A52B4EE8(iVar2))
{
if (func_78(iVar2, 0))
{
if (!bVar1)
{
if (func_157(unk_0x7D2B9E6A64637269(), iVar2, 5f, 1))
{
if (!func_237())
{
func_232(iVar0);
bVar1 = true;
}
}
}
if (!iLocal_1048[iVar0])
{
if (iVar0 == 0)
{
func_98(&uLocal_879, iVar0, iVar2, "MICHAEL", 0, 1);
}
else if (iVar0 == 1)
{
func_98(&uLocal_879, iVar0, iVar2, "FRANKLIN", 0, 1);
}
else if (iVar0 == 2)
{
func_98(&uLocal_879, iVar0, iVar2, "TREVOR", 0, 1);
}
iLocal_1048[iVar0] = 1;
}
}
if (!func_224(iVar2))
{
if (func_78(iVar2, 0))
{
if (func_231(iVar2) || func_229(iVar2))
{
if (func_228(iVar2, 0))
{
unk_0x4985CD0720AFD468(iVar2, 1, 1);
unk_0xBE91B077ADADE97F(iVar2, true);
unk_0xCA089CD1A17D76DF(iVar2);
}
}
}
}
else if (unk_0x9984C023D4E57C2E(iVar2, 1))
{
if (func_231(iVar2))
{
if (unk_0x4E8DA737B686529A(iVar2, -1273030092) != 1 && unk_0x4E8DA737B686529A(iVar2, -1273030092) != 0)
{
if (unk_0xA1CB00B61C47B900(623.3781f, -172.26f, 1700.732f, -2115.843f))
{
unk_0xE946751408DFA71B(iVar2, unk_0x75B58B38E45C6F9A(iVar2, 0), Local_827, 20f, 0, 0, 34340901, 2f, 10f);
}
else
{
unk_0xABAA7F8FD10DCDF2(623.3781f, -172.26f, 1700.732f, -2115.843f);
}
}
}
else if (func_229(iVar2))
{
if (func_37(Local_868))
{
if (!func_157(iVar2, Local_868, 17f, 1))
{
if (unk_0x4E8DA737B686529A(iVar2, -1273030092) != 1 && unk_0x4E8DA737B686529A(iVar2, -1273030092) != 0)
{
unk_0x7B5530AB21BFC748(iVar2, unk_0x75B58B38E45C6F9A(iVar2, 0), Local_868, 3, 20f, 786468, 2f, 0.5f, 1);
}
}
}
}
else
{
func_223(iVar2);
}
}
}
iVar0++;
}
}
int func_228(int iParam0, int iParam1)
{
int iVar0;
return 0;
if (!unk_0xECEC7528A52B4EE8(iParam0))
{
iVar0 = func_29(iParam0);
if (iVar0 > 3)
{
return 0;
}
if (func_79(iVar0) != iParam0)
{
return 0;
}
if (unk_0x234B68AC2E35ED5A(Global_95224, iVar0))
{
return 0;
}
if (iParam1 == 0)
{
if (iParam0 == unk_0x7D2B9E6A64637269())
{
return 0;
}
}
if (unk_0x234B68AC2E35ED5A(Global_95223, iVar0))
{
unk_0x20FB50DE4E866E5F(iParam0, 0, 0);
unk_0x46EDFC827DC67D89(iParam0, 0, 1);
unk_0x191DDA30577F440A(&Global_95224, iVar0);
return 1;
}
}
return 0;
}
int func_229(int iParam0)
{
int iVar0;
if (!func_230())
{
if ((!unk_0xECEC7528A52B4EE8(unk_0x7D2B9E6A64637269()) && unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0)) && unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) == 0)
{
iVar0 = unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0);
if (func_37(iVar0))
{
if (unk_0xEACFC87E44438F24(iVar0, joaat("trash")))
{
return 0;
}
if (unk_0xF41EB7643E61A928(iParam0, iVar0, 0) && unk_0x27FC1B0077581B37(iVar0, -1, 0) == iParam0)
{
return 1;
}
}
}
}
return 0;
}
int func_230()
{
if (!unk_0x02BFF15CAA701972())
{
return Global_96848.f_44 == 1;
}
return 0;
}
int func_231(int iParam0)
{
if (!func_230())
{
if ((unk_0x419E13582192CFEA(Local_868) && unk_0xBFCE58B2B3249999(Local_868, 0)) && !unk_0x591190E69BE43117(Local_868, Local_827, 2f, 2f, 2f, 0, 1, 0))
{
if ((!unk_0xECEC7528A52B4EE8(unk_0x7D2B9E6A64637269()) && unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), Local_868, 0)) && unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) == 0)
{
if (unk_0xF41EB7643E61A928(iParam0, Local_868, 0) && unk_0x27FC1B0077581B37(Local_868, -1, 0) == iParam0)
{
return 1;
}
}
}
}
return 0;
}
void func_232(int iParam0)
{
if (iLocal_683 > 1)
{
if (iLocal_685 > 0)
{
if (!unk_0x234B68AC2E35ED5A(Local_688[iParam0 /*8*/].f_7, 0) && iLocal_686 == 1)
{
if (!unk_0x123480158F10FA67())
{
if (func_236(&uLocal_879, cLocal_878, Local_688[iParam0 /*8*/][0], 8, 0, 0, 0))
{
unk_0x191DDA30577F440A(&(Local_688[iParam0 /*8*/].f_7), 0);
}
}
}
}
else
{
if ((unk_0x234B68AC2E35ED5A(Local_688[iParam0 /*8*/].f_7, 0) && !unk_0x234B68AC2E35ED5A(Local_688[iParam0 /*8*/].f_7, 1)) && iLocal_686 == 1)
{
if (!unk_0x123480158F10FA67())
{
if (func_236(&uLocal_879, cLocal_878, Local_688[iParam0 /*8*/][1], 7, 0, 0, 0))
{
unk_0x191DDA30577F440A(&(Local_688[iParam0 /*8*/].f_7), 1);
}
}
}
if (!unk_0x234B68AC2E35ED5A(Local_688[iParam0 /*8*/].f_7, 5))
{
if (func_235(iLocal_874, Local_827, 1) < 15f && iLocal_686 == 1)
{
if (!unk_0x123480158F10FA67())
{
if (func_236(&uLocal_879, cLocal_878, Local_688[iParam0 /*8*/][5], 7, 0, 0, 0))
{
unk_0x191DDA30577F440A(&(Local_688[iParam0 /*8*/].f_7), 5);
}
}
}
}
switch (func_29(unk_0x7D2B9E6A64637269()))
{
case 0:
if (iParam0 == 1)
{
if (!func_234(2))
{
func_233(iParam0, 2);
}
}
else if (iParam0 == 2)
{
if (!func_234(4))
{
func_233(iParam0, 4);
}
}
break;
case 1:
if (iParam0 == 0)
{
if (!func_234(2))
{
func_233(iParam0, 2);
}
}
else if (iParam0 == 2)
{
if (!func_234(3))
{
func_233(iParam0, 3);
}
}
break;
case 2:
if (iParam0 == 1)
{
if (!func_234(3))
{
func_233(iParam0, 3);
}
}
else if (iParam0 == 0)
{
if (!func_234(4))
{
func_233(iParam0, 4);
}
}
break;
}
}
}
}
void func_233(int iParam0, int iParam1)
{
if (!unk_0x234B68AC2E35ED5A(Local_688[iParam0 /*8*/].f_7, iParam1))
{
if (iLocal_1052 != -1)
{
if (!unk_0x123480158F10FA67())
{
if (func_236(&uLocal_879, cLocal_878, Local_688[iParam0 /*8*/][iParam1], 7, 0, 0, 0))
{
unk_0x191DDA30577F440A(&(Local_688[iParam0 /*8*/].f_7), iParam1);
}
}
}
else if (!func_237() && !unk_0x123480158F10FA67())
{
iLocal_1052 = unk_0xDFB7BFA6482FEE1E();
}
else
{
iLocal_1052 = -1;
}
}
}
int func_234(int iParam0)
{
if ((unk_0x234B68AC2E35ED5A(Local_688[0 /*8*/].f_7, iParam0) || unk_0x234B68AC2E35ED5A(Local_688[1 /*8*/].f_7, iParam0)) || unk_0x234B68AC2E35ED5A(Local_688[2 /*8*/].f_7, iParam0))
{
return 1;
}
return 0;
}
float func_235(int iParam0, struct<3> Param1, int iParam4)
{
struct<3> Var0;
if (!unk_0xE50EB54E0F21BED0(iParam0, 0))
{
Var0 = { unk_0xD6E677FAD7521410(iParam0, 1) };
}
else
{
Var0 = { unk_0xD6E677FAD7521410(iParam0, 0) };
}
return unk_0x0BABEFEA577FCFA4(Var0, Param1, iParam4);
}
bool func_236(var uParam0, char* sParam1, char* sParam2, int iParam3, int iParam4, int iParam5, int iParam6)
{
func_95(uParam0, 145, sParam1, iParam4, iParam5, iParam6);
if (iParam3 > 7)
{
if (iParam3 < 12)
{
iParam3 = 7;
}
}
Global_21132 = 0;
Global_21134 = 0;
Global_21139 = 0;
Global_22116 = 0;
Global_22118 = 0;
Global_22122 = 0;
Global_2621441 = 0;
return func_83(sParam2, iParam3, 0);
}
int func_237()
{
if (Global_21125 != 0 || unk_0x6C2F471E0CF8D4CF())
{
return 1;
}
return 0;
}
void func_238()
{
if (func_107(unk_0x7D2B9E6A64637269(), Local_827, 220f))
{
if (!iLocal_877 && !func_107(unk_0x7D2B9E6A64637269(), Local_827, 100f))
{
iLocal_877 = func_153(&uLocal_876, joaat("cavalcade2"), 1370.912f, -2060.055f, 50.9983f, 312.8686f, 1);
}
}
else if (func_107(unk_0x7D2B9E6A64637269(), Local_827, 240f))
{
if (iLocal_877)
{
func_6(&uLocal_876);
iLocal_877 = 0;
}
}
}
void func_239()
{
func_215(&iLocal_874, &uLocal_875, &iLocal_686, &iLocal_822, &iLocal_821, Local_827, Local_868, 0, 1090519040);
func_214();
func_155();
switch (iLocal_684)
{
case 0:
if (func_122(iLocal_683, bLocal_28))
{
func_125(&iLocal_821, Local_868, 1);
func_121("PRA_GOVAN", &iLocal_820);
iLocal_684 = 1;
}
break;
case 1:
func_227();
if (func_37(Local_868))
{
func_242(&uLocal_671, Local_868, 0, 0, 1, 1, 1);
}
if (!bLocal_833)
{
if (func_341(Local_840) && unk_0xECA23EB9C2A5E83F(Local_840))
{
func_241();
}
if (func_341(Local_854) && unk_0xECA23EB9C2A5E83F(Local_854))
{
func_241();
}
}
if (func_37(iLocal_874))
{
if ((iLocal_686 == 1 || iLocal_686 == 2) || iLocal_686 == 3)
{
unk_0x2DC2890038BFF758(5f, 5f, 4);
iLocal_684 = 2;
}
}
break;
case 2:
func_7(&iLocal_821);
func_145(&uLocal_671, 0, 0);
func_110(0);
break;
case 3:
func_8(&Local_840);
func_8(&Local_854);
if (func_37(Local_868))
{
unk_0xB1D85A6C23F2F945(unk_0x7D2B9E6A64637269(), Local_868, -1);
}
func_240(1);
func_40(1, 1, 1);
iLocal_684 = 1;
break;
}
}
void func_240(bool bParam0)
{
unk_0xE63D792F88BFF242(1, bParam0);
unk_0xE63D792F88BFF242(2, bParam0);
unk_0xE63D792F88BFF242(3, bParam0);
unk_0xE63D792F88BFF242(4, bParam0);
unk_0xE63D792F88BFF242(5, bParam0);
if (bParam0)
{
unk_0x5E84945E26CAEF1F(1f);
unk_0x20D884FB6567BAD5(5);
}
else
{
unk_0x20D884FB6567BAD5(0);
unk_0x5E84945E26CAEF1F(0f);
}
}
void func_241()
{
char* sVar0;
switch (func_25())
{
case 0:
sVar0 = "FBI4_JACKSM";
break;
case 1:
sVar0 = "FBI4_JACKSF";
break;
case 2:
sVar0 = "FBI4_JACKST";
break;
}
bLocal_833 = func_236(&uLocal_879, "FBIPRAU", sVar0, 7, 0, 0, 0);
if (bLocal_833)
{
unk_0x2DC2890038BFF758(8f, 8f, 4);
}
}
void func_242(var uParam0, int iParam1, char* sParam2, int iParam3, bool bParam4, int iParam5, bool bParam6)
{
func_243(uParam0, iParam1, 0f, 0f, 0f, sParam2, iParam3, bParam4, iParam5, bParam6);
}
void func_243(var uParam0, int iParam1, struct<3> Param2, char* sParam5, int iParam6, bool bParam7, var uParam8, bool bParam9)
{
func_244(uParam0, iParam1, Param2, sParam5, iParam6, bParam7, uParam8, bParam9);
}
void func_244(var uParam0, int iParam1, struct<3> Param2, char* sParam5, int iParam6, bool bParam7, var uParam8, bool bParam9)
{
if (!unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1))
{
func_145(uParam0, 0, 0);
}
uParam0->f_6 = 2;
func_245(uParam0, iParam1, Param2, sParam5, iParam6, bParam7, uParam8, bParam9);
}
void func_245(var uParam0, int iParam1, struct<3> Param2, char* sParam5, int iParam6, bool bParam7, var uParam8, bool bParam9)
{
int iVar0;
int iVar1;
if (uParam0->f_1 && unk_0x79CC60D128756F16())
{
if (unk_0xDFB7BFA6482FEE1E() >= (uParam0->f_8 + uParam0->f_9))
{
uParam0->f_1 = 0;
}
}
iVar0 = sParam5;
if (unk_0x4030103C8B148AFC(iVar0))
{
if (!unk_0x02BFF15CAA701972())
{
iVar0 = "CMN_HINT";
}
else
{
iVar0 = "FM_IHELP_HNT";
}
}
if (func_146(iVar0))
{
func_269();
}
if (func_268(iParam1) && unk_0x1F9D47D45E125FA6(iParam1))
{
iVar1 = 0;
if (unk_0xA2CCAAC7F5CA3F49(iParam1))
{
unk_0xE10AFFAFED85BE48(unk_0xFAA5505029C4B5A6(iParam1));
unk_0xED9E2F10D8093C4B(unk_0xFAA5505029C4B5A6(iParam1), 1);
if (unk_0x906F86AA0011D5F8(unk_0xFAA5505029C4B5A6(iParam1)))
{
iVar1 = 1;
}
}
else if (unk_0x55F5BD4ABD80B211(iParam1))
{
unk_0x8CA9CB0F4A5018B4(unk_0x611CD1312FD3CA66(iParam1));
if (unk_0x6626CA37A88F93B9(unk_0x611CD1312FD3CA66(iParam1)))
{
iVar1 = 1;
}
}
else if (unk_0x50997FC21D62251F(iParam1))
{
unk_0xC61A3EA05D996D93(unk_0x6F9D3E582271B7F5(iParam1));
if (unk_0x88F676C35100CFCA(unk_0x6F9D3E582271B7F5(iParam1)))
{
iVar1 = 1;
}
}
if (!unk_0x79CC60D128756F16())
{
if (func_263(uParam0, bParam7, bParam9, 0))
{
func_260(uParam0, iParam1, Param2, iParam6);
}
if (*uParam0)
{
*uParam0 = 0;
}
else if (uParam0->f_6 == 2)
{
if (func_250(iVar0))
{
if ((unk_0x4030103C8B148AFC(uParam0->f_3) && !unk_0x4030103C8B148AFC(iVar0)) && unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if ((iVar1 && !unk_0xE8FFE38E2BA32BD6()) && uParam8)
{
if (!func_146(iVar0))
{
func_249(iVar0, -1);
uParam0->f_3 = iVar0;
if (unk_0xDA654EB115F9FF7D("CMN_HINT", iVar0))
{
func_248(1);
}
}
}
}
}
}
else if (func_250(iVar0))
{
if (unk_0x4030103C8B148AFC(uParam0->f_3) && !unk_0x4030103C8B148AFC(iVar0))
{
if (((unk_0xB4E725A8915BDF60(iParam1) && iVar1) && !unk_0xE8FFE38E2BA32BD6()) && uParam8)
{
if (!func_146(iVar0))
{
func_249(iVar0, -1);
uParam0->f_3 = iVar0;
if (unk_0xDA654EB115F9FF7D("CMN_HINT", iVar0))
{
func_248(1);
}
}
}
}
}
}
else
{
if (!unk_0x4030103C8B148AFC(sParam5))
{
if (func_146(sParam5))
{
unk_0x66AE54CE92457FEE(1);
}
}
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1))
{
if (unk_0xDD3EBE641B253A60(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(3) == 3 || unk_0x5F95E51ABC3FC59A(3) == 4)
{
func_145(uParam0, iVar0, 1);
}
}
else if (unk_0xD1A2328AC17D6F4C(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(6) == 3 || unk_0x5F95E51ABC3FC59A(6) == 4)
{
func_145(uParam0, iVar0, 1);
}
}
else if (unk_0x8599CD37AE5778BB(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(4) == 3 || unk_0x5F95E51ABC3FC59A(4) == 4)
{
func_145(uParam0, iVar0, 1);
}
}
else if (unk_0x44FBC864916E75D4(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(5) == 3 || unk_0x5F95E51ABC3FC59A(5) == 4)
{
func_145(uParam0, iVar0, 1);
}
}
else if (unk_0x57605ED0D405D759(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(2) == 3 || unk_0x5F95E51ABC3FC59A(2) == 4)
{
func_145(uParam0, iVar0, 1);
}
}
else if (unk_0x84BDC1D2DDA37898() == 3 || unk_0x84BDC1D2DDA37898() == 4)
{
func_145(uParam0, iVar0, 1);
}
}
if (!func_263(uParam0, bParam7, bParam9, 0))
{
if ((!*uParam0 && !uParam0->f_1) && !func_247(uParam0))
{
func_246(uParam0);
}
}
}
}
else
{
func_145(uParam0, iVar0, 0);
}
}
void func_246(var uParam0)
{
if (func_268(unk_0x7D2B9E6A64637269()))
{
unk_0x880C7B361C9651EE(unk_0x7D2B9E6A64637269());
}
if (unk_0x79CC60D128756F16())
{
unk_0xD6ABECE3CBB224B0(1);
unk_0xD20D31BC4E3A72D3(0);
unk_0xC0BBE340BE2AA02D("HINT_CAM_SCENE");
unk_0xBAF2F13FE4D19AA9("FocusIn");
if (uParam0->f_11)
{
unk_0x9673FB069F90F6B9("FocusOut", 0, 0);
unk_0x9B0169E27978C1A2(-1, "FocusOut", "HintCamSounds", 1);
uParam0->f_11 = 0;
}
}
uParam0->f_2 = -1;
*uParam0 = 1;
}
int func_247(var uParam0)
{
int iVar0;
if (uParam0->f_2 > 0)
{
iVar0 = (uParam0->f_10 / 2);
if (uParam0->f_2 + iVar0) > unk_0xDFB7BFA6482FEE1E()
{
return 1;
}
}
return 0;
}
int func_248(bool bParam0)
{
switch (Global_42009)
{
case 0:
case 3:
if (bParam0)
{
Global_112293.f_10047.f_100++;
}
return Global_112293.f_10047.f_100;
break;
case 4:
if (bParam0)
{
Global_112293.f_10047.f_101++;
}
return Global_112293.f_10047.f_101;
break;
case 5:
case 15:
if (bParam0)
{
Global_112293.f_10047.f_102++;
}
return Global_112293.f_10047.f_102;
break;
default:
break;
}
return 3;
}
void func_249(char* sParam0, int iParam1)
{
unk_0xDDEC6D09154BA73A(sParam0);
unk_0x4A5DC2FF6E0B609F(0, 0, 1, iParam1);
}
int func_250(char* sParam0)
{
if (!func_251(1, 1, 0))
{
if ((!unk_0xAB6A270F84A8781E(sParam0) && func_146(sParam0)) || func_146("CMN_HINT"))
{
unk_0x66AE54CE92457FEE(1);
}
return 0;
}
switch (Global_42009)
{
case 0:
case 3:
if (func_248(0) < 3)
{
return 1;
}
break;
case 4:
if (func_248(0) < 1)
{
return 1;
}
break;
case 5:
case 15:
if (func_248(0) < 1)
{
return 1;
}
break;
default:
break;
}
return 0;
}
int func_251(bool bParam0, bool bParam1, bool bParam2)
{
int iVar0;
int iVar1;
if (bParam0)
{
if (!unk_0xDF02DA324F934755(unk_0x1146A9AE09CE2B14()))
{
return 0;
}
}
if (bParam2)
{
return 1;
}
if (unk_0xF471787D45ADC2C1())
{
return 0;
}
if (func_69(0))
{
return 0;
}
if (func_259())
{
return 0;
}
if (unk_0xFEABE4F1525A0A08())
{
return 0;
}
if (Global_74428)
{
return 0;
}
if (unk_0x636F1F53CC61D2C9(joaat("appinternet")) > 0)
{
return 0;
}
if (Global_59279)
{
return 0;
}
if (bParam1)
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1))
{
if (unk_0xDD3EBE641B253A60(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(3) == 3 || unk_0x5F95E51ABC3FC59A(3) == 4)
{
return 0;
}
}
else if (unk_0xD1A2328AC17D6F4C(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(6) == 3 || unk_0x5F95E51ABC3FC59A(6) == 4)
{
return 0;
}
}
else if (unk_0x8599CD37AE5778BB(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(4) == 3 || unk_0x5F95E51ABC3FC59A(4) == 4)
{
return 0;
}
}
else if (unk_0x44FBC864916E75D4(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(5) == 3 || unk_0x5F95E51ABC3FC59A(5) == 4)
{
return 0;
}
}
else if (unk_0x57605ED0D405D759(unk_0x7D2B9E6A64637269()))
{
if (unk_0x5F95E51ABC3FC59A(2) == 3 || unk_0x5F95E51ABC3FC59A(2) == 4)
{
return 0;
}
}
else if (unk_0x84BDC1D2DDA37898() == 3 || unk_0x84BDC1D2DDA37898() == 4)
{
return 0;
}
if (unk_0x7F827BDD9A88B58D())
{
return 0;
}
}
}
if ((func_258() || func_257(Global_4456448.f_133963)) || func_256())
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
iVar0 = unk_0x75B58B38E45C6F9A(unk_0x7D2B9E6A64637269(), 0);
iVar1 = func_255(unk_0x7D2B9E6A64637269(), 0);
if (((unk_0xCA5702B560C1A812(iVar0, iVar1) || (unk_0x6471F4759775FCA4(iVar0) == joaat("apc") && iVar1 != -1)) || (unk_0x6471F4759775FCA4(iVar0) == joaat("akula") && iVar1 != -1)) || (((unk_0x6471F4759775FCA4(iVar0) == joaat("riot2") && iVar1 == 0) && func_254(iVar0, 10)) && unk_0xB51972B58BF40F96(iVar0, 10) != -1))
{
return 0;
}
}
}
if (Global_1694746)
{
return 0;
}
if (func_252(unk_0x1146A9AE09CE2B14()))
{
return 0;
}
return 1;
}
int func_252(int iParam0)
{
if (iParam0 != func_88())
{
if (func_253(iParam0, 1, 1))
{
return Global_2426865[iParam0 /*449*/].f_319.f_6 != -1;
}
else if ((Global_1312902 && iParam0 == unk_0x1146A9AE09CE2B14()) && func_253(iParam0, 1, 0))
{
return Global_2426865[iParam0 /*449*/].f_319.f_6 != -1;
}
}
return 0;
}
int func_253(int iParam0, bool bParam1, bool bParam2)
{
int iVar0;
iVar0 = iParam0;
if (iVar0 != -1)
{
if (unk_0x8CFC2F41A749E236(iParam0))
{
if (bParam1)
{
if (!unk_0xCAD1755E530A6012(iParam0))
{
return 0;
}
}
if (bParam2)
{
if (!Global_2441237.f_3[iVar0])
{
return 0;
}
}
return 1;
}
}
return 0;
}
int func_254(int iParam0, int iParam1)
{
if (unk_0xBFCE58B2B3249999(iParam0, 0))
{
if (unk_0xCF1FE5DEA3E2E135(iParam0) > 0)
{
switch (iParam1)
{
case 17:
case 18:
case 19:
case 20:
case 21:
case 22:
return 1;
break;
default:
if (unk_0x622E46C9F30FB60D(iParam0, iParam1) > 0)
{
return 1;
}
break;
}
}
}
return 0;
}
int func_255(int iParam0, int iParam1)
{
int iVar0;
int iVar1;
int iVar2;
int iVar3;
if (!unk_0xECEC7528A52B4EE8(iParam0))
{
if (unk_0xC49311A2A500FF09(iParam0, iParam1))
{
iVar0 = unk_0x75B58B38E45C6F9A(iParam0, iParam1);
if (unk_0x419E13582192CFEA(iVar0))
{
iVar1 = unk_0xEF6894DFD91DE23D(unk_0x6471F4759775FCA4(iVar0));
if (iVar1 == 1)
{
iVar3 = -1;
return iVar3;
}
iVar2 = 0;
while (iVar2 < iVar1)
{
iVar3 = (iVar2 - 1);
if (!unk_0x9B73EB6255D4AE81(iVar0, iVar3, 0))
{
if (unk_0x27FC1B0077581B37(iVar0, iVar3, 0) == iParam0)
{
return iVar3;
}
}
iVar2++;
}
}
}
}
return iVar3;
}
var func_256()
{
return Global_2453009.f_19;
}
bool func_257(int iParam0)
{
return iParam0 == 51;
}
var func_258()
{
return Global_2453009.f_18;
}
bool func_259()
{
return unk_0xDFB7BFA6482FEE1E() <= Global_22670.f_6135 + 100;
}
void func_260(var uParam0, int iParam1, struct<3> Param2, int iParam5)
{
int iVar0;
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (Global_1319203 == 1)
{
return;
}
if (unk_0xE50EB54E0F21BED0(iParam1, 0))
{
func_145(uParam0, 0, 0);
}
if (func_15(Param2, 0f, 0f, 0f, 0))
{
if (unk_0xA2CCAAC7F5CA3F49(iParam1))
{
iVar0 = unk_0xFAA5505029C4B5A6(iParam1);
if (!unk_0xC49311A2A500FF09(iVar0, 0))
{
if (unk_0x72D30262CF8C8603(iVar0))
{
if (!func_261())
{
Param2 = { 0f, 0f, 1f };
}
}
else if (unk_0x9B9082138A642C14(iVar0))
{
Param2 = { 0f, 0f, 1f };
}
}
}
}
unk_0xD6ABECE3CBB224B0(0);
iVar1 = uParam0->f_9;
iVar2 = uParam0->f_10;
if (iParam5 == 1726668277)
{
if (iVar1 < 1500)
{
iVar1 = 1500;
}
if (iVar2 < 1500)
{
iVar2 = 1500;
}
}
unk_0x48A41E0B6D206A79(iParam1, Param2, 1, -1, iVar1, iVar2, iParam5);
iVar3 = 2048;
iVar4 = 3;
unk_0x8ADA462BC5F42FD8(unk_0x7D2B9E6A64637269(), iParam1, -1, iVar3, iVar4);
unk_0x9673FB069F90F6B9("FocusIn", 0, 0);
unk_0xB84B43B766630B5C("HINT_CAM_SCENE");
unk_0x9B0169E27978C1A2(-1, "FocusIn", "HintCamSounds", 1);
uParam0->f_11 = 1;
uParam0->f_8 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_1 = 1;
*uParam0 = 0;
}
bool func_261()
{
return func_262(unk_0x1146A9AE09CE2B14());
}
int func_262(int iParam0)
{
if (unk_0x6471F4759775FCA4(unk_0xD56332194D622ECE(iParam0)) == joaat("mp_f_freemode_01"))
{
return 1;
}
return 0;
}
int func_263(var uParam0, bool bParam1, bool bParam2, bool bParam3)
{
if (uParam0->f_1)
{
if (unk_0xDFB7BFA6482FEE1E() >= (uParam0->f_8 + uParam0->f_9))
{
uParam0->f_1 = 0;
}
}
switch (uParam0->f_5)
{
case 0:
uParam0->f_7 = 0;
if (uParam0->f_6 == 0)
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1))
{
if (func_267(bParam1, bParam2, bParam3))
{
uParam0->f_4 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 1;
uParam0->f_7 = 1;
}
}
else if (func_266(bParam1, bParam2, bParam3))
{
uParam0->f_4 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 1;
uParam0->f_7 = 1;
}
}
else if (uParam0->f_6 == 1)
{
if (func_266(bParam1, bParam2, bParam3))
{
uParam0->f_4 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 1;
uParam0->f_7 = 1;
}
}
else if (uParam0->f_6 == 2)
{
if (func_267(bParam1, bParam2, bParam3))
{
uParam0->f_4 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 1;
uParam0->f_7 = 1;
}
}
if (func_247(uParam0))
{
uParam0->f_7 = 1;
uParam0->f_5 = 4;
}
break;
case 1:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_4) <= 500)
{
if (uParam0->f_6 == 0)
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1))
{
if (!func_267(bParam1, bParam2, bParam3))
{
uParam0->f_4 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 3;
}
}
else if (!func_266(bParam1, bParam2, bParam3))
{
uParam0->f_4 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 3;
}
}
else if (uParam0->f_6 == 1)
{
if (!func_266(bParam1, bParam2, bParam3))
{
uParam0->f_4 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 3;
}
}
else if (uParam0->f_6 == 2)
{
if (!func_267(bParam1, bParam2, bParam3))
{
uParam0->f_4 = unk_0xDFB7BFA6482FEE1E();
uParam0->f_5 = 3;
}
}
}
else
{
uParam0->f_5 = 2;
}
break;
case 2:
if (uParam0->f_6 == 0)
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1))
{
if (!func_267(bParam1, bParam2, bParam3))
{
uParam0->f_5 = 0;
}
}
else if (!func_266(bParam1, bParam2, bParam3))
{
uParam0->f_5 = 0;
}
}
else if (uParam0->f_6 == 1)
{
if (!func_266(bParam1, bParam2, bParam3) || unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1))
{
uParam0->f_5 = 0;
}
}
else if (uParam0->f_6 == 2)
{
if (!unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1) || unk_0x986C539B536E0ED2(unk_0x7D2B9E6A64637269(), 2))
{
uParam0->f_5 = 0;
}
else if (!func_267(bParam1, bParam2, bParam3))
{
uParam0->f_5 = 0;
}
}
break;
case 3:
if ((unk_0xDFB7BFA6482FEE1E() - uParam0->f_4) > 500)
{
if (uParam0->f_6 == 0)
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1))
{
if (func_265(bParam1, bParam2, bParam3))
{
uParam0->f_5 = 0;
}
}
else if (func_264(bParam1, bParam2, bParam3))
{
uParam0->f_5 = 0;
}
}
else if (uParam0->f_6 == 1)
{
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1) || func_264(bParam1, bParam2, bParam3))
{
uParam0->f_5 = 0;
}
}
else if (uParam0->f_6 == 2)
{
if (!unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 1) || unk_0x986C539B536E0ED2(unk_0x7D2B9E6A64637269(), 2))
{
uParam0->f_5 = 0;
}
else if (func_265(bParam1, bParam2, bParam3))
{
uParam0->f_5 = 0;
}
}
}
break;
case 4:
if (!func_247(uParam0))
{
uParam0->f_5 = 0;
}
break;
}
if (!func_251(bParam1, bParam2, bParam3))
{
uParam0->f_5 = 0;
uParam0->f_7 = 0;
}
if (uParam0->f_7)
{
func_269();
return 1;
}
else
{
return 0;
}
return 0;
}
int func_264(bool bParam0, bool bParam1, bool bParam2)
{
if (!func_251(bParam0, bParam1, bParam2))
{
return 0;
}
if (!unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if (!unk_0xAE07F5C5D7B878C1(unk_0x1146A9AE09CE2B14()))
{
unk_0x366E7F593105797F(0, 140, 1);
unk_0x366E7F593105797F(0, 80, 1);
if (unk_0x6DC4D8B66C3E0EA0(0, 80))
{
return 1;
}
}
}
return 0;
}
int func_265(bool bParam0, bool bParam1, bool bParam2)
{
if (!func_251(bParam0, bParam1, bParam2))
{
return 0;
}
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
unk_0x366E7F593105797F(0, 80, 1);
if (unk_0xC3AFE2B8AF48FCC8())
{
if (unk_0x6DC4D8B66C3E0EA0(0, 80))
{
unk_0xD6ABECE3CBB224B0(0);
return 1;
}
}
}
return 0;
}
int func_266(bool bParam0, bool bParam1, bool bParam2)
{
if (!func_251(bParam0, bParam1, bParam2))
{
return 0;
}
if (!unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
if (!unk_0xAE07F5C5D7B878C1(unk_0x1146A9AE09CE2B14()))
{
unk_0x366E7F593105797F(0, 140, 1);
unk_0x366E7F593105797F(0, 80, 1);
if (unk_0x51794501073F0A33(0, 80) && unk_0xDFB7BFA6482FEE1E() > Global_116)
{
return 1;
}
}
}
return 0;
}
int func_267(bool bParam0, bool bParam1, bool bParam2)
{
if (!func_251(bParam0, bParam1, bParam2))
{
return 0;
}
if (unk_0xC49311A2A500FF09(unk_0x7D2B9E6A64637269(), 0))
{
unk_0x366E7F593105797F(0, 80, 1);
if (unk_0xC3AFE2B8AF48FCC8())
{
if (unk_0x51794501073F0A33(0, 80) && unk_0xDFB7BFA6482FEE1E() > Global_116)
{
unk_0xD6ABECE3CBB224B0(0);
return 1;
}
}
}
return 0;
}
int func_268(int iParam0)
{
if (unk_0x419E13582192CFEA(iParam0))
{
if (unk_0x55F5BD4ABD80B211(iParam0))
{
if (unk_0xBFCE58B2B3249999(unk_0x611CD1312FD3CA66(iParam0), 0))
{
return 1;
}
}
else if (unk_0xA2CCAAC7F5CA3F49(iParam0))
{
if (!unk_0xECEC7528A52B4EE8(unk_0xFAA5505029C4B5A6(iParam0)))
{
return 1;
}
}
else if (unk_0x50997FC21D62251F(iParam0))
{
return 1;
}
}
return 0;
}
void func_269()
{
unk_0x191DDA30577F440A(&Global_7669, 4);
}
void func_270()
{
switch (iLocal_684)
{
case 0:
if (func_122(iLocal_683, 0))
{
func_284();
func_282(33);
unk_0x20D884FB6567BAD5(2);
unk_0x5E84945E26CAEF1F(0.1f);
if (func_357())
{
func_279(0, -1, 1);
func_41(500, 1);
iLocal_684 = 2;
}
else
{
if (func_33(0))
{
func_124(unk_0x7D2B9E6A64637269(), 1228.635f, -348.4277f, 68.0929f, 86.7244f);
func_272(1228.635f, -348.4277f, 68.0929f, 1112014848, 12, 5000, 0, 0);
func_41(500, 1);
}
func_271();
if (iLocal_683 == 2)
{
iLocal_684 = 0;
}
else
{
iLocal_684 = 2;
}
}
}
break;
case 2:
func_110(0);
break;
}
}
void func_271()
{
}
void func_272(struct<3> Param0, int iParam3, int iParam4, int iParam5, bool bParam6, bool bParam7)
{
var uVar0;
int iVar1;
uVar0 = unk_0xD1F051AA4563F197(Param0, iParam3, iParam4, 127);
if (unk_0xE2BB9441C54169BF(uVar0))
{
iVar1 = (unk_0xDFB7BFA6482FEE1E() + iParam5);
while (!unk_0xA5827500BA13CF74(uVar0) && unk_0xDFB7BFA6482FEE1E() < iVar1)
{
if (bParam7)
{
func_274(0);
}
if (bParam6)
{
func_273();
}
SYSTEM::WAIT(0);
}
if (unk_0xDFB7BFA6482FEE1E() < iVar1)
{
}
unk_0xDF27EE31B849DF76(uVar0);
}
}
void func_273()
{
Global_22531.f_6 = 1;
}
void func_274(int iParam0)
{
if (func_278())
{
return;
}
if (!Global_19798.f_1 == 1)
{
if (func_69(0))
{
func_275(iParam0);
}
unk_0x191DDA30577F440A(&Global_7669, 2);
}
}
void func_275(int iParam0)
{
if (func_278())
{
return;
}
if (Global_19984)
{
if (func_277())
{
func_276(1, 1);
}
else
{
func_276(0, 0);
}
}
if (Global_19798.f_1 == 10 || Global_19798.f_1 == 9)
{
unk_0x191DDA30577F440A(&Global_7669, 16);
}
if (unk_0x8820F6FCD373F9F7())
{
unk_0x75B41F5020877259(false);
}
Global_21125 = 5;
if (iParam0 == 1)
{
unk_0x191DDA30577F440A(&Global_7668, 30);
}
else
{
unk_0xC664C0067EEAB8D1(&Global_7668, 30);
}
if (!func_51())
{
Global_19798.f_1 = 3;
}
}
void func_276(bool bParam0, bool bParam1)
{
if (bParam0)
{
if (func_69(0))
{
Global_19984 = 1;
if (bParam1)
{
unk_0x3AEC124A3999B3D1(&Global_19735);
}
Global_19726 = { Global_19744[Global_19743 /*3*/] };
unk_0xA48FA5CE681A5230(Global_19726);
}
}
else if (Global_19984 == 1)
{
Global_19984 = 0;
Global_19726 = { Global_19751[Global_19743 /*3*/] };
if (bParam1)
{
unk_0xA48FA5CE681A5230(Global_19735);
}
else
{
unk_0xA48FA5CE681A5230(Global_19726);
}
}
}
bool func_277()
{
return unk_0x234B68AC2E35ED5A(Global_1695733, 5);
}
bool func_278()
{
return unk_0x234B68AC2E35ED5A(Global_1695733, 19);
}
void func_279(int iParam0, int iParam1, int iParam2)
{
if (func_357() && func_281())
{
while (Global_99365 != 6)
{
SYSTEM::WAIT(0);
}
unk_0x543F5B2D3F90CA6D(0);
if (unk_0x419E13582192CFEA(unk_0x7D2B9E6A64637269()))
{
if (!unk_0xECEC7528A52B4EE8(unk_0x7D2B9E6A64637269()))
{
unk_0x6E88C3DDF38550FA(unk_0x7D2B9E6A64637269());
}
}
if (iParam0 != 0)
{
if (!unk_0xECEC7528A52B4EE8(unk_0x7D2B9E6A64637269()))
{
if (unk_0x419E13582192CFEA(iParam0))
{
if (unk_0xBFCE58B2B3249999(iParam0, 0))
{
if (!unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), iParam0, 0))
{
unk_0xB1D85A6C23F2F945(unk_0x7D2B9E6A64637269(), iParam0, iParam1);
unk_0x3A13FD2813C8251F(0f, 1065353216);
unk_0xDF23DCD7A3E1B7A5(0f);
SYSTEM::WAIT(0);
}
}
}
}
}
if (iParam2 == 1)
{
if (unk_0xCAD1755E530A6012(unk_0x1146A9AE09CE2B14()))
{
unk_0xF99B8860747709DD(unk_0x1146A9AE09CE2B14(), 1, 0);
}
}
unk_0x87C9692CDE8B3A8D();
func_280(0);
}
}
void func_280(int iParam0)
{
if (iParam0 == 1)
{
unk_0x191DDA30577F440A(&(Global_99370.f_20), 13);
}
else
{
unk_0xC664C0067EEAB8D1(&(Global_99370.f_20), 13);
}
}
bool func_281()
{
return unk_0x234B68AC2E35ED5A(Global_99370.f_20, 13);
}
void func_282(int iParam0)
{
Global_95225 = 0;
switch (iParam0)
{
case 72:
func_283(2);
func_283(4);
break;
case 73:
func_283(0);
func_283(1);
func_283(7);
break;
case 92:
func_283(10);
func_283(9);
func_283(13);
func_283(6);
break;
case 68:
func_283(11);
break;
case 78:
func_283(14);
break;
case joaat("mpsv_lp0_31"):
func_283(3);
break;
default:
break;
}
}
void func_283(int iParam0)
{
unk_0x191DDA30577F440A(&Global_95225, iParam0);
}
void func_284()
{
int iVar0;
iVar0 = unk_0x0BF0F8F3AD0993F6();
if (unk_0x419E13582192CFEA(iVar0))
{
if (unk_0xBFCE58B2B3249999(iVar0, 0))
{
func_285(iVar0, unk_0xD6E677FAD7521410(iVar0, 1), unk_0xA8D713A937F31250(iVar0), 24, 0);
}
}
}
void func_285(int iParam0, struct<3> Param1, var uParam4, int iParam5, bool bParam6)
{
struct<60> Var0;
if (unk_0x419E13582192CFEA(iParam0) && unk_0xBFCE58B2B3249999(iParam0, 0))
{
if (iParam5 != 24 && iParam5 != 25)
{
return;
}
if (iParam5 == 24)
{
if (unk_0x419E13582192CFEA(Global_76066.f_484[25]) && unk_0xBFCE58B2B3249999(Global_76066.f_484[25], 0))
{
if (Global_76066.f_484[25] == iParam0)
{
return;
}
}
}
if (!bParam6)
{
if ((unk_0x9AAA60D60CB4E5C7(iParam0) || unk_0x6471F4759775FCA4(iParam0) == joaat("bus")) || unk_0x6471F4759775FCA4(iParam0) == joaat("tourbus"))
{
return;
}
}
func_332(iParam5);
Var0.f_9 = 49;
Var0.f_59 = 2;
func_327(iParam0, &Var0);
if (func_15(Param1, 0f, 0f, 0f, 0))
{
Param1 = { unk_0xD6E677FAD7521410(iParam0, 1) };
uParam4 = unk_0xA8D713A937F31250(iParam0);
}
if (iParam5 == 24)
{
if (unk_0x15173FB88ABC94F9(unk_0x471C98FD94C0A5FD()) != joaat("vehicle_gen_controller"))
{
Global_77054 = unk_0x15173FB88ABC94F9(unk_0x471C98FD94C0A5FD());
}
}
func_320(iParam5, &Var0, Param1, uParam4, func_326(iParam0));
func_286(iParam5, iParam0, 0);
}
}
void func_286(int iParam0, int iParam1, int iParam2)
{
int iVar0;
if (iParam0 == -1)
{
return;
}
if (!func_317(&(Global_76066.f_555[0 /*21*/]), iParam0))
{
return;
}
if (!unk_0x234B68AC2E35ED5A(Global_76066.f_555[0 /*21*/].f_9, 12) && !unk_0x234B68AC2E35ED5A(Global_76066.f_555[0 /*21*/].f_9, 10))
{
if (Global_76066.f_555[0 /*21*/].f_4 != unk_0x6471F4759775FCA4(iParam1))
{
return;
}
}
if (Global_76973 != -1 && Global_76973 != iParam0)
{
return;
}
if (unk_0x419E13582192CFEA(iParam1))
{
if (unk_0xBFCE58B2B3249999(iParam1, 0))
{
if (!unk_0xEE1D92A39CF8E1E6(iParam1))
{
unk_0x4985CD0720AFD468(iParam1, 1, 1);
}
if (iParam0 == 24)
{
Global_112293.f_32747.f_4801 = func_306();
}
if (iParam1 != Global_76066.f_139[iParam0])
{
if (iParam0 == 24)
{
iVar0 = func_305(iParam0);
if ((unk_0x419E13582192CFEA(iVar0) && unk_0xBFCE58B2B3249999(iVar0, 0)) && iParam1 != iVar0)
{
func_287(iVar0, 145);
}
}
Global_76972 = iParam1;
Global_76973 = iParam0;
Global_76974 = iParam2;
}
}
}
}
void func_287(int iParam0, int iParam1)
{
int iVar0;
int iVar1;
int iVar2;
if (!func_288(iParam0))
{
return;
}
if ((iParam1 != 0 && iParam1 != 1) && iParam1 != 2)
{
iVar0 = unk_0x27FC1B0077581B37(iParam0, -1, 0);
if (!unk_0x419E13582192CFEA(iVar0))
{
iVar0 = unk_0xC6F40BA22FFB861E(iParam0, -1);
}
if (unk_0x419E13582192CFEA(iVar0) && !unk_0xECEC7528A52B4EE8(iVar0))
{
if (unk_0x6471F4759775FCA4(iVar0) == joaat("player_zero"))
{
iParam1 = 0;
}
else if (unk_0x6471F4759775FCA4(iVar0) == joaat("player_one"))
{
iParam1 = 1;
}
else if (unk_0x6471F4759775FCA4(iVar0) == joaat("player_two"))
{
iParam1 = 2;
}
}
if ((iParam1 != 0 && iParam1 != 1) && iParam1 != 2)
{
iParam1 = Global_112293.f_2361.f_539.f_4321;
}
}
iVar1 = 0;
while (iVar1 < 3)
{
iVar2 = 0;
while (iVar2 < 2)
{
if (unk_0x6471F4759775FCA4(iParam0) == Global_112293.f_32747.f_5038[iVar1 /*157*/][iVar2 /*78*/].f_66)
{
if (!unk_0xAB6A270F84A8781E(&(Global_112293.f_32747.f_5038[iVar1 /*157*/][iVar2 /*78*/].f_1)))
{
if (unk_0xDA654EB115F9FF7D(unk_0x0B676D4511ABB729(iParam0), &(Global_112293.f_32747.f_5038[iVar1 /*157*/][iVar2 /*78*/].f_1)))
{
Global_112293.f_32747.f_5038[iVar1 /*157*/][iVar2 /*78*/].f_66 = 0;
Global_112293.f_32747.f_5592[iVar1] = iVar2;
}
}
}
iVar2++;
}
iVar1++;
}
iVar1 = 0;
while (iVar1 < 3)
{
if (unk_0x6471F4759775FCA4(iParam0) == Global_112293.f_32747.f_5600[iVar1 /*78*/].f_66)
{
if (!unk_0xAB6A270F84A8781E(&(Global_112293.f_32747.f_5600[iVar1 /*78*/].f_1)))
{
if (unk_0xDA654EB115F9FF7D(unk_0x0B676D4511ABB729(iParam0), &(Global_112293.f_32747.f_5600[iVar1 /*78*/].f_1)))
{
Global_112293.f_32747.f_5600[iVar1 /*78*/].f_66 = 0;
}
}
}
iVar1++;
}
Global_112293.f_32747.f_5590 = iParam1;
Global_76971 = iParam0;
Global_112293.f_32747.f_5588 = 1;
func_327(iParam0, &(Global_112293.f_32747.f_5510));
}
int func_288(int iParam0)
{
if ((((((((((!unk_0x419E13582192CFEA(iParam0) || !unk_0xBFCE58B2B3249999(iParam0, 0)) || func_303(iParam0, 0, 0)) || func_303(iParam0, 1, 0)) || func_303(iParam0, 2, 0)) || func_326(iParam0) != 145) || func_302(iParam0)) || func_301(iParam0)) || func_300(iParam0)) || func_299(iParam0)) || !func_289(unk_0x6471F4759775FCA4(iParam0)))
{
if (func_301(iParam0))
{
}
if (func_301(iParam0))
{
}
if (func_303(iParam0, 0, 0))
{
}
if (func_303(iParam0, 1, 0))
{
}
if (func_303(iParam0, 2, 0))
{
}
if (func_326(iParam0) != 145)
{
}
return 0;
}
return 1;
}
int func_289(int iParam0)
{
if (iParam0 == 0)
{
return 0;
}
if (!func_290(iParam0, 0))
{
return 0;
}
if (((unk_0x8D367F0B53916265(iParam0) || unk_0x48E10529AEAE00F9(iParam0)) || unk_0xE267416B80E7921F(iParam0)) || unk_0x8C6BE3ED9638F314(iParam0))
{
return 0;
}
switch (iParam0)
{
case joaat("bus"):
case joaat("stretch"):
case joaat("barracks"):
case joaat("armytanker"):
case joaat("rhino"):
case joaat("armytrailer"):
case joaat("barracks2"):
case joaat("flatbed"):
case joaat("ripley"):
case joaat("towtruck"):
case joaat("towtruck2"):
case joaat("airbus"):
case joaat("coach"):
case joaat("rentalbus"):
case joaat("tourbus"):
case joaat("firetruk"):
case joaat("pbus"):
case joaat("trash"):
case joaat("benson"):
case joaat("boattrailer"):
case joaat("biff"):
case joaat("hauler"):
case joaat("docktrailer"):
case joaat("phantom"):
case joaat("pounder"):
case joaat("tractor2"):
case joaat("bulldozer"):
case joaat("handler"):
case joaat("tiptruck"):
case joaat("cutter"):
case joaat("dump"):
case joaat("mixer"):
case joaat("mixer2"):
case joaat("rubble"):
case joaat("scrap"):
case joaat("tiptruck2"):
case joaat("camper"):
case joaat("taco"):
case joaat("boxville"):
case joaat("boxville2"):
case joaat("boxville3"):
case joaat("journey"):
case joaat("mule"):
case joaat("mule2"):
case joaat("police"):
case joaat("police2"):
case joaat("police3"):
case joaat("police4"):
case joaat("policeb"):
case joaat("policeold1"):
case joaat("policeold2"):
case joaat("policet"):
case joaat("taxi"):
case joaat("submersible"):
case joaat("submersible2"):
case joaat("monster"):
return 0;
break;
}
return 1;
}
int func_290(int iParam0, bool bParam1)
{
int iVar0;
struct<2> Var1;
if (iParam0 == 0)
{
return 0;
}
if (!unk_0xB4DD528ED76ED647(iParam0))
{
return 0;
}
if (((((iParam0 == joaat("dominator2") && !unk_0x02BFF15CAA701972()) || (iParam0 == joaat("buffalo3") && !unk_0x02BFF15CAA701972())) || (iParam0 == joaat("gauntlet2") && !unk_0x02BFF15CAA701972())) || iParam0 == joaat("blimp2")) || (iParam0 == joaat("stalion2") && !unk_0x02BFF15CAA701972()))
{
if (!func_298())
{
return 0;
}
}
else
{
iVar0 = 0;
while (iVar0 < unk_0xE4F2BC3D40737711())
{
if (unk_0x953EAC8A463313E4(iVar0, &Var1))
{
if (iParam0 == Var1.f_1)
{
if (unk_0xD1ABD511D9C326A3(Var1))
{
return 0;
}
}
}
iVar0++;
}
}
if (iParam0 == joaat("blimp"))
{
if ((((!func_297() && !func_296()) && !func_295()) && !func_294()) && !func_298())
{
return 0;
}
}
if ((iParam0 == joaat("hotknife") || iParam0 == joaat("carbonrs")) || iParam0 == joaat("khamelion"))
{
if ((unk_0x2322DD4FBF5E4E2F() || unk_0x3640D836D145B814()) || unk_0xE22116C6D321FECA())
{
}
else if (!func_295())
{
return 0;
}
}
if (bParam1)
{
if (!func_293(iParam0))
{
return 0;
}
}
if (!func_291(iParam0))
{
return 0;
}
return 1;
}
int func_291(int iParam0)
{
int iVar0;
var uVar1;
char cVar2[64];
if (!func_292())
{
return 1;
}
unk_0xB4989F41D2C06478(&iVar0, &uVar1);
if (iVar0 == 4)
{
return 1;
}
switch (iParam0)
{
case joaat("dune4"):
StringCopy(&cVar2, "VE_DUNE4_t0_v3", 64);
break;
case joaat("voltic2"):
StringCopy(&cVar2, "VE_VOLTIC2_t0_v3", 64);
break;
case joaat("ruiner2"):
StringCopy(&cVar2, "VE_RUINER2_t0_v3", 64);
break;
case joaat("phantom2"):
StringCopy(&cVar2, "VE_PHANTOM2_t0_v3", 64);
break;
case joaat("technical2"):
StringCopy(&cVar2, "VE_TECHNICAL2_t0_v3", 64);
break;
case joaat("boxville5"):
StringCopy(&cVar2, "VE_BOXVILLE5_t0_v3", 64);
break;
case joaat("wastelander"):
StringCopy(&cVar2, "VE_WASTELANDER_t0_v3", 64);
break;
case joaat("blazer5"):
StringCopy(&cVar2, "VE_BLAZER5_t0_v3", 64);
break;
default:
return 1;
break;
}
if (!unk_0x14D8BAC5AEFB49EB(&cVar2))
{
return 0;
}
return 1;
}
int func_292()
{
if (unk_0x3640D836D145B814())
{
return unk_0x57FB3D94D590E8BC();
}
return 0;
}
int func_293(int iParam0)
{
int iVar0;
int iVar1;
if (Global_2518293)
{
return 1;
}
iVar0 = 1;
iVar1 = unk_0x666C16A4ED8F3098();
if (iParam0 == joaat("btype3"))
{
if ((!Global_262145.f_6770 && !Global_262145.f_13100) && iVar1 < Global_262145.f_13101)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("faction3"))
{
if (!Global_262145.f_14400 && iVar1 < Global_262145.f_14412)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("virgo3") || iParam0 == joaat("virgo2"))
{
if (!Global_262145.f_14396 && iVar1 < Global_262145.f_14408)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sabregt2"))
{
if (!Global_262145.f_14397 && iVar1 < Global_262145.f_14409)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tornado5"))
{
if (!Global_262145.f_14398 && iVar1 < Global_262145.f_14410)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("minivan2"))
{
if (!Global_262145.f_14399 && iVar1 < Global_262145.f_14411)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("slamvan3"))
{
if (!Global_262145.f_14401 && iVar1 < Global_262145.f_14413)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("prototipo"))
{
if (!Global_262145.f_14402 && iVar1 < Global_262145.f_14405)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("seven70"))
{
if (!Global_262145.f_14403 && iVar1 < Global_262145.f_14406)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pfister811"))
{
if (!Global_262145.f_14404 && iVar1 < Global_262145.f_14407)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("bf400"))
{
if (!Global_262145.f_17032 && iVar1 < Global_262145.f_16997)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("brioso"))
{
if (!Global_262145.f_17027 && iVar1 < Global_262145.f_16992)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cliffhanger"))
{
if (!Global_262145.f_17031 && iVar1 < Global_262145.f_16996)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("contender"))
{
if (!Global_262145.f_17030 && iVar1 < Global_262145.f_16995)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("le7b"))
{
if (!Global_262145.f_17024 && iVar1 < Global_262145.f_16989)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("omnis"))
{
if (!Global_262145.f_17025 && iVar1 < Global_262145.f_16990)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("trophytruck"))
{
if (!Global_262145.f_17028 && iVar1 < Global_262145.f_16993)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("trophytruck2"))
{
if (!Global_262145.f_17029 && iVar1 < Global_262145.f_16994)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tropos"))
{
if (!Global_262145.f_17026 && iVar1 < Global_262145.f_16991)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gargoyle"))
{
if (!Global_262145.f_17034 && iVar1 < Global_262145.f_16999)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rallytruck"))
{
if (!Global_262145.f_17035 && iVar1 < Global_262145.f_17000)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tampa2"))
{
if (!Global_262145.f_17023 && iVar1 < Global_262145.f_16988)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tyrus"))
{
if (!Global_262145.f_17022 && iVar1 < Global_262145.f_16987)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sheava"))
{
if (!Global_262145.f_17021 && iVar1 < Global_262145.f_16986)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("lynx"))
{
if (!Global_262145.f_17033 && iVar1 < Global_262145.f_16998)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stalion2"))
{
if (!Global_262145.f_17036 && iVar1 < Global_262145.f_17001)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gauntlet2"))
{
if (!Global_262145.f_17037 && iVar1 < Global_262145.f_17002)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dominator2"))
{
if (!Global_262145.f_17038 && iVar1 < Global_262145.f_17003)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("buffalo3"))
{
if (!Global_262145.f_17039 && iVar1 < Global_262145.f_17004)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("defiler"))
{
if (!Global_262145.f_17186 && iVar1 < Global_262145.f_17208)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nightblade"))
{
if (!Global_262145.f_17187 && iVar1 < Global_262145.f_17209)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zombiea"))
{
if (!Global_262145.f_17188 && iVar1 < Global_262145.f_17210)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("esskey"))
{
if (!Global_262145.f_17189 && iVar1 < Global_262145.f_17211)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("avarus"))
{
if (!Global_262145.f_17190 && iVar1 < Global_262145.f_17212)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zombieb"))
{
if (!Global_262145.f_17191 && iVar1 < Global_262145.f_17213)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hakuchou2"))
{
if (!Global_262145.f_17193 && iVar1 < Global_262145.f_17214)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vortex"))
{
if (!Global_262145.f_17194 && iVar1 < Global_262145.f_17215)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("shotaro"))
{
if (!Global_262145.f_17195 && iVar1 < Global_262145.f_17216)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("chimera"))
{
if (!Global_262145.f_17196 && iVar1 < Global_262145.f_17217)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("raptor"))
{
if (!Global_262145.f_17197 && iVar1 < Global_262145.f_17218)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("daemon2"))
{
if (!Global_262145.f_17198 && iVar1 < Global_262145.f_17219)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("blazer4"))
{
if (!Global_262145.f_17199 && iVar1 < Global_262145.f_17220)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tornado6"))
{
if (!Global_262145.f_17205 && iVar1 < Global_262145.f_17227)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("youga2"))
{
if (!Global_262145.f_17202 && iVar1 < Global_262145.f_17223)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("wolfsbane"))
{
if (!Global_262145.f_17203 && iVar1 < Global_262145.f_17224)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("faggio3"))
{
if (!Global_262145.f_17204 && iVar1 < Global_262145.f_17225)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("faggio"))
{
if (!Global_262145.f_17192 && iVar1 < Global_262145.f_17226)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("bagger"))
{
if (!Global_262145.f_17206 && iVar1 < Global_262145.f_17228)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sanctus"))
{
if (!Global_262145.f_17200 && iVar1 < Global_262145.f_17221)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("manchez"))
{
if (!Global_262145.f_17201 && iVar1 < Global_262145.f_17222)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ratbike"))
{
if (!Global_262145.f_17207 && iVar1 < Global_262145.f_17229)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("voltic2"))
{
if (!Global_262145.f_18838 && iVar1 < Global_262145.f_18935)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ruiner2"))
{
if (!Global_262145.f_18839 && iVar1 < Global_262145.f_18936)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dune4"))
{
if (!Global_262145.f_18840 && iVar1 < Global_262145.f_18937)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dune5"))
{
if (!Global_262145.f_18841 && iVar1 < Global_262145.f_18938)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("phantom2"))
{
if (!Global_262145.f_18842 && iVar1 < Global_262145.f_18939)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("technical2"))
{
if (!Global_262145.f_18843 && iVar1 < Global_262145.f_18940)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("boxville5"))
{
if (!Global_262145.f_18844 && iVar1 < Global_262145.f_18941)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("wastelander"))
{
if (!Global_262145.f_18845 && iVar1 < Global_262145.f_18942)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("blazer5"))
{
if (!Global_262145.f_18846 && iVar1 < Global_262145.f_18943)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet2"))
{
if (!Global_262145.f_18847 && iVar1 < Global_262145.f_18944)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet3"))
{
if (!Global_262145.f_18848 && iVar1 < Global_262145.f_18945)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("diablous"))
{
if (!Global_262145.f_18849 && iVar1 < Global_262145.f_18946)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("diablous2"))
{
if (!Global_262145.f_18850 && iVar1 < Global_262145.f_18947)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("elegy"))
{
if (!Global_262145.f_18851 && iVar1 < Global_262145.f_18948)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("elegy2"))
{
if (!Global_262145.f_18852 && iVar1 < Global_262145.f_18949)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("fcr"))
{
if (!Global_262145.f_18853 && iVar1 < Global_262145.f_18950)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("fcr2"))
{
if (!Global_262145.f_18854 && iVar1 < Global_262145.f_18951)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("italigtb"))
{
if (!Global_262145.f_18855 && iVar1 < Global_262145.f_18952)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("italigtb2"))
{
if (!Global_262145.f_18856 && iVar1 < Global_262145.f_18953)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nero"))
{
if (!Global_262145.f_18857 && iVar1 < Global_262145.f_18954)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nero2"))
{
if (!Global_262145.f_18858 && iVar1 < Global_262145.f_18955)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("penetrator"))
{
if (!Global_262145.f_18859 && iVar1 < Global_262145.f_18956)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("specter"))
{
if (!Global_262145.f_18860 && iVar1 < Global_262145.f_18957)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("specter2"))
{
if (!Global_262145.f_18861 && iVar1 < Global_262145.f_18958)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tempesta"))
{
if (!Global_262145.f_18862 && iVar1 < Global_262145.f_18959)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("gp1"))
{
if (!Global_262145.f_19919 && iVar1 < Global_262145.f_19915)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("infernus2"))
{
if (!Global_262145.f_19920 && iVar1 < Global_262145.f_19916)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ruston"))
{
if (!Global_262145.f_19921 && iVar1 < Global_262145.f_19917)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("turismo2"))
{
if (!Global_262145.f_19922 && iVar1 < Global_262145.f_19918)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("xa21"))
{
if (!Global_262145.f_20800 && iVar1 < Global_262145.f_20808)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cheetah2"))
{
if (!Global_262145.f_20801 && iVar1 < Global_262145.f_20809)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("torero"))
{
if (!Global_262145.f_20802 && iVar1 < Global_262145.f_20810)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vagner"))
{
if (!Global_262145.f_20803 && iVar1 < Global_262145.f_20811)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ardent"))
{
if (!Global_262145.f_20804 && iVar1 < Global_262145.f_20812)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nightshark"))
{
if (!Global_262145.f_20805 && iVar1 < Global_262145.f_20813)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("microlight"))
{
if (!Global_262145.f_21580 && iVar1 < Global_262145.f_21600)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("mogul"))
{
if (!Global_262145.f_21592 && iVar1 < Global_262145.f_21612)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rogue"))
{
if (!Global_262145.f_21583 && iVar1 < Global_262145.f_21603)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("starling"))
{
if (!Global_262145.f_21593 && iVar1 < Global_262145.f_21613)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("seabreeze"))
{
if (!Global_262145.f_21581 && iVar1 < Global_262145.f_21601)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tula"))
{
if (!Global_262145.f_21597 && iVar1 < Global_262145.f_21617)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pyro"))
{
if (!Global_262145.f_21595 && iVar1 < Global_262145.f_21615)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("molotok"))
{
if (!Global_262145.f_21596 && iVar1 < Global_262145.f_21616)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nokota"))
{
if (!Global_262145.f_21591 && iVar1 < Global_262145.f_21611)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("bombushka"))
{
if (!Global_262145.f_21598 && iVar1 < Global_262145.f_21618)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hunter"))
{
if (!Global_262145.f_21594 && iVar1 < Global_262145.f_21614)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("havok"))
{
if (!Global_262145.f_21590 && iVar1 < Global_262145.f_21610)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("howard"))
{
if (!Global_262145.f_21582 && iVar1 < Global_262145.f_21602)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("alphaz1"))
{
if (!Global_262145.f_21584 && iVar1 < Global_262145.f_21604)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cyclone"))
{
if (!Global_262145.f_21585 && iVar1 < Global_262145.f_21605)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("visione"))
{
if (!Global_262145.f_21586 && iVar1 < Global_262145.f_21606)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vigilante"))
{
if (!Global_262145.f_21587 && iVar1 < Global_262145.f_21607)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("retinue"))
{
if (!Global_262145.f_21588 && iVar1 < Global_262145.f_21608)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rapidgt3"))
{
if (!Global_262145.f_21589 && iVar1 < Global_262145.f_21609)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("deluxo"))
{
if (!Global_262145.f_22541 && iVar1 < Global_262145.f_22569)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stromberg"))
{
if (!Global_262145.f_22542 && iVar1 < Global_262145.f_22570)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("riot2"))
{
if (!Global_262145.f_22543 && iVar1 < Global_262145.f_22571)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("chernobog"))
{
if (!Global_262145.f_22544 && iVar1 < Global_262145.f_22572)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("khanjali"))
{
if (!Global_262145.f_22545 && iVar1 < Global_262145.f_22573)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("akula"))
{
if (!Global_262145.f_22546 && iVar1 < Global_262145.f_22574)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("thruster"))
{
if (!Global_262145.f_22547 && iVar1 < Global_262145.f_22575)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("barrage"))
{
if (!Global_262145.f_22548 && iVar1 < Global_262145.f_22576)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("volatol"))
{
if (!Global_262145.f_22549 && iVar1 < Global_262145.f_22577)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet4"))
{
if (!Global_262145.f_22550 && iVar1 < Global_262145.f_22578)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("neon"))
{
if (!Global_262145.f_22551 && iVar1 < Global_262145.f_22579)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("streiter"))
{
if (!Global_262145.f_22552 && iVar1 < Global_262145.f_22580)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sentinel3"))
{
if (!Global_262145.f_22553 && iVar1 < Global_262145.f_22581)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("yosemite"))
{
if (!Global_262145.f_22554 && iVar1 < Global_262145.f_22582)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sc1"))
{
if (!Global_262145.f_22555 && iVar1 < Global_262145.f_22583)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("autarch"))
{
if (!Global_262145.f_22556 && iVar1 < Global_262145.f_22584)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gt500"))
{
if (!Global_262145.f_22557 && iVar1 < Global_262145.f_22585)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hustler"))
{
if (!Global_262145.f_22558 && iVar1 < Global_262145.f_22586)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("revolter"))
{
if (!Global_262145.f_22559 && iVar1 < Global_262145.f_22587)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pariah"))
{
if (!Global_262145.f_22560 && iVar1 < Global_262145.f_22588)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("raiden"))
{
if (!Global_262145.f_22561 && iVar1 < Global_262145.f_22589)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("savestra"))
{
if (!Global_262145.f_22562 && iVar1 < Global_262145.f_22590)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("riata"))
{
if (!Global_262145.f_22563 && iVar1 < Global_262145.f_22591)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hermes"))
{
if (!Global_262145.f_22564 && iVar1 < Global_262145.f_22592)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("comet5"))
{
if (!Global_262145.f_22565 && iVar1 < Global_262145.f_22593)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("z190"))
{
if (!Global_262145.f_22566 && iVar1 < Global_262145.f_22594)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("viseris"))
{
if (!Global_262145.f_22567 && iVar1 < Global_262145.f_22595)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("kamacho"))
{
if (!Global_262145.f_22568 && iVar1 < Global_262145.f_22596)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("gb200"))
{
if (!Global_262145.f_23761 && iVar1 < Global_262145.f_23777)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("fagaloa"))
{
if (!Global_262145.f_23762 && iVar1 < Global_262145.f_23778)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("ellie"))
{
if (!Global_262145.f_23766 && iVar1 < Global_262145.f_23782)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("issi3"))
{
if (!Global_262145.f_23769 && iVar1 < Global_262145.f_23785)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("michelli"))
{
if (!Global_262145.f_23774 && iVar1 < Global_262145.f_23790)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("flashgt"))
{
if (!Global_262145.f_23768 && iVar1 < Global_262145.f_23784)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hotring"))
{
if (!Global_262145.f_23760 && iVar1 < Global_262145.f_23776)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tezeract"))
{
if (!Global_262145.f_23767 && iVar1 < Global_262145.f_23783)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tyrant"))
{
if (!Global_262145.f_23773 && iVar1 < Global_262145.f_23789)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dominator3"))
{
if (!Global_262145.f_23772 && iVar1 < Global_262145.f_23788)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("taipan"))
{
if (!Global_262145.f_23763 && iVar1 < Global_262145.f_23779)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("entity2"))
{
if (!Global_262145.f_23765 && iVar1 < Global_262145.f_23781)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("jester3"))
{
if (!Global_262145.f_23775 && iVar1 < Global_262145.f_23791)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("cheburek"))
{
if (!Global_262145.f_23771 && iVar1 < Global_262145.f_23787)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("caracara"))
{
if (!Global_262145.f_23764 && iVar1 < Global_262145.f_23780)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("seasparrow"))
{
if (!Global_262145.f_23770 && iVar1 < Global_262145.f_23786)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("terbyte"))
{
if (!Global_262145.f_23851 && iVar1 < Global_262145.f_23838)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pbus2"))
{
if (!Global_262145.f_23852 && iVar1 < Global_262145.f_23839)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("mule4"))
{
if (!Global_262145.f_23857 && iVar1 < Global_262145.f_23844)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("pounder2"))
{
if (!Global_262145.f_23856 && iVar1 < Global_262145.f_23843)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("swinger"))
{
if (!Global_262145.f_23854 && iVar1 < Global_262145.f_23841)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("menacer"))
{
if (!Global_262145.f_23860 && iVar1 < Global_262145.f_23847)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("scramjet"))
{
if (!Global_262145.f_23862 && iVar1 < Global_262145.f_23849)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("strikeforce"))
{
if (!Global_262145.f_23863 && iVar1 < Global_262145.f_23850)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("oppressor2"))
{
if (!Global_262145.f_23861 && iVar1 < Global_262145.f_23848)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("patriot2"))
{
if (!Global_262145.f_23853 && iVar1 < Global_262145.f_23840)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stafford"))
{
if (!Global_262145.f_23855 && iVar1 < Global_262145.f_23842)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("freecrawler"))
{
if (!Global_262145.f_23859 && iVar1 < Global_262145.f_23846)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("blimp3"))
{
if (!Global_262145.f_23858 && iVar1 < Global_262145.f_23845)
{
iVar0 = 0;
}
}
if (iParam0 == joaat("monster3"))
{
}
else if (iParam0 == joaat("cerberus"))
{
}
else if (iParam0 == joaat("cerberus2"))
{
}
else if (iParam0 == joaat("cerberus3"))
{
}
else if (iParam0 == joaat("brutus"))
{
}
else if (iParam0 == joaat("brutus2"))
{
}
else if (iParam0 == joaat("brutus3"))
{
}
else if (iParam0 == joaat("scarab"))
{
}
else if (iParam0 == joaat("scarab2"))
{
}
else if (iParam0 == joaat("scarab3"))
{
}
else if (iParam0 == joaat("imperator"))
{
}
else if (iParam0 == joaat("imperator2"))
{
}
else if (iParam0 == joaat("imperator3"))
{
}
else if (iParam0 == joaat("zr380"))
{
}
else if (iParam0 == joaat("zr3802"))
{
}
else if (iParam0 == joaat("zr3803"))
{
}
else if (iParam0 == joaat("impaler"))
{
}
else if (iParam0 == joaat("deveste"))
{
if (!Global_262145.f_26267 && iVar1 < Global_262145.f_26269)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("toros"))
{
if (!Global_262145.f_25280 && iVar1 < Global_262145.f_25273)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("clique"))
{
if (!Global_262145.f_25281 && iVar1 < Global_262145.f_25274)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("italigto"))
{
if (!Global_262145.f_25282 && iVar1 < Global_262145.f_25275)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("deviant"))
{
if (!Global_262145.f_25283 && iVar1 < Global_262145.f_25276)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vamos"))
{
if (!Global_262145.f_26268 && iVar1 < Global_262145.f_26270)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tulip"))
{
if (!Global_262145.f_25284 && iVar1 < Global_262145.f_25277)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("schlagen"))
{
if (!Global_262145.f_25285 && iVar1 < Global_262145.f_25278)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rcbandito"))
{
if (!Global_262145.f_25286 && iVar1 < Global_262145.f_25279)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("thrax"))
{
if (!Global_262145.f_25291 && iVar1 < Global_262145.f_25312)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("drafter"))
{
if (!Global_262145.f_25292 && iVar1 < Global_262145.f_25313)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("locust"))
{
if (!Global_262145.f_25293 && iVar1 < Global_262145.f_25314)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("novak"))
{
if (!Global_262145.f_25294 && iVar1 < Global_262145.f_25315)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zorrusso"))
{
if (!Global_262145.f_25295 && iVar1 < Global_262145.f_25316)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gauntlet3"))
{
if (!Global_262145.f_25296 && iVar1 < Global_262145.f_25317)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("issi7"))
{
if (!Global_262145.f_25297 && iVar1 < Global_262145.f_25318)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zion3"))
{
if (!Global_262145.f_25298 && iVar1 < Global_262145.f_25319)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("nebula"))
{
if (!Global_262145.f_25299 && iVar1 < Global_262145.f_25320)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("hellion"))
{
if (!Global_262145.f_25300 && iVar1 < Global_262145.f_25321)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dynasty"))
{
if (!Global_262145.f_25301 && iVar1 < Global_262145.f_25322)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rrocket"))
{
if (!Global_262145.f_25302 && iVar1 < Global_262145.f_25323)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("peyote2"))
{
if (!Global_262145.f_25303 && iVar1 < Global_262145.f_25324)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gauntlet4"))
{
if (!Global_262145.f_25304 && iVar1 < Global_262145.f_25325)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("caracara2"))
{
if (!Global_262145.f_25305 && iVar1 < Global_262145.f_25326)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("jugular"))
{
if (!Global_262145.f_25306 && iVar1 < Global_262145.f_25327)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("s80"))
{
if (!Global_262145.f_25307 && iVar1 < Global_262145.f_25328)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("krieger"))
{
if (!Global_262145.f_25308 && iVar1 < Global_262145.f_25329)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("emerus"))
{
if (!Global_262145.f_25309 && iVar1 < Global_262145.f_25330)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("neo"))
{
if (!Global_262145.f_25310 && iVar1 < Global_262145.f_25331)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("paragon"))
{
if (!Global_262145.f_25311 && iVar1 < Global_262145.f_25332)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("asbo"))
{
if (!Global_262145.f_28111 && iVar1 < Global_262145.f_28132)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("kanjo"))
{
if (!Global_262145.f_28112 && iVar1 < Global_262145.f_28133)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("everon"))
{
if (!Global_262145.f_28113 && iVar1 < Global_262145.f_28134)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("retinue2"))
{
if (!Global_262145.f_28114 && iVar1 < Global_262145.f_28135)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("yosemite2"))
{
if (!Global_262145.f_28115 && iVar1 < Global_262145.f_28136)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sugoi"))
{
if (!Global_262145.f_28116 && iVar1 < Global_262145.f_28137)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("sultan2"))
{
if (!Global_262145.f_28117 && iVar1 < Global_262145.f_28138)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("outlaw"))
{
if (!Global_262145.f_28118 && iVar1 < Global_262145.f_28139)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vagrant"))
{
if (!Global_262145.f_28119 && iVar1 < Global_262145.f_28140)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("komoda"))
{
if (!Global_262145.f_28120 && iVar1 < Global_262145.f_28141)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stryder"))
{
if (!Global_262145.f_28121 && iVar1 < Global_262145.f_28142)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("furia"))
{
if (!Global_262145.f_28122 && iVar1 < Global_262145.f_28143)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("zhaba"))
{
if (!Global_262145.f_28123 && iVar1 < Global_262145.f_28144)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("jb7002"))
{
if (!Global_262145.f_28124 && iVar1 < Global_262145.f_28145)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("firetruk"))
{
if (!Global_262145.f_28125 && iVar1 < Global_262145.f_28146)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("burrito2"))
{
if (!Global_262145.f_28126 && iVar1 < Global_262145.f_28147)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("boxville"))
{
if (!Global_262145.f_28127 && iVar1 < Global_262145.f_28148)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("stockade"))
{
if (!Global_262145.f_28128 && iVar1 < Global_262145.f_28149)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("minitank"))
{
if (!Global_262145.f_28129 && iVar1 < Global_262145.f_28150)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("lguard"))
{
if (!Global_262145.f_28130 && iVar1 < Global_262145.f_28151)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("blazer2"))
{
if (!Global_262145.f_28131 && iVar1 < Global_262145.f_28152)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("formula"))
{
if ((!Global_262145.f_28154 && iVar1 < Global_262145.f_28155) && !Global_262145.f_28109)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("formula2"))
{
if ((!Global_262145.f_28157 && iVar1 < Global_262145.f_28158) && !Global_262145.f_28110)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("imorgon"))
{
if (!Global_262145.f_28162 && iVar1 < Global_262145.f_28165)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("rebla"))
{
if (!Global_262145.f_28163 && iVar1 < Global_262145.f_28166)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vstr"))
{
if (!Global_262145.f_28164 && iVar1 < Global_262145.f_28167)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("gauntlet5"))
{
if (!Global_262145.f_29178 && iVar1 < Global_262145.f_28843)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("club"))
{
if (!Global_262145.f_28829 && iVar1 < Global_262145.f_28850)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dukes3"))
{
if (!Global_262145.f_28830 && iVar1 < Global_262145.f_28836)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("yosemite3"))
{
if (!Global_262145.f_29176 && iVar1 < Global_262145.f_28844)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("peyote3"))
{
if (!Global_262145.f_29177 && iVar1 < Global_262145.f_28845)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("glendale2"))
{
if (!Global_262145.f_28823 && iVar1 < Global_262145.f_28842)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("penumbra2"))
{
if (!Global_262145.f_28824 && iVar1 < Global_262145.f_28851)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("landstalker2"))
{
if (!Global_262145.f_28825 && iVar1 < Global_262145.f_28841)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("seminole2"))
{
if (!Global_262145.f_28826 && iVar1 < Global_262145.f_28839)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("tigon"))
{
if (!Global_262145.f_29172 && iVar1 < Global_262145.f_28846)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("openwheel1"))
{
if (!Global_262145.f_29173 && iVar1 < Global_262145.f_28847)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("openwheel2"))
{
if (!Global_262145.f_29174 && iVar1 < Global_262145.f_28848)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("coquette4"))
{
if (!Global_262145.f_29175 && iVar1 < Global_262145.f_28849)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("manana2"))
{
if (!Global_262145.f_28827 && iVar1 < Global_262145.f_28838)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("youga3"))
{
if (!Global_262145.f_28828 && iVar1 < Global_262145.f_28840)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("toreador"))
{
if (!Global_262145.f_29620 && iVar1 < Global_262145.f_29603)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("annihilator2"))
{
if (!Global_262145.f_29621 && iVar1 < Global_262145.f_29604)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("alkonost"))
{
if (!Global_262145.f_29622 && iVar1 < Global_262145.f_29605)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("patrolboat"))
{
if (!Global_262145.f_29623 && iVar1 < Global_262145.f_29606)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("longfin"))
{
if (!Global_262145.f_29624 && iVar1 < Global_262145.f_29607)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("winky"))
{
if (!Global_262145.f_29625 && iVar1 < Global_262145.f_29608)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("veto"))
{
if (!Global_262145.f_29626 && iVar1 < Global_262145.f_29609)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("veto2"))
{
if (!Global_262145.f_29627 && iVar1 < Global_262145.f_29610)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("italirsx"))
{
if (!Global_262145.f_29628 && iVar1 < Global_262145.f_29611)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("weevil"))
{
if (Global_262145.f_29637)
{
}
else if (!Global_262145.f_29629 && iVar1 < Global_262145.f_29612)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("manchez2"))
{
if (!Global_262145.f_29630 && iVar1 < Global_262145.f_29613)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("slamtruck"))
{
if (!Global_262145.f_29631 && iVar1 < Global_262145.f_29614)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("vetir"))
{
if (!Global_262145.f_29632 && iVar1 < Global_262145.f_29615)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("squaddie"))
{
if (!Global_262145.f_29633 && iVar1 < Global_262145.f_29616)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("brioso2"))
{
if (Global_262145.f_29638)
{
}
else if (!Global_262145.f_29634 && iVar1 < Global_262145.f_29617)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("dinghy5"))
{
if (!Global_262145.f_29635 && iVar1 < Global_262145.f_29618)
{
iVar0 = 0;
}
}
else if (iParam0 == joaat("verus"))
{
if (!Global_262145.f_29636 && iVar1 < Global_262145.f_29619)
{
iVar0 = 0;
}
}
else if (iParam0 == -1244461404)
{
if (!Global_262145.f_30484 && iVar1 < Global_262145.f_30467)
{
iVar0 = 0;
}
}
else if (iParam0 == 2038480341)
{
if (!Global_262145.f_30485 && iVar1 < Global_262145.f_30468)
{
iVar0 = 0;
}
}
else if (iParam0 == -291021213)
{
if (!Global_262145.f_30486 && iVar1 < Global_262145.f_30469)
{
iVar0 = 0;
}
}
else if (iParam0 == -452604007)
{
if (!Global_262145.f_30487 && iVar1 < Global_262145.f_30470)
{
iVar0 = 0;
}
}
else if (iParam0 == -1540373595)
{
if (!Global_262145.f_30488 && iVar1 < Global_262145.f_30471)
{
iVar0 = 0;
}
}
else if (iParam0 == -1858654120)
{
if (!Global_262145.f_30489 && iVar1 < Global_262145.f_30472)
{
iVar0 = 0;
}
}
else if (iParam0 == 579912970)
{
if (!Global_262145.f_30490 && iVar1 < Global_262145.f_30473)
{
iVar0 = 0;
}
}
else if (iParam0 == -1193912403)
{
if (!Global_262145.f_30491 && iVar1 < Global_262145.f_30474)
{
iVar0 = 0;
}
}
else if (iParam0 == 1377217886)
{
if (!Global_262145.f_30492 && iVar1 < Global_262145.f_30475)
{
iVar0 = 0;
}
}
else if (iParam0 == 1755697647)
{
if (!Global_262145.f_30493 && iVar1 < Global_262145.f_30476)
{
iVar0 = 0;
}
}
else if (iParam0 == 426742808)
{
if (!Global_262145.f_30494 && iVar1 < Global_262145.f_30477)
{
iVar0 = 0;
}
}
else if (iParam0 == -1582061455)
{
if (!Global_262145.f_30495 && iVar1 < Global_262145.f_30478)
{
iVar0 = 0;
}
}
else if (iParam0 == -1507230520)
{
if (!Global_262145.f_30496 && iVar1 < Global_262145.f_30479)
{
iVar0 = 0;
}
}
else if (iParam0 == 736672010)
{
if (!Global_262145.f_30497 && iVar1 < Global_262145.f_30480)
{
iVar0 = 0;
}
}
else if (iParam0 == 1416471345)
{
if (!Global_262145.f_30498 && iVar1 < Global_262145.f_30481)
{
iVar0 = 0;
}
}
else if (iParam0 == 1304459735)
{
if (!Global_262145.f_30499 && iVar1 < Global_262145.f_30482)
{
iVar0 = 0;
}
}
else if (iParam0 == -1726022652)
{
if (!Global_262145.f_30500 && iVar1 < Global_262145.f_30483)
{
iVar0 = 0;
}
}
return iVar0;
}
int func_294()
{
return 0;
}
int func_295()
{
return 1;
}
int func_296()
{
return 1;
}
int func_297()
{
if (unk_0x14FA206D9CE730A9(-1226939934))
{
return 1;
}
return 0;
}
int func_298()
{
var uVar0;
if (unk_0xB2EC8B4970766623())
{
if (unk_0x1D0F0A8090E1551E())
{
if (unk_0x722D5CFE95568B02())
{
unk_0xD885BEFA31A18D47(joaat("sp_unlock_exclus_content"), &uVar0, -1);
unk_0x191DDA30577F440A(&uVar0, 2);
unk_0x191DDA30577F440A(&uVar0, 4);
unk_0x191DDA30577F440A(&uVar0, 6);
unk_0x191DDA30577F440A(&Global_25, 2);
unk_0x191DDA30577F440A(&Global_25, 4);
unk_0x191DDA30577F440A(&Global_25, 6);
unk_0xAC4FD27671081628(joaat("sp_unlock_exclus_content"), uVar0, 1);
if (unk_0xF7701A907195ED86())
{
uVar0 = unk_0xC82CD1DB42480082(866);
unk_0x191DDA30577F440A(&uVar0, 0);
unk_0x0E32F508F8A14DE9(uVar0);
}
return 1;
}
}
}
if (Global_151130 == 2)
{
return 1;
}
else if (Global_151130 == 3)
{
return 0;
}
if (unk_0xF7701A907195ED86())
{
if (unk_0x234B68AC2E35ED5A(unk_0xC82CD1DB42480082(866), 0))
{
return 1;
}
}
return 0;
}
int func_299(int iParam0)
{
int iVar0;
char* sVar1;
iVar0 = unk_0x6471F4759775FCA4(iParam0);
sVar1 = unk_0x0B676D4511ABB729(iParam0);
if (iVar0 == joaat("speedo") && unk_0xDA654EB115F9FF7D(sVar1, "LAMAR G "))
{
return 1;
}
if (!func_290(iVar0, 0))
{
return 1;
}
return 0;
}
int func_300(int iParam0)
{
int iVar0;
iVar0 = 0;
while (iVar0 < 3)
{
if (unk_0x419E13582192CFEA(Global_96731[iVar0]))
{
if (Global_96731[iVar0] == iParam0)
{
return 1;
}
}
iVar0++;
}
return 0;
}
int func_301(int iParam0)
{
int iVar0;
if (unk_0x419E13582192CFEA(iParam0) && unk_0xBFCE58B2B3249999(iParam0, 0))
{
iVar0 = 0;
while (iVar0 < 9)
{
if (unk_0x419E13582192CFEA(Global_96701[iVar0]) && unk_0xBFCE58B2B3249999(Global_96701[iVar0], 0))
{
if (Global_96701[iVar0] == iParam0 && unk_0x6471F4759775FCA4(Global_96701[iVar0]) == unk_0x6471F4759775FCA4(iParam0))
{
return 1;
}
}
iVar0++;
}
}
return 0;
}
int func_302(int iParam0)
{
int iVar0;
if (unk_0x419E13582192CFEA(Global_76066.f_484[24]))
{
if (iParam0 == Global_76066.f_484[24])
{
return 0;
}
}
iVar0 = 0;
while (iVar0 < 68)
{
if (unk_0x419E13582192CFEA(Global_76066.f_484[iVar0]))
{
if ((((((((((((iVar0 != 24 && iVar0 != 21) && iVar0 != 22) && iVar0 != 23) && iVar0 != 27) && iVar0 != 30) && iVar0 != 33) && iVar0 != 28) && iVar0 != 31) && iVar0 != 34) && iVar0 != 26) && iVar0 != 29) && iVar0 != 32)
{
if (iParam0 == Global_76066.f_484[iVar0])
{
return 1;
}
}
}
iVar0++;
}
return 0;
}
int func_303(int iParam0, int iParam1, bool bParam2)
{
int iVar0;
char* sVar1;
int iVar9;
if (!unk_0x419E13582192CFEA(iParam0) || !unk_0xBFCE58B2B3249999(iParam0, 0))
{
return 0;
}
iVar0 = 0;
while (func_304(iParam1, iVar0, &sVar1, &iVar9))
{
if (!bParam2 || unk_0x234B68AC2E35ED5A(Global_112293.f_7227[iVar9], 0))
{
if (unk_0xC5C459033A48B1E4(&sVar1, iParam0))
{
return 1;
}
}
iVar0++;
}
return 0;
}
int func_304(int iParam0, int iParam1, char* sParam2, var uParam3)
{
StringCopy(sParam2, "", 32);
switch (iParam0)
{
case 0:
if (iParam1 == 0)
{
StringCopy(sParam2, "Michael - Beverly Hills", 32);
*uParam3 = 0;
return 1;
}
else if (iParam1 == 1)
{
StringCopy(sParam2, "Trevor - Countryside", 32);
*uParam3 = 1;
return 1;
}
break;
case 1:
if (iParam1 == 0)
{
StringCopy(sParam2, "Franklin - Aunt", 32);
*uParam3 = 5;
return 1;
}
else if (iParam1 == 1)
{
StringCopy(sParam2, "Franklin - Hills", 32);
*uParam3 = 6;
return 1;
}
break;
case 2:
if (iParam1 == 0)
{
StringCopy(sParam2, "Trevor - Countryside", 32);
*uParam3 = 2;
return 1;
}
else if (iParam1 == 1)
{
StringCopy(sParam2, "Trevor - City", 32);
*uParam3 = 3;
return 1;
}
else if (iParam1 == 2)
{
StringCopy(sParam2, "Trevor - Stripclub", 32);
*uParam3 = 4;
return 1;
}
break;
}
return 0;
}
int func_305(int iParam0)
{
if (iParam0 == -1)
{
return 0;
}
return Global_76066.f_139[iParam0];
}
var func_306()
{
var uVar0;
func_316(&uVar0, unk_0x1947D86A2BB06F8D());
func_315(&uVar0, unk_0x942C8DFFBBCB3EB4());
func_314(&uVar0, unk_0xCA86FAB7FADC8353());
func_309(&uVar0, unk_0x9E6858A319A1F6F2());
func_308(&uVar0, unk_0xA91C851005050418());
func_307(&uVar0, unk_0x77D50D8E8FF785AC());
return uVar0;
}
void func_307(var uParam0, int iParam1)
{
if (iParam1 <= 0)
{
return;
}
if (iParam1 > 2043 || iParam1 < 1979)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 2080374784);
if (iParam1 < 2011)
{
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT((2011 - iParam1), 26));
*uParam0 |= -2147483648;
}
else
{
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT((iParam1 - 2011), 26));
*uParam0 = (*uParam0 - *uParam0 & -2147483648);
}
}
void func_308(var uParam0, int iParam1)
{
if (iParam1 < 0 || iParam1 > 11)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 15);
*uParam0 = (*uParam0 || iParam1);
}
void func_309(var uParam0, int iParam1)
{
int iVar0;
int iVar1;
iVar0 = func_313(*uParam0);
iVar1 = func_311(*uParam0);
if (iParam1 < 1 || iParam1 > func_310(iVar0, iVar1))
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 496);
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT(iParam1, 4));
}
int func_310(int iParam0, int iParam1)
{
if (iParam1 < 0)
{
iParam1 = 0;
}
switch (iParam0)
{
case 0:
case 2:
case 4:
case 6:
case 7:
case 9:
case 11:
return 31;
break;
case 3:
case 5:
case 8:
case 10:
return 30;
break;
case 1:
if ((iParam1 % 4) == 0)
{
if ((iParam1 % 100) != 0)
{
return 29;
}
else if ((iParam1 % 400) == 0)
{
return 29;
}
}
return 28;
break;
}
return 30;
}
var func_311(int iParam0)
{
return (SYSTEM::SHIFT_RIGHT(iParam0, 26) & 31 * func_312(unk_0x234B68AC2E35ED5A(iParam0, 31), -1, 1)) + 2011;
}
int func_312(bool bParam0, int iParam1, int iParam2)
{
if (bParam0)
{
return iParam1;
}
return iParam2;
}
int func_313(var uParam0)
{
return uParam0 & 15;
}
void func_314(var uParam0, int iParam1)
{
if (iParam1 < 0 || iParam1 > 24)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 15872);
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT(iParam1, 9));
}
void func_315(var uParam0, int iParam1)
{
if (iParam1 < 0 || iParam1 >= 60)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 1032192);
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT(iParam1, 14));
}
void func_316(var uParam0, int iParam1)
{
if (iParam1 < 0 || iParam1 >= 60)
{
return;
}
*uParam0 = (*uParam0 - *uParam0 & 66060288);
*uParam0 = (*uParam0 || SYSTEM::SHIFT_LEFT(iParam1, 20));
}
int func_317(var uParam0, int iParam1)
{
int iVar0;
int iVar1;
*uParam0 = { 0f, 0f, 0f };
uParam0->f_3 = 0f;
uParam0->f_4 = 0;
StringCopy(&(uParam0->f_5), "", 16);
uParam0->f_9 = 0;
uParam0->f_10 = 0;
uParam0->f_11 = 0;
uParam0->f_12 = 145;
uParam0->f_13 = -1;
uParam0->f_14 = 0;
uParam0->f_15 = { 0f, 0f, 0f };
uParam0->f_18 = { 0f, 0f, 0f };
switch (iParam1)
{
case 0:
*uParam0 = { -831.8538f, 172.1154f, 69.9058f };
uParam0->f_3 = 157.5705f;
uParam0->f_4 = func_318(0, 1);
uParam0->f_12 = 0;
unk_0x191DDA30577F440A(&(uParam0->f_9), 20);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 1:
*uParam0 = { 1970.943f, 3801.684f, 31.1396f };
uParam0->f_3 = 301.3964f;
uParam0->f_4 = func_318(0, 1);
uParam0->f_12 = 0;
unk_0x191DDA30577F440A(&(uParam0->f_9), 20);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 2:
*uParam0 = { -22.6297f, -1439.137f, 29.6549f };
uParam0->f_3 = 180.0808f;
uParam0->f_4 = func_318(1, 1);
uParam0->f_12 = 1;
unk_0x191DDA30577F440A(&(uParam0->f_9), 20);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 3:
*uParam0 = { -22.5229f, -1434.699f, 29.6552f };
uParam0->f_3 = 141.6114f;
uParam0->f_4 = func_318(1, 2);
uParam0->f_12 = 1;
unk_0x191DDA30577F440A(&(uParam0->f_9), 19);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 4:
*uParam0 = { 10.9281f, 545.669f, 174.7951f };
uParam0->f_3 = 61.392f;
uParam0->f_4 = func_318(1, 1);
uParam0->f_12 = 1;
unk_0x191DDA30577F440A(&(uParam0->f_9), 20);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 5:
*uParam0 = { 6.1093f, 544.9742f, 174.2835f };
uParam0->f_3 = 92.1548f;
uParam0->f_4 = func_318(1, 2);
uParam0->f_12 = 1;
unk_0x191DDA30577F440A(&(uParam0->f_9), 19);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 6:
*uParam0 = { 1981.416f, 3808.131f, 31.1384f };
uParam0->f_3 = 117.2557f;
uParam0->f_4 = func_318(2, 1);
uParam0->f_12 = 2;
unk_0x191DDA30577F440A(&(uParam0->f_9), 20);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 7:
*uParam0 = { -1158.488f, -1529.367f, 3.8995f };
uParam0->f_3 = 35.7505f;
uParam0->f_4 = func_318(2, 1);
uParam0->f_12 = 2;
unk_0x191DDA30577F440A(&(uParam0->f_9), 20);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 8:
*uParam0 = { 148.2868f, -1270.569f, 28.2252f };
uParam0->f_3 = 208.4685f;
uParam0->f_4 = func_318(2, 1);
uParam0->f_12 = 2;
unk_0x191DDA30577F440A(&(uParam0->f_9), 20);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
iVar0 = 1;
break;
case 9:
*uParam0 = { 1459.509f, -1380.45f, 78.3259f };
uParam0->f_3 = 99.6211f;
uParam0->f_4 = joaat("scorcher");
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 10:
*uParam0 = { -1518.947f, -1387.865f, -0.5134f };
uParam0->f_3 = 98.3867f;
uParam0->f_4 = joaat("seashark");
iVar0 = 1;
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
break;
case 11:
*uParam0 = { 353.0926f, 3577.593f, 32.351f };
uParam0->f_3 = 16.6205f;
uParam0->f_4 = joaat("duster");
iVar0 = 1;
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
break;
case 12:
uParam0->f_14 = 0;
*uParam0 = { -1652.004f, -3142.348f, 12.9921f };
uParam0->f_3 = 329.1082f;
uParam0->f_12 = 0;
uParam0->f_13 = 359;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 13:
uParam0->f_14 = 1;
*uParam0 = { -1271.649f, -3380.685f, 12.9451f };
uParam0->f_3 = 329.5137f;
uParam0->f_12 = 1;
uParam0->f_13 = 359;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 14:
uParam0->f_14 = 2;
*uParam0 = { 1735.586f, 3294.531f, 40.1651f };
uParam0->f_3 = 194.9525f;
uParam0->f_12 = 2;
uParam0->f_13 = 359;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 15:
uParam0->f_14 = 3;
*uParam0 = { -846.27f, -1363.19f, 0.22f };
uParam0->f_3 = 108.78f;
uParam0->f_12 = 0;
uParam0->f_13 = 356;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 22);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 16:
uParam0->f_14 = 4;
*uParam0 = { -849.47f, -1354.99f, 0.24f };
uParam0->f_3 = 109.84f;
uParam0->f_12 = 1;
uParam0->f_13 = 356;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 22);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 17:
uParam0->f_14 = 5;
*uParam0 = { -852.47f, -1346.2f, 0.21f };
uParam0->f_3 = 108.76f;
uParam0->f_12 = 2;
uParam0->f_13 = 356;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 22);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 18:
uParam0->f_14 = 6;
*uParam0 = { -745.857f, -1433.904f, 4.0005f };
uParam0->f_12 = 0;
uParam0->f_13 = 360;
uParam0->f_15 = { -756.2952f, -1441.609f, 2.9184f };
uParam0->f_18 = { -738.0606f, -1423.068f, 8.2835f };
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 19:
uParam0->f_14 = 7;
*uParam0 = { -761.8486f, -1453.829f, 4.0005f };
uParam0->f_12 = 1;
uParam0->f_13 = 360;
uParam0->f_15 = { -772.8158f, -1459.957f, 3.2894f };
uParam0->f_18 = { -754.3353f, -1440.836f, 8.3334f };
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 20:
uParam0->f_14 = 8;
*uParam0 = { 1769.3f, 3244f, 41.1f };
uParam0->f_12 = 2;
uParam0->f_13 = 360;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
iVar0 = 1;
break;
case 21:
uParam0->f_14 = 9;
*uParam0 = { 192.7897f, -1020.539f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = 0;
uParam0->f_13 = 357;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 24);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
unk_0x191DDA30577F440A(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 22:
uParam0->f_14 = 10;
*uParam0 = { 192.7897f, -1020.539f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = 1;
uParam0->f_13 = 357;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 24);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
unk_0x191DDA30577F440A(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 23:
uParam0->f_14 = 11;
*uParam0 = { 192.7897f, -1020.539f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = 2;
uParam0->f_13 = 357;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 14);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 24);
unk_0x191DDA30577F440A(&(uParam0->f_9), 28);
unk_0x191DDA30577F440A(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 26:
case 27:
case 28:
iVar1 = (iParam1 - 26);
uParam0->f_14 = (12 + iVar1);
*uParam0 = { 196.2794f, -1020.479f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = (0 + iVar1);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 27);
unk_0x191DDA30577F440A(&(uParam0->f_9), 24);
unk_0x191DDA30577F440A(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 29:
case 30:
case 31:
iVar1 = (iParam1 - 29);
uParam0->f_14 = (15 + iVar1);
*uParam0 = { 199.8872f, -1020.048f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = (0 + iVar1);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 27);
unk_0x191DDA30577F440A(&(uParam0->f_9), 24);
unk_0x191DDA30577F440A(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 32:
case 33:
case 34:
iVar1 = (iParam1 - 32);
uParam0->f_14 = (18 + iVar1);
*uParam0 = { 203.6006f, -1019.776f, -99.98f };
uParam0->f_3 = 180f;
uParam0->f_4 = 0;
uParam0->f_12 = (0 + iVar1);
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
unk_0x191DDA30577F440A(&(uParam0->f_9), 7);
unk_0x191DDA30577F440A(&(uParam0->f_9), 27);
unk_0x191DDA30577F440A(&(uParam0->f_9), 24);
unk_0x191DDA30577F440A(&(uParam0->f_9), 29);
iVar0 = 1;
break;
case 24:
uParam0->f_14 = 21;
*uParam0 = { 0f, 0f, 0f };
uParam0->f_3 = 0f;
uParam0->f_4 = 0;
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 11);
unk_0x191DDA30577F440A(&(uParam0->f_9), 13);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
iVar0 = 1;
break;
case 25:
uParam0->f_14 = 22;
*uParam0 = { 723.2515f, -632.0496f, 27.1484f };
uParam0->f_3 = 12.9316f;
uParam0->f_4 = joaat("tailgater");
unk_0x191DDA30577F440A(&(uParam0->f_9), 10);
unk_0x191DDA30577F440A(&(uParam0->f_9), 11);
unk_0x191DDA30577F440A(&(uParam0->f_9), 13);
unk_0x191DDA30577F440A(&(uParam0->f_9), 12);
iVar0 = 1;
break;
case 35:
*uParam0 = { -51.23f, 3111.9f, 24.95f };
uParam0->f_3 = 46.78f;
uParam0->f_4 = joaat("proptrailer");
unk_0x191DDA30577F440A(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 36:
*uParam0 = { -55.7984f, -1096.586f, 25.4223f };
uParam0->f_3 = 308.0596f;
uParam0->f_4 = joaat("bjxl");
uParam0->f_10 = 126;
uParam0->f_11 = 126;
unk_0x191DDA30577F440A(&(uParam0->f_9), 9);
unk_0x191DDA30577F440A(&(uParam0->f_9), 13);
iVar0 = 1;
break;
case 37:
*uParam0 = { -2892.93f, 3192.37f, 11.66f };
uParam0->f_3 = -132.35f;
uParam0->f_4 = joaat("velum");
uParam0->f_10 = 157;
uParam0->f_11 = 157;
unk_0x191DDA30577F440A(&(uParam0->f_9), 9);
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
unk_0x191DDA30577F440A(&(uParam0->f_9), 13);
iVar0 = 1;
break;
case 38:
*uParam0 = { 1744.308f, 3270.673f, 40.2076f };
uParam0->f_3 = 125f;
uParam0->f_4 = joaat("cargobob3");
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
unk_0x191DDA30577F440A(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 39:
*uParam0 = { 1751.44f, 3322.643f, 42.1855f };
uParam0->f_3 = 268.134f;
uParam0->f_4 = joaat("submersible");
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
iVar0 = 1;
break;
case 41:
*uParam0 = { 1377.104f, -2076.2f, 52f };
uParam0->f_3 = 37.5f;
uParam0->f_4 = joaat("towtruck");
unk_0x191DDA30577F440A(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 40:
*uParam0 = { 1380.42f, -2072.77f, 51.7607f };
uParam0->f_3 = 37.5f;
uParam0->f_4 = joaat("trash");
unk_0x191DDA30577F440A(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 42:
*uParam0 = { 1359.389f, 3618.441f, 33.8907f };
uParam0->f_3 = 108.2337f;
uParam0->f_4 = joaat("barracks");
unk_0x191DDA30577F440A(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 43:
*uParam0 = { 693.1154f, -1018.155f, 21.6387f };
uParam0->f_3 = 177.6454f;
uParam0->f_4 = joaat("firetruk");
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
unk_0x191DDA30577F440A(&(uParam0->f_9), 8);
iVar0 = 1;
break;
case 44:
*uParam0 = { -73.6963f, 495.124f, 143.5226f };
uParam0->f_3 = 155.5994f;
uParam0->f_4 = joaat("vacca");
iVar0 = 1;
break;
case 45:
*uParam0 = { -67.6314f, 891.8266f, 234.5348f };
uParam0->f_3 = 294.993f;
uParam0->f_4 = joaat("surano");
iVar0 = 1;
break;
case 46:
*uParam0 = { 533.9048f, -169.2469f, 53.7005f };
uParam0->f_3 = 1.2998f;
uParam0->f_4 = joaat("tornado2");
iVar0 = 1;
break;
case 47:
*uParam0 = { -726.8914f, -408.6952f, 34.0416f };
uParam0->f_3 = 267.7392f;
uParam0->f_4 = joaat("superd");
iVar0 = 1;
break;
case 48:
*uParam0 = { -1321.519f, 261.3993f, 61.5709f };
uParam0->f_3 = 350.7697f;
uParam0->f_4 = joaat("double");
iVar0 = 1;
break;
case 49:
*uParam0 = { -1267.999f, 451.6463f, 93.7071f };
uParam0->f_3 = 48.9311f;
uParam0->f_4 = joaat("double");
iVar0 = 1;
break;
case 50:
*uParam0 = { -1062.076f, -226.7637f, 37.157f };
uParam0->f_3 = 234.2767f;
uParam0->f_4 = joaat("double");
iVar0 = 1;
break;
case 51:
*uParam0 = { 68.16914f, -1558.958f, 29.46904f };
uParam0->f_3 = 49.90575f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
unk_0x191DDA30577F440A(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 52:
*uParam0 = { 589.4399f, 2736.708f, 42.03316f };
uParam0->f_3 = -175.7105f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
unk_0x191DDA30577F440A(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 53:
*uParam0 = { -488.774f, -344.5721f, 34.36356f };
uParam0->f_3 = 82.4042f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
unk_0x191DDA30577F440A(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 54:
*uParam0 = { 288.8808f, -585.4728f, 43.15428f };
uParam0->f_3 = -20.80707f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
unk_0x191DDA30577F440A(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 55:
*uParam0 = { 304.8294f, -1383.674f, 31.67744f };
uParam0->f_3 = -41.11603f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
unk_0x191DDA30577F440A(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 56:
*uParam0 = { 1126.194f, -1481.486f, 34.7016f };
uParam0->f_3 = -91.43369f;
uParam0->f_4 = joaat("rumpo2");
uParam0->f_12 = 2;
unk_0x191DDA30577F440A(&(uParam0->f_9), 26);
iVar0 = 1;
break;
case 57:
*uParam0 = { -1598.36f, 5252.84f, 0f };
uParam0->f_3 = 28.14f;
uParam0->f_4 = joaat("submersible");
uParam0->f_13 = 308;
unk_0x191DDA30577F440A(&(uParam0->f_9), 2);
unk_0x191DDA30577F440A(&(uParam0->f_9), 30);
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 58:
*uParam0 = { -1602.62f, 5260.37f, 0.86f };
uParam0->f_3 = 25.32f;
uParam0->f_4 = joaat("dinghy");
uParam0->f_13 = 404;
unk_0x191DDA30577F440A(&(uParam0->f_9), 2);
unk_0x191DDA30577F440A(&(uParam0->f_9), 22);
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 59:
*uParam0 = { 2116.571f, 4763.279f, 40.1596f };
uParam0->f_3 = 198.723f;
uParam0->f_4 = joaat("bfinjection");
iVar0 = 1;
break;
case 60:
*uParam0 = { 1133.21f, 120.2f, 80.9f };
uParam0->f_3 = 134.4f;
if (func_298())
{
uParam0->f_4 = joaat("blimp2");
}
else
{
uParam0->f_4 = joaat("blimp");
}
uParam0->f_13 = 401;
unk_0x191DDA30577F440A(&(uParam0->f_9), 13);
unk_0x191DDA30577F440A(&(uParam0->f_9), 2);
unk_0x191DDA30577F440A(&(uParam0->f_9), 1);
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
iVar0 = 1;
break;
case 61:
*uParam0 = { -806.31f, -2679.65f, 13.9f };
uParam0->f_3 = 150.54f;
if (func_298())
{
uParam0->f_4 = joaat("blimp2");
}
else
{
uParam0->f_4 = joaat("blimp");
}
uParam0->f_13 = 401;
unk_0x191DDA30577F440A(&(uParam0->f_9), 13);
unk_0x191DDA30577F440A(&(uParam0->f_9), 2);
unk_0x191DDA30577F440A(&(uParam0->f_9), 1);
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
iVar0 = 1;
break;
case 62:
*uParam0 = { 1985.85f, 3828.96f, 31.98f };
uParam0->f_3 = -16.58f;
uParam0->f_4 = joaat("blazer3");
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 63:
*uParam0 = { 3870.75f, 4464.67f, 0f };
uParam0->f_3 = 0f;
uParam0->f_4 = joaat("submersible2");
uParam0->f_13 = 308;
unk_0x191DDA30577F440A(&(uParam0->f_9), 0);
unk_0x191DDA30577F440A(&(uParam0->f_9), 21);
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
unk_0x191DDA30577F440A(&(uParam0->f_9), 30);
iVar0 = 1;
break;
case 64:
*uParam0 = { 1257.729f, -2564.474f, 41.717f };
uParam0->f_3 = 284.5561f;
uParam0->f_4 = joaat("dukes2");
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 65:
*uParam0 = { 643.2823f, 3014.152f, 42.2733f };
uParam0->f_3 = 128.0554f;
uParam0->f_4 = joaat("dukes2");
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 66:
*uParam0 = { 38.9368f, 850.8677f, 196.3f };
uParam0->f_3 = 311.6813f;
uParam0->f_4 = joaat("dodo");
unk_0x191DDA30577F440A(&(uParam0->f_9), 30);
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
iVar0 = 1;
break;
case 67:
*uParam0 = { 1333.875f, 4262.226f, 30.78f };
uParam0->f_3 = 262.5293f;
uParam0->f_4 = joaat("dodo");
unk_0x191DDA30577F440A(&(uParam0->f_9), 30);
unk_0x191DDA30577F440A(&(uParam0->f_9), 23);
unk_0x191DDA30577F440A(&(uParam0->f_9), 6);
iVar0 = 1;
break;
}
if (unk_0x234B68AC2E35ED5A(uParam0->f_9, 10))
{
uParam0->f_4 = Global_112293.f_32747.f_69[uParam0->f_14 /*78*/].f_66;
if (iParam1 == 14)
{
if (((((uParam0->f_4 == joaat("miljet") || uParam0->f_4 == joaat("besra")) || uParam0->f_4 == joaat("luxor")) || uParam0->f_4 == joaat("shamal")) || uParam0->f_4 == joaat("titan")) || uParam0->f_4 == joaat("luxor2"))
{
*uParam0 = { 1678.8f, 3229.6f, 41.8f };
uParam0->f_3 = 106.0906f;
}
}
if (!func_15(Global_112293.f_32747.f_1864[uParam0->f_14 /*3*/], 0f, 0f, 0f, 0))
{
*uParam0 = { Global_112293.f_32747.f_1864[uParam0->f_14 /*3*/] };
}
if (Global_112293.f_32747.f_1934[uParam0->f_14] != -1f)
{
uParam0->f_3 = Global_112293.f_32747.f_1934[uParam0->f_14];
}
}
if (unk_0x234B68AC2E35ED5A(uParam0->f_9, 19))
{
if (!func_15(Global_112293.f_2361.f_539.f_3588[1 /*10*/][uParam0->f_12 /*3*/], 0f, 0f, 0f, 0))
{
*uParam0 = { Global_112293.f_2361.f_539.f_3588[1 /*10*/][uParam0->f_12 /*3*/] };
uParam0->f_3 = Global_112293.f_2361.f_539.f_3609[1 /*4*/][uParam0->f_12];
}
}
else if (unk_0x234B68AC2E35ED5A(uParam0->f_9, 20))
{
if (!func_15(Global_112293.f_2361.f_539.f_3588[0 /*10*/][uParam0->f_12 /*3*/], 0f, 0f, 0f, 0))
{
*uParam0 = { Global_112293.f_2361.f_539.f_3588[0 /*10*/][uParam0->f_12 /*3*/] };
uParam0->f_3 = Global_112293.f_2361.f_539.f_3609[0 /*4*/][uParam0->f_12];
}
}
return iVar0;
}
int func_318(int iParam0, int iParam1)
{
struct<82> Var0;
if (func_28(iParam0))
{
Var0.f_11 = 12;
Var0.f_31 = 49;
Var0.f_81 = 2;
func_319(iParam0, &Var0, iParam1);
return Var0;
}
else if (iParam0 != 145)
{
}
return 0;
}
void func_319(int iParam0, var uParam1, int iParam2)
{
int iVar0;
uParam1->f_88 = 1;
uParam1->f_84 = 255;
uParam1->f_85 = 255;
uParam1->f_86 = 255;
uParam1->f_97 = 1;
uParam1->f_3 = 1000;
uParam1->f_1 = 0;
switch (iParam0)
{
case 0:
iVar0 = joaat("tailgater");
if (Global_112293.f_9083.f_99.f_58[128] && !Global_112293.f_9083.f_99.f_58[131])
{
iVar0 = joaat("premier");
}
switch (iVar0)
{
case joaat("tailgater"):
*uParam1 = iVar0;
uParam1->f_2 = 3f;
uParam1->f_4 = 0;
uParam1->f_9 = 1;
uParam1->f_11[0] = 1;
StringCopy(&(uParam1->f_27), "5MDS003", 16);
break;
case joaat("premier"):
*uParam1 = iVar0;
uParam1->f_2 = 14.9f;
uParam1->f_5 = 43;
uParam1->f_6 = 43;
uParam1->f_7 = 0;
uParam1->f_8 = 156;
uParam1->f_9 = 0;
StringCopy(&(uParam1->f_27), "880HS955", 16);
break;
}
break;
case 2:
iVar0 = joaat("bodhi2");
switch (iVar0)
{
case joaat("bodhi2"):
*uParam1 = iVar0;
uParam1->f_2 = 14f;
uParam1->f_5 = 32;
uParam1->f_6 = 0;
uParam1->f_7 = 0;
uParam1->f_8 = 156;
StringCopy(&(uParam1->f_27), "BETTY 32", 16);
if (Global_112293.f_9083.f_99.f_58[119])
{
uParam1->f_11[1] = 1;
}
break;
}
break;
case 1:
if (iParam2 == 1)
{
iVar0 = joaat("buffalo2");
}
else if (iParam2 == 2)
{
iVar0 = joaat("bagger");
}
else if (Global_112293.f_9083.f_99.f_58[118])
{
iVar0 = joaat("bagger");
}
else
{
iVar0 = joaat("buffalo2");
}
switch (iVar0)
{
case joaat("bagger"):
*uParam1 = iVar0;
uParam1->f_2 = 6f;
uParam1->f_5 = 53;
uParam1->f_6 = 0;
uParam1->f_7 = 59;
uParam1->f_8 = 156;
StringCopy(&(uParam1->f_27), "FC88", 16);
break;
case joaat("buffalo2"):
*uParam1 = iVar0;
uParam1->f_2 = 0f;
uParam1->f_5 = 111;
uParam1->f_6 = 111;
uParam1->f_7 = 0;
uParam1->f_8 = 156;
uParam1->f_10 = 1;
StringCopy(&(uParam1->f_27), "FC1988", 16);
uParam1->f_11[0] = 1;
uParam1->f_11[1] = 1;
uParam1->f_11[2] = 1;
uParam1->f_11[3] = 1;
uParam1->f_11[4] = 1;
uParam1->f_11[5] = 1;
uParam1->f_11[6] = 1;
uParam1->f_11[7] = 1;
uParam1->f_11[8] = 1;
break;
}
break;
default:
break;
}
}
void func_320(int iParam0, var uParam1, struct<3> Param2, var uParam5, int iParam6)
{
if (func_317(&(Global_76066.f_555[0 /*21*/]), iParam0))
{
if (unk_0x234B68AC2E35ED5A(Global_76066.f_555[0 /*21*/].f_9, 10))
{
func_325(iParam0);
func_324(uParam1, &(Global_112293.f_32747.f_69[Global_76066.f_555[0 /*21*/].f_14 /*78*/]));
if (unk_0x234B68AC2E35ED5A(Global_76066.f_555[0 /*21*/].f_9, 11))
{
Global_112293.f_32747.f_1864[Global_76066.f_555[0 /*21*/].f_14 /*3*/] = { Param2 };
Global_112293.f_32747.f_1934[Global_76066.f_555[0 /*21*/].f_14] = uParam5;
}
else
{
Global_112293.f_32747.f_1864[Global_76066.f_555[0 /*21*/].f_14 /*3*/] = { 0f, 0f, 0f };
Global_112293.f_32747.f_1934[Global_76066.f_555[0 /*21*/].f_14] = -1f;
}
Global_112293.f_32747.f_1958[Global_76066.f_555[0 /*21*/].f_14] = iParam6 + 1;
func_321(iParam0, 1);
}
}
}
void func_321(int iParam0, bool bParam1)
{
if (iParam0 == -1)
{
return;
}
if (bParam1)
{
if (!func_323(iParam0, 0))
{
func_322(iParam0, 1, 0);
func_322(iParam0, 2, 0);
func_322(iParam0, 3, 0);
func_322(iParam0, 4, 0);
func_322(iParam0, 0, 1);
Global_76066[iParam0] = 1;
}
}
else
{
func_322(iParam0, 0, 0);
}
}
void func_322(int iParam0, int iParam1, bool bParam2)
{
if (iParam0 == -1)
{
return;
}
if (bParam2)
{
unk_0x191DDA30577F440A(&(Global_112293.f_32747[iParam0]), iParam1);
}
else
{
unk_0xC664C0067EEAB8D1(&(Global_112293.f_32747[iParam0]), iParam1);
}
}
bool func_323(int iParam0, int iParam1)
{
if (iParam0 == -1)
{
return 0;
}
return unk_0x234B68AC2E35ED5A(Global_112293.f_32747[iParam0], iParam1);
}
void func_324(var uParam0, var uParam1)
{
uParam1->f_66 = uParam0->f_66;
*uParam1 = *uParam0;
uParam1->f_1 = { uParam0->f_1 };
uParam1->f_5 = uParam0->f_5;
uParam1->f_6 = uParam0->f_6;
uParam1->f_7 = uParam0->f_7;
uParam1->f_8 = uParam0->f_8;
uParam1->f_9 = { uParam0->f_9 };
uParam1->f_59 = { uParam0->f_59 };
uParam1->f_62 = uParam0->f_62;
uParam1->f_63 = uParam0->f_63;
uParam1->f_64 = uParam0->f_64;
uParam1->f_65 = uParam0->f_65;
uParam1->f_77 = uParam0->f_77;
uParam1->f_67 = uParam0->f_67;
uParam1->f_69 = uParam0->f_69;
uParam1->f_68 = uParam0->f_68;
uParam1->f_71 = uParam0->f_71;
uParam1->f_72 = uParam0->f_72;
uParam1->f_73 = uParam0->f_73;
uParam1->f_74 = uParam0->f_74;
uParam1->f_75 = uParam0->f_75;
uParam1->f_76 = uParam0->f_76;
}
void func_325(int iParam0)
{
if (iParam0 == -1)
{
return;
}
if (func_317(&(Global_76066.f_555[0 /*21*/]), iParam0))
{
if (unk_0x419E13582192CFEA(Global_76066.f_139[iParam0]))
{
unk_0x4985CD0720AFD468(Global_76066.f_139[iParam0], 1, 1);
unk_0x795957CD3A0042C8(&(Global_76066.f_139[iParam0]));
Global_76066.f_139[iParam0] = 0;
}
if (unk_0x234B68AC2E35ED5A(Global_76066.f_555[0 /*21*/].f_9, 13))
{
func_321(iParam0, 0);
}
}
}
int func_326(int iParam0)
{
int iVar0;
if (!unk_0x419E13582192CFEA(iParam0))
{
return 145;
}
if (!unk_0xBFCE58B2B3249999(iParam0, 0))
{
return 145;
}
iVar0 = 0;
while (iVar0 < 9)
{
if (unk_0x419E13582192CFEA(Global_96701[iVar0]))
{
if (Global_96701[iVar0] == iParam0)
{
return Global_96711[iVar0];
}
}
iVar0++;
}
return 145;
}
void func_327(int iParam0, var uParam1)
{
int iVar0;
if (unk_0xBFCE58B2B3249999(iParam0, 0))
{
func_331(uParam1);
uParam1->f_66 = unk_0x6471F4759775FCA4(iParam0);
StringCopy(&(uParam1->f_1), unk_0x0B676D4511ABB729(iParam0), 16);
*uParam1 = unk_0x8F77FF37B3B66EE9(iParam0);
unk_0x63316D59F2B56D9A(iParam0, &(uParam1->f_5), &(uParam1->f_6));
unk_0x39A17B456BB9800A(iParam0, &(uParam1->f_7), &(uParam1->f_8));
unk_0xDCC81D0196B6BB05(iParam0, &(uParam1->f_62), &(uParam1->f_63), &(uParam1->f_64));
uParam1->f_65 = unk_0x3763A95FD16BF2D0(iParam0);
uParam1->f_67 = unk_0x91A6237658B4DA68(iParam0);
uParam1->f_69 = unk_0x1D74385CEC17951D(iParam0);
uParam1->f_70 = unk_0xAFD2714E8B5AEB9F(iParam0);
unk_0x67CF1352CC692A08(iParam0, &(uParam1->f_71), &(uParam1->f_72), &(uParam1->f_73));
unk_0x0CC8B4C581022F66(iParam0, &(uParam1->f_74), &(uParam1->f_75), &(uParam1->f_76));
if (unk_0x0602C700974DF696(iParam0, 2))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 28);
}
if (unk_0x0602C700974DF696(iParam0, 3))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 29);
}
if (unk_0x0602C700974DF696(iParam0, 0))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 30);
}
if (unk_0x0602C700974DF696(iParam0, 1))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 31);
}
if (uParam1->f_65 == -1 && !func_330(uParam1->f_66))
{
uParam1->f_65 = 0;
}
if (unk_0xCBD5BF9FD895F81F(iParam0, 0))
{
uParam1->f_68 = unk_0x334291A8490E5BCB(iParam0);
}
if (unk_0x48E10529AEAE00F9(uParam1->f_66))
{
if (unk_0x4D79903AC2C62A29(iParam0))
{
switch (unk_0xC504A6173BF90791(iParam0))
{
case 3:
case 0:
unk_0xC664C0067EEAB8D1(&(uParam1->f_77), 23);
unk_0x191DDA30577F440A(&(uParam1->f_77), 22);
break;
case 4:
case 1:
unk_0xC664C0067EEAB8D1(&(uParam1->f_77), 23);
unk_0xC664C0067EEAB8D1(&(uParam1->f_77), 22);
break;
case 5:
unk_0x191DDA30577F440A(&(uParam1->f_77), 23);
break;
}
}
else
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 23);
}
}
if (!unk_0x7EB56EF7F2EC63A6(iParam0))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 9);
}
if (unk_0x44CD355F587F467C(iParam0))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 10);
}
if (unk_0x06B95C5D3415375D(iParam0))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 13);
unk_0xD1C8CE12A38AA6D0(iParam0, &(uParam1->f_71), &(uParam1->f_72), &(uParam1->f_73));
}
if (unk_0x89FF0171FDDB2246(iParam0))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 12);
}
func_329(&iParam0, &(uParam1->f_9), &(uParam1->f_59));
iVar0 = 0;
while (iVar0 <= 11)
{
if (unk_0xE3C9546BB1ECEC04(iParam0, iVar0 + 1))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), func_328(iVar0 + 1));
}
iVar0++;
}
if (unk_0x88CF23F322C9687A(iParam0, 0))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 11);
}
else
{
unk_0xC664C0067EEAB8D1(&(uParam1->f_77), 11);
}
if (unk_0x5B38E054B758C032(iParam0, "IgnoredByQuickSave") && unk_0xCDB2D643EC18E75E(iParam0, "IgnoredByQuickSave"))
{
unk_0x191DDA30577F440A(&(uParam1->f_77), 27);
}
else
{
unk_0xC664C0067EEAB8D1(&(uParam1->f_77), 27);
}
}
}
int func_328(int iParam0)
{
switch (iParam0)
{
case 1:
return 0;
break;
case 2:
return 1;
break;
case 3:
return 2;
break;
case 4:
return 3;
break;
case 5:
return 4;
break;
case 6:
return 5;
break;
case 7:
return 6;
break;
case 8:
return 7;
break;
case 9:
return 8;
break;
case 10:
return 24;
break;
case 11:
return 25;
break;
case 12:
return 26;
break;
}
return 0;
}
int func_329(int iParam0, var uParam1, var uParam2)
{
int iVar0;
int iVar1;
if (!unk_0xBFCE58B2B3249999(*iParam0, 0))
{
return 0;
}
if (unk_0xCF1FE5DEA3E2E135(*iParam0) == 0)
{
return 0;
}
iVar0 = 0;
while (iVar0 < *uParam1)
{
iVar1 = iVar0;
if ((((iVar1 == 17 || iVar1 == 18) || iVar1 == 19) || iVar1 == 20) || iVar1 == 21)
{
(*uParam1)[iVar0] = 0;
if (unk_0x0350660BE3973FF3(*iParam0, iVar1))
{
(*uParam1)[iVar0] = 1;
}
}
else if (iVar1 == 22)
{
if (unk_0x0350660BE3973FF3(*iParam0, iVar1))
{
switch (unk_0x64CF0B1FED5D2D23(*iParam0))
{
case 255:
(*uParam1)[iVar0] = 1;
break;
case 0:
(*uParam1)[iVar0] = 2;
break;
case 1:
(*uParam1)[iVar0] = 3;
break;
case 2:
(*uParam1)[iVar0] = 4;
break;
case 3:
(*uParam1)[iVar0] = 5;
break;
case 4:
(*uParam1)[iVar0] = 6;
break;
case 5:
(*uParam1)[iVar0] = 7;
break;
case 6:
(*uParam1)[iVar0] = 8;
break;
case 7:
(*uParam1)[iVar0] = 9;
break;
case 8:
(*uParam1)[iVar0] = 10;
break;
case 9:
(*uParam1)[iVar0] = 11;
break;
case 10:
(*uParam1)[iVar0] = 12;
break;
case 11:
(*uParam1)[iVar0] = 13;
break;
case 12:
(*uParam1)[iVar0] = 14;
break;
case 13:
(*uParam1)[iVar0] = 15;
break;
}
}
else
{
(*uParam1)[iVar0] = 0;
}
}
else
{
(*uParam1)[iVar0] = unk_0xB51972B58BF40F96(*iParam0, iVar0) + 1;
if (iVar0 == 23)
{
(*uParam2)[0] = unk_0xB7A74982A8F639B9(*iParam0, iVar0);
}
else if (iVar0 == 24)
{
(*uParam2)[1] = unk_0xB7A74982A8F639B9(*iParam0, iVar0);
}
}
iVar0++;
}
return 1;
}
int func_330(int iParam0)
{
switch (iParam0)
{
case joaat("granger"):
case joaat("visione"):
return 1;
default:
}
return 0;
}
void func_331(var uParam0)
{
int iVar0;
uParam0->f_66 = 0;
uParam0->f_77 = 0;
uParam0->f_65 = 0;
uParam0->f_62 = 0;
uParam0->f_63 = 0;
uParam0->f_64 = 0;
uParam0->f_74 = 0;
uParam0->f_75 = 0;
uParam0->f_76 = 0;
*uParam0 = 0;
StringCopy(&(uParam0->f_1), "", 16);
uParam0->f_5 = 0;
uParam0->f_6 = 0;
uParam0->f_7 = 0;
uParam0->f_8 = 0;
iVar0 = 0;
while (iVar0 < 49)
{
uParam0->f_9[iVar0] = 0;
iVar0++;
}
iVar0 = 0;
while (iVar0 < 2)
{
uParam0->f_59[iVar0] = 0;
iVar0++;
}
uParam0->f_67 = 0;
uParam0->f_68 = 0;
uParam0->f_69 = 0;
uParam0->f_70 = 1;
uParam0->f_71 = 0;
uParam0->f_72 = 0;
uParam0->f_73 = 0;
}
void func_332(int iParam0)
{
if (iParam0 != 24 && iParam0 != 25)
{
}
func_325(iParam0);
func_321(iParam0, 0);
}
void func_333()
{
func_336();
func_334();
}
void func_334()
{
if (!iLocal_831)
{
if (func_37(iLocal_874))
{
if (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), iLocal_874, 0))
{
func_66(iLocal_874, -1);
func_65(iLocal_874, 318);
iLocal_831 = 1;
}
}
}
if (!iLocal_832)
{
if (unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) > 0)
{
func_335(320, 0);
iLocal_832 = 1;
}
}
else if (unk_0x6C9038EC46DA62DE(unk_0x1146A9AE09CE2B14()) == 0)
{
func_64(0, 320);
iLocal_832 = 0;
}
}
void func_335(int iParam0, bool bParam1)
{
int iVar0;
Global_62108 = iParam0;
if (!Global_62106)
{
Global_62106 = 1;
}
if (bParam1)
{
iVar0 = 0;
while (iVar0 < Global_74193)
{
if (Global_74194[iVar0 /*9*/] == iParam0)
{
Global_74194[iVar0 /*9*/].f_1 = 0;
}
iVar0++;
}
}
}
void func_336()
{
}
void func_337()
{
if (!bLocal_28 && iLocal_683 != 5)
{
if (iLocal_683 > 0)
{
func_338();
}
}
}
void func_338()
{
float fVar0;
int iVar1;
fVar0 = 600f;
if (!func_37(iLocal_874))
{
if (!func_37(uLocal_875) && !func_37(Local_868))
{
func_340(1);
return;
}
if (func_37(Local_868) && !func_157(unk_0x7D2B9E6A64637269(), Local_868, fVar0, 1))
{
func_340(2);
}
}
else
{
iVar1 = 0;
if (!func_157(unk_0x7D2B9E6A64637269(), iLocal_874, fVar0, 1))
{
iVar1++;
}
if (func_37(uLocal_875))
{
if (!func_157(unk_0x7D2B9E6A64637269(), uLocal_875, fVar0, 1))
{
iVar1++;
}
}
else
{
iVar1++;
}
if (func_37(Local_868))
{
if (!func_157(unk_0x7D2B9E6A64637269(), Local_868, fVar0, 1))
{
iVar1++;
}
}
else
{
iVar1++;
}
if (iVar1 >= 3)
{
func_340(2);
return;
}
iVar1 = 0;
if (func_339(iLocal_874))
{
iVar1++;
}
if (func_37(uLocal_875))
{
if (func_339(uLocal_875))
{
iVar1++;
}
}
else
{
iVar1++;
}
if (func_37(Local_868))
{
if (func_339(Local_868))
{
iVar1++;
}
}
else
{
iVar1++;
}
if (iVar1 >= 3)
{
func_340(3);
return;
}
}
}
int func_339(var uParam0)
{
if (func_37(uParam0))
{
if (((unk_0x0D628BB90DA6214A(uParam0, 0, 7000) || unk_0x0D628BB90DA6214A(uParam0, 3, 30000)) || unk_0x0D628BB90DA6214A(uParam0, 2, 30000)) || unk_0x0D628BB90DA6214A(uParam0, 1, 40000))
{
return 1;
}
else
{
return 0;
}
}
return 0;
}
void func_340(int iParam0)
{
unk_0x1036762BD3781C84();
func_61();
switch (iParam0)
{
case 0:
break;
case 1:
sLocal_818 = "PRA_FWRECK";
break;
case 2:
sLocal_818 = "PRA_FFAR";
break;
case 3:
sLocal_818 = "PRA_FSTUCK";
break;
}
iLocal_683 = 5;
iLocal_684 = 0;
}
int func_341(int iParam0)
{
if (func_10(iParam0))
{
if (!unk_0xECEC7528A52B4EE8(iParam0))
{
return 1;
}
}
return 0;
}
void func_342()
{
if (!func_102(36))
{
func_343(21, 0, 0);
}
}
void func_343(int iParam0, bool bParam1, int iParam2)
{
if (bParam1)
{
if (!func_355(iParam0, 0, 0))
{
if (iParam2 && Global_99422.f_18[iParam0])
{
if (func_354(iParam0) == 3 && !func_353(iParam0))
{
func_352(iParam0);
func_351(iParam0, 0, 0);
func_345(iParam0, 1, 0);
func_344(iParam0);
}
else
{
func_351(iParam0, 1, 0);
func_344(iParam0);
}
}
else
{
func_351(iParam0, 0, 0);
func_345(iParam0, 1, 0);
func_344(iParam0);
}
}
else
{
func_345(iParam0, 1, 0);
func_344(iParam0);
}
}
else if (func_355(iParam0, 0, 0))
{
func_345(iParam0, 0, 0);
func_345(iParam0, 1, 0);
func_344(iParam0);
}
}
void func_344(int iParam0)
{
Global_99422.f_190[iParam0] = 1;
Global_99422.f_189 = 1;
}
void func_345(int iParam0, int iParam1, bool bParam2)
{
var uVar0;
if (iParam0 == -1)
{
return;
}
if (bParam2)
{
unk_0xC664C0067EEAB8D1(&(Global_99422.f_1378[iParam0]), iParam1);
}
else if (unk_0x02BFF15CAA701972())
{
if (func_350() == 0)
{
uVar0 = func_348(func_349(iParam0), -1, 0);
unk_0xC664C0067EEAB8D1(&uVar0, iParam1);
func_346(func_349(iParam0), uVar0, -1, 1, 0);
}
}
else
{
unk_0xC664C0067EEAB8D1(&(Global_112293.f_668[iParam0]), iParam1);
}
}
void func_346(int iParam0, var uParam1, int iParam2, int iParam3, bool bParam4)
{
int iVar0;
if (bParam4)
{
}
iVar0 = Global_2555716[iParam0 /*3*/][func_347(iParam2)];
if (iVar0 != 0)
{
unk_0xAC4FD27671081628(iVar0, uParam1, iParam3);
}
}
int func_347(var uParam0)
{
int iVar0;
int iVar1;
iVar0 = uParam0;
if (iVar0 == -1)
{
iVar1 = func_47();
if (iVar1 > -1)
{
Global_2555428 = 0;
iVar0 = iVar1;
}
else
{
iVar0 = 0;
Global_2555428 = 1;
}
}
return iVar0;
}
int func_348(int iParam0, int iParam1, int iParam2)
{
var uVar0;
var uVar1;
if (iParam0 != 12074)
{
if (iParam2 == 0)
{
}
uVar0 = Global_2555716[iParam0 /*3*/][func_347(iParam1)];
if (unk_0xD885BEFA31A18D47(uVar0, &uVar1, -1))
{
return uVar1;
}
}
return 0;
}
int func_349(int iParam0)
{
switch (iParam0)
{
case 0:
return 828;
break;
case 1:
return 829;
break;
case 2:
return 830;
break;
case 3:
return 831;
break;
case 4:
return 832;
break;
case 5:
return 833;
break;
case 6:
return 834;
break;
case 7:
return 835;
break;
case 8:
return 836;
break;
case 9:
return 837;
break;
case 10:
return 838;
break;
case 11:
return 839;
break;
case 12:
return 840;
break;
case 13:
return 841;
break;
case 14:
return 842;
break;
case 15:
return 844;
break;
case 16:
return 845;
break;
case 17:
return 846;
break;
case 18:
return 847;
break;
case 19:
return 848;
break;
case 20:
return 849;
break;
case 21:
return 850;
break;
case 22:
return 851;
break;
case 23:
return 852;
break;
case 24:
return 853;
break;
case 25:
return 854;
break;
case 26:
return 855;
break;
case 27:
return 856;
break;
case 28:
return 857;
break;
case 29:
return 858;
break;
case 30:
return 859;
break;
case 31:
return 860;
break;
case 32:
return 861;
break;
case 33:
return 862;
break;
case 34:
return 863;
break;
case 35:
return 864;
break;
case 36:
return 865;
break;
case 37:
return 866;
break;
case 38:
return 867;
break;
case 39:
return 868;
break;
case 40:
return 872;
break;
case 41:
return 873;
break;
case 42:
return 874;
break;
case 43:
return 875;
break;
case 44:
return 10402;
break;
case 45:
return 3810;
break;
case 46:
return 5385;
break;
case 47:
return 6157;
break;
case 48:
return 7234;
break;
case 49:
return 7880;
break;
case 52:
return 8916;
break;
case 50:
return 8267;
break;
case 51:
return 8269;
break;
case 53:
return 9556;
break;
case 54:
return 9632;
break;
case 55:
return 9847;
break;
default:
break;
}
return 12074;
}
int func_350()
{
return Global_31345;
}
void func_351(int iParam0, int iParam1, bool bParam2)
{
var uVar0;
if (iParam0 == -1)
{
return;
}
if (bParam2)
{
unk_0x191DDA30577F440A(&(Global_99422.f_1378[iParam0]), iParam1);
}
else if (unk_0x02BFF15CAA701972())
{
if (func_350() == 0)
{
uVar0 = func_348(func_349(iParam0), -1, 0);
unk_0x191DDA30577F440A(&uVar0, iParam1);
func_346(func_349(iParam0), uVar0, -1, 1, 0);
}
}
else
{
unk_0x191DDA30577F440A(&(Global_112293.f_668[iParam0]), iParam1);
}
}
void func_352(int iParam0)
{
if (Global_99422.f_18[iParam0])
{
func_351(iParam0, 10, 1);
func_351(iParam0, 19, 1);
}
}
bool func_353(int iParam0)
{
return func_355(iParam0, 5, 1);
}
int func_354(int iParam0)
{
switch (iParam0)
{
case -1:
return 6;
break;
case 0:
return 0;
break;
case 1:
return 0;
break;
case 2:
return 0;
break;
case 3:
return 0;
break;
case 4:
return 0;
break;
case 5:
return 0;
break;
case 6:
return 0;
break;
case 50:
return 0;
break;
case 7:
return 1;
break;
case 8:
return 1;
break;
case 9:
return 1;
break;
case 10:
return 1;
break;
case 11:
return 1;
break;
case 12:
return 1;
break;
case 13:
return 1;
break;
case 14:
return 1;
break;
case 15:
return 1;
break;
case 16:
return 1;
break;
case 17:
return 1;
break;
case 18:
return 1;
break;
case 19:
return 1;
break;
case 20:
return 1;
break;
case 21:
return 1;
break;
case 22:
return 2;
break;
case 23:
return 2;
break;
case 24:
return 2;
break;
case 25:
return 2;
break;
case 26:
return 2;
break;
case 27:
return 2;
break;
case 28:
return 3;
break;
case 29:
return 3;
break;
case 30:
return 3;
break;
case 31:
return 3;
break;
case 32:
return 3;
break;
case 33:
return 3;
break;
case 34:
return 3;
break;
case 35:
return 3;
break;
case 36:
return 3;
break;
case 37:
return 3;
break;
case 38:
return 3;
break;
case 39:
return 4;
break;
case 40:
return 4;
break;
case 41:
return 4;
break;
case 42:
return 4;
break;
case 43:
return 4;
break;
case 44:
return 4;
break;
case 45:
return 5;
break;
case 46:
return 3;
break;
case 47:
return 3;
break;
case 48:
return 3;
break;
case 49:
return 3;
break;
case 52:
return 3;
break;
case 51:
return 1;
break;
case 53:
return 3;
break;
case 54:
return 2;
break;
case 55:
return 1;
break;
}
return 6;
}
int func_355(int iParam0, int iParam1, bool bParam2)
{
if (iParam0 == -1)
{
return 0;
}
if (bParam2)
{
return unk_0x234B68AC2E35ED5A(Global_99422.f_1378[iParam0], iParam1);
}
else if (unk_0x02BFF15CAA701972())
{
if (func_350() == 0)
{
return unk_0x234B68AC2E35ED5A(func_348(func_349(iParam0), -1, 0), iParam1);
}
}
else
{
return unk_0x234B68AC2E35ED5A(Global_112293.f_668[iParam0], iParam1);
}
return 0;
}
void func_356(struct<3> Param0, float fParam3, int iParam4, int iParam5)
{
if (func_357())
{
unk_0x87F1904AB605184A(0);
unk_0xC664C0067EEAB8D1(&(Global_99370.f_20), 2);
unk_0x543F5B2D3F90CA6D(1);
if (unk_0xCAD1755E530A6012(unk_0x1146A9AE09CE2B14()))
{
unk_0xF99B8860747709DD(unk_0x1146A9AE09CE2B14(), 0, 0);
}
Global_99366 = { Param0 };
Global_99369 = fParam3;
Global_99365 = 1;
if (iParam4 == 1)
{
unk_0x191DDA30577F440A(&(Global_99370.f_20), 14);
}
else
{
unk_0xC664C0067EEAB8D1(&(Global_99370.f_20), 14);
}
if (iParam5 == 1)
{
unk_0x191DDA30577F440A(&(Global_99370.f_20), 24);
}
else
{
unk_0xC664C0067EEAB8D1(&(Global_99370.f_20), 24);
}
func_280(1);
}
}
int func_357()
{
if (Global_99370 == 10 || Global_99370 == 9)
{
return 1;
}
return 0;
}
void func_358()
{
func_373();
func_371();
func_364();
func_361();
func_359();
}
void func_359()
{
iLocal_1048[0] = 0;
iLocal_1048[1] = 0;
iLocal_1048[2] = 0;
Local_688[0 /*8*/] = { func_360("FP1_WANTM", "FP1_LOSTM", "FP1_THEREM", "FP1_CHATFM", "", "FP1_CHATTM") };
Local_688[1 /*8*/] = { func_360("FP1_WANTT", "FP1_LOSTT", "FP1_THERET", "FP1_CHATFM", "FP1_CHATFT", "") };
Local_688[2 /*8*/] = { func_360("FP1_WANTF", "FP1_LOSTF", "FP1_THEREF", "", "FP1_CHATFT", "FP1_CHATTM") };
}
struct<8> func_360(char* sParam0, char* sParam1, char* sParam2, char* sParam3, char* sParam4, char* sParam5)
{
struct<8> Var0;
Var0 = 6;
Var0[0] = sParam0;
Var0[1] = sParam1;
Var0[5] = sParam2;
Var0[2] = sParam3;
Var0[3] = sParam4;
Var0[4] = sParam5;
return Var0;
}
void func_361()
{
Local_134[0 /*25*/] = { func_363(1203.146f, -337.3543f, 67.9314f, 1245.118f, -348.5059f, 68.2099f, 253.1908f, 0) };
func_362(&(Local_134[0 /*25*/]), Local_824, 0, 15f, 5f, 270f, 3, 1192.006f, -631.4703f, 61.6972f, 10f, 10f, 5f);
Local_134[1 /*25*/] = { func_363(1215.084f, -339.3139f, 68.1323f, 964.9214f, -555.212f, 58.0211f, 39.645f, 0) };
func_362(&(Local_134[1 /*25*/]), Local_824, 0, 15f, 10f, 270f, 3, 1103.29f, -764.532f, 56.633f, 10f, 10f, 5f);
Local_134[2 /*25*/] = { func_363(1179.533f, -361.3286f, 67.4559f, 929.8701f, -619.4534f, 56.4632f, 164.3631f, 0) };
func_362(&(Local_134[2 /*25*/]), Local_824, 0, 15f, 10f, 270f, 3, 933.3745f, -615.9453f, 56.3041f, 10f, 10f, 5f);
Local_134[3 /*25*/] = { func_363(1107.674f, -364.0569f, 65.9581f, 1099.266f, -775.0809f, 57.3525f, 178.2038f, 0) };
func_362(&(Local_134[3 /*25*/]), Local_824, 0, 15f, 2f, 270f, 3, 1062.149f, -479.4801f, 62.9454f, 10f, 10f, 5f);
Local_134[4 /*25*/] = { func_363(1069.279f, -393.5795f, 66.0262f, 1065.364f, -389.9561f, 66.1504f, 220.1611f, 0) };
func_362(&(Local_134[4 /*25*/]), Local_824, 0, 5f, 30f, 128.1732f, 3, 1069.718f, -393.9912f, 66.0261f, 10f, 10f, 5f);
Local_134[5 /*25*/] = { func_363(1031.673f, -424.599f, 64.5439f, 1027.179f, -420.6656f, 64.6268f, 178.2038f, joaat("p_binbag_01_s")) };
func_362(&(Local_134[5 /*25*/]), 1028.201f, -428.3677f, 64.3571f, 1, 15f, 2f, 128.3915f, 1, 1027.179f, -420.6656f, 64.6268f, 10f, 10f, 5f);
Local_134[6 /*25*/] = { func_363(942.1528f, -488.8956f, 59.3129f, 932.0198f, -489.3886f, 58.9212f, 202.5785f, joaat("p_binbag_01_s")) };
func_362(&(Local_134[6 /*25*/]), 930.7186f, -494.9253f, 58.616f, 1, 15f, 2f, 119.6518f, 1, 952.9781f, -482.5082f, 60.0003f, 10f, 10f, 5f);
Local_134[7 /*25*/] = { func_363(868.2734f, -529.5473f, 56.2071f, 865.0042f, -522.4746f, 56.3363f, 241.9711f, joaat("p_binbag_01_s")) };
func_362(&(Local_134[7 /*25*/]), 865.2349f, -535.8759f, 56.1574f, 1, 15f, 2f, 162.7219f, 1, 1062.149f, -479.4801f, 62.9454f, 10f, 10f, 5f);
Local_134[8 /*25*/] = { func_363(874.8076f, -571.2073f, 56.2987f, 983.125f, -541.9902f, 58.5929f, 49.7653f, 0) };
func_362(&(Local_134[8 /*25*/]), Local_824, 0, 15f, 2f, 270f, 3, 1062.149f, -479.4801f, 62.9454f, 10f, 10f, 5f);
Local_134[9 /*25*/] = { func_363(931.5218f, -614.2144f, 56.3119f, 928.6471f, -620.711f, 56.4611f, -108.06f, joaat("p_binbag_01_s")) };
func_362(&(Local_134[9 /*25*/]), 940.4086f, -622.1787f, 56.3003f, 1, 15f, 2f, 228.1176f, 1, 918.6716f, -602.9258f, 56.3395f, 10f, 10f, 5f);
Local_134[10 /*25*/] = { func_363(964.9758f, -645.9614f, 56.4465f, 927.1033f, -575.4162f, 56.5329f, 55.9317f, 0) };
func_362(&(Local_134[10 /*25*/]), Local_824, 0, 15f, 2f, 270f, 3, 1062.149f, -479.4801f, 62.9454f, 10f, 10f, 5f);
Local_134[11 /*25*/] = { func_363(983.4438f, -683.1442f, 56.4087f, 929.3757f, -618.9091f, 56.4612f, 181.1844f, 0) };
func_362(&(Local_134[11 /*25*/]), Local_824, 0, 15f, 2f, 270f, 3, 1149.136f, -981.231f, 45.0495f, 10f, 10f, 5f);
Local_134[12 /*25*/] = { func_363(1016.261f, -731.546f, 56.555f, 1011.801f, -733.0652f, 56.7435f, 314.5626f, joaat("p_binbag_01_s")) };
func_362(&(Local_134[12 /*25*/]), 1020.251f, -736.815f, 56.6235f, 1, 15f, 2f, 220.7804f, 1, 1011.238f, -724.7085f, 56.5183f, 10f, 10f, 5f);
Local_134[13 /*25*/] = { func_363(1164.126f, -762.2866f, 56.6656f, 1099.342f, -775.4273f, 57.3525f, 177.5729f, 0) };
func_362(&(Local_134[13 /*25*/]), Local_824, 0, 15f, 2f, 270f, 3, 1149.136f, -981.231f, 45.0495f, 10f, 10f, 5f);
Local_134[14 /*25*/] = { func_363(1199.339f, -678.0995f, 59.9051f, 1205.415f, -672.1282f, 60.1445f, 105.2374f, 0) };
func_362(&(Local_134[14 /*25*/]), Local_824, 0, 15f, 2f, 12.1103f, 3, 1199.339f, -678.0995f, 59.9051f, 10f, 10f, 5f);
Local_134[15 /*25*/] = { func_363(1183.445f, -582.9476f, 63.0962f, 929.3757f, -618.9091f, 56.4612f, 181.1844f, 0) };
func_362(&(Local_134[15 /*25*/]), Local_824, 0, 15f, 2f, 270f, 3, 1149.136f, -981.231f, 45.0495f, 10f, 10f, 5f);
Local_134[16 /*25*/] = { func_363(1192.479f, -485.1086f, 64.7195f, 1264.359f, -719.084f, 63.328f, 65.0519f, 0) };
func_362(&(Local_134[16 /*25*/]), Local_824, 0, 15f, 2f, 270f, 3, 1149.136f, -981.231f, 45.0495f, 10f, 10f, 5f);
Local_134[17 /*25*/] = { func_363(1212.693f, -400.0532f, 67.0971f, 1284.109f, -676.728f, 65.0225f, 69.9898f, 0) };
func_362(&(Local_134[17 /*25*/]), Local_824, 0, 15f, 2f, 270f, 3, 1149.136f, -981.231f, 45.0495f, 10f, 10f, 5f);
Local_134[18 /*25*/] = { func_363(1114.573f, -232.3706f, 68.0949f, 929.3757f, -618.9091f, 56.4612f, 181.1844f, 0) };
func_362(&(Local_134[18 /*25*/]), Local_824, 0, 15f, 2f, 270f, 3, 1149.136f, -981.231f, 45.0495f, 10f, 10f, 5f);
iLocal_830 = 19;
}
void func_362(var uParam0, struct<3> Param1, int iParam4, float fParam5, float fParam6, float fParam7, int iParam8, struct<3> Param9, struct<3> Param12)
{
uParam0->f_3 = { Param1 };
uParam0->f_6 = fParam5;
uParam0->f_7 = fParam6;
uParam0->f_8 = fParam7;
uParam0->f_9 = iParam4;
uParam0->f_10 = iParam8;
uParam0->f_11 = { Param9 };
uParam0->f_14 = { Param12 };
}
struct<25> func_363(struct<3> Param0, struct<3> Param3, float fParam6, int iParam7)
{
struct<25> Var0;
Var0.f_9 = 1;
Var0.f_10 = 3;
Var0 = { Param0 };
Var0.f_19 = { Param3 };
Var0.f_22 = fParam6;
Var0.f_23 = iParam7;
return Var0;
}
void func_364()
{
struct<3> Var0[6];
Var0[0 /*3*/] = { 1251.308f, -400.6231f, 68.0926f };
Var0[1 /*3*/] = { 1183.993f, -403.3443f, 66.8734f };
Var0[2 /*3*/] = { 1161.54f, -372.6073f, 66.6034f };
Var0[3 /*3*/] = { 1167.644f, -273.7987f, 67.9705f };
Var0[4 /*3*/] = { 1252.362f, -247.353f, 77.5631f };
Var0[5 /*3*/] = { 1330.062f, -341.0342f, 100.3476f };
func_365(&Var0, 6);
}
void func_365(var uParam0, int iParam1)
{
int iVar0;
func_370(&uLocal_713);
iVar0 = 0;
while (iVar0 <= (iParam1 - 1))
{
func_369(&uLocal_713, *(uParam0[iVar0 /*3*/]));
iVar0++;
}
func_368(&uLocal_713);
func_366(&uLocal_765, &uLocal_713, 50f);
}
void func_366(var uParam0, var uParam1, float fParam2)
{
int iVar0;
int iVar1;
int iVar2;
struct<3> Var3;
struct<3> Var6;
struct<3> Var9;
if (uParam1->f_46 < 3)
{
}
iVar0 = (uParam1->f_46 - 1);
iVar1 = 0;
iVar2 = 1;
uParam0->f_46 = uParam1->f_46;
while (iVar1 < uParam1->f_46)
{
Var3 = { *(uParam1[iVar1 /*3*/]) - *(uParam1[iVar0 /*3*/]) };
Var6 = { *(uParam1[iVar2 /*3*/]) - *(uParam1[iVar1 /*3*/]) };
Var3 = { Var3 / FtoV(SYSTEM::SQRT(((Var3.x * Var3.x) + (Var3.f_1 * Var3.f_1)))) };
Var6 = { Var6 / FtoV(SYSTEM::SQRT(((Var6.x * Var6.x) + (Var6.f_1 * Var6.f_1)))) };
Var9 = { Var3 - Var6 };
Var9 = { Var9 / FtoV(SYSTEM::SQRT(((Var9.x * Var9.x) + (Var9.f_1 * Var9.f_1)))) };
if (func_367(uParam1, *(uParam1[iVar1 /*3*/]) + Var9))
{
Var9 = { -Var9 };
}
*(uParam0[iVar1 /*3*/]) = { *(uParam1[iVar1 /*3*/]) + Var9 * Vector(fParam2, fParam2, fParam2) };
iVar0 = iVar1;
iVar1++;
iVar2 = (iVar2 + 1 % uParam1->f_46);
}
}
bool func_367(var uParam0, struct<2> Param1, Vector3 vParam3)
{
bool bVar0;
int iVar1;
int iVar2;
if (uParam0->f_46 < 3)
{
}
bVar0 = false;
iVar1 = 0;
iVar2 = (uParam0->f_46 - 1);
while (iVar1 < uParam0->f_46)
{
if (((uParam0[iVar1 /*3*/])->f_1 < Param1.f_1 && (uParam0[iVar2 /*3*/])->f_1 >= Param1.f_1) || ((uParam0[iVar2 /*3*/])->f_1 < Param1.f_1 && (uParam0[iVar1 /*3*/])->f_1 >= Param1.f_1))
{
if (((*uParam0)[iVar1 /*3*/] + (((Param1.f_1 - (uParam0[iVar1 /*3*/])->f_1) / ((uParam0[iVar2 /*3*/])->f_1 - (uParam0[iVar1 /*3*/])->f_1)) * ((*uParam0)[iVar2 /*3*/] - (*uParam0)[iVar1 /*3*/]))) < Param1)
{
bVar0 = !bVar0;
}
}
iVar2 = iVar1;
iVar1++;
}
return bVar0;
}
void func_368(var uParam0)
{
int iVar0;
float fVar1;
if (uParam0->f_51 == 0)
{
}
if (uParam0->f_46 < 3)
{
}
iVar0 = 0;
while (iVar0 < uParam0->f_46)
{
uParam0->f_47 = { uParam0->f_47 + *(uParam0[iVar0 /*3*/]) };
iVar0++;
}
uParam0->f_47 = { uParam0->f_47 / FtoV(SYSTEM::TO_FLOAT(iVar0)) };
iVar0 = 0;
while (iVar0 < uParam0->f_46)
{
fVar1 = SYSTEM::VDIST2(uParam0->f_47, *(uParam0[iVar0 /*3*/]));
if (fVar1 > uParam0->f_50)
{
uParam0->f_50 = fVar1;
}
iVar0++;
}
uParam0->f_50 = SYSTEM::SQRT(uParam0->f_50);
uParam0->f_51 = 0;
}
void func_369(var uParam0, struct<3> Param1)
{
if (uParam0->f_51 == 0)
{
}
if (uParam0->f_46 >= 15)
{
}
*(uParam0[uParam0->f_46 /*3*/]) = { Param1 };
uParam0->f_46++;
}
void func_370(var uParam0)
{
if (uParam0->f_51)
{
}
uParam0->f_46 = 0;
uParam0->f_47 = { 0f, 0f, 0f };
uParam0->f_50 = 0f;
uParam0->f_51 = 1;
}
void func_371()
{
Local_840 = { func_372(1200.61f, -344.2721f, 68.0424f, 269.2015f, joaat("s_m_y_garbage")) };
Local_854 = { func_372(1202.42f, -341.6034f, 67.9378f, 273.1125f, joaat("s_m_y_garbage")) };
}
struct<14> func_372(struct<3> Param0, float fParam3, int iParam4)
{
struct<14> Var0;
Var0.f_1 = { Param0 };
Var0.f_4 = fParam3;
Var0.f_5 = iParam4;
return Var0;
}
void func_373()
{
Local_868 = { func_374(1203.146f, -337.3543f, 67.9314f, 189.7047f, joaat("trash")) };
}
struct<6> func_374(struct<3> Param0, float fParam3, int iParam4)
{
struct<6> Var0;
Var0.f_1 = { Param0 };
Var0.f_4 = fParam3;
Var0.f_5 = iParam4;
return Var0;
}
void func_375()
{
func_240(1);
func_386(1);
unk_0x16C6E55F8C91ED24(joaat("trash"), 0);
unk_0x16C6E55F8C91ED24(joaat("towtruck"), 0);
unk_0x16C6E55F8C91ED24(joaat("s_m_y_garbage"), 0);
func_63();
func_385();
func_384();
func_376(0);
unk_0x4BFE89D21F9885DC();
}
void func_376(bool bParam0)
{
struct<3> Var0;
if (bParam0)
{
}
unk_0xF99B8860747709DD(unk_0x1146A9AE09CE2B14(), 1, 0);
unk_0x911ACE3851C77474("DRIVE", 1);
unk_0x911ACE3851C77474("WORLD_VEHICLE_ATTRACTOR", 1);
unk_0x911ACE3851C77474("WORLD_VEHICLE_DRIVE_PASSENGERS", 1);
unk_0x911ACE3851C77474("WORLD_VEHICLE_DRIVE_SOLO", 1);
func_38();
func_383();
func_382();
func_381();
func_380();
func_222();
if (bParam0)
{
if (unk_0x419E13582192CFEA(iLocal_874))
{
if (unk_0x419E13582192CFEA(unk_0x7D2B9E6A64637269()))
{
if (!unk_0xECEC7528A52B4EE8(unk_0x7D2B9E6A64637269()))
{
if (unk_0xF41EB7643E61A928(unk_0x7D2B9E6A64637269(), iLocal_874, 0))
{
Var0 = { unk_0xD6E677FAD7521410(unk_0x7D2B9E6A64637269(), 1) };
unk_0x78CDDD1E6367978D(unk_0x7D2B9E6A64637269(), Var0, 1, 0, 0, 1);
}
}
}
}
func_378();
unk_0x1036762BD3781C84();
func_2();
}
else
{
func_377();
}
unk_0xBA817770948E3E78(0);
func_145(&uLocal_671, 0, 0);
if (unk_0x0E8572B08CEB6A11(uLocal_823))
{
unk_0x09F9466B03D29D2D(0, 0, 3000, 1, 0, 0);
unk_0xFE1DEC9C5734D0C0(uLocal_823, 0);
}
}
void func_377()
{
func_3();
func_6(&Local_868);
func_6(&uLocal_875);
func_6(&iLocal_874);
func_5(&Local_840, 1, 0, 1);
func_5(&Local_854, 1, 0, 1);
func_6(&uLocal_876);
}
void func_378()
{
Global_19991 = 0;
func_379();
}
void func_379()
{
unk_0xBA3738C78262143F();
Global_22136 = 0;
if (unk_0x6C2F471E0CF8D4CF())
{
unk_0x75B41F5020877259(false);
Global_21125 = 6;
}
}
void func_380()
{
}
void func_381()
{
if (iLocal_837)
{
unk_0xC39EE54ACC066848(joaat("trash"));
}
}
void func_382()
{
}
void func_383()
{
unk_0x824F744352C8BC82(Local_868.f_5);
}
void func_384()
{
func_343(21, 1, 0);
}
void func_385()
{
Global_95225 = 0;
}
void func_386(int iParam0)
{
Global_96676 = iParam0;
}
void func_387()
{
int iVar0;
if (unk_0x79CDCC8ABB331B8C("buddyDeathResponse"))
{
SYSTEM::START_NEW_SCRIPT("buddyDeathResponse", 1424);
}
if (Global_112293.f_9083 || func_33(0))
{
if (!func_388())
{
iVar0 = func_32();
if (iVar0 != -1)
{
if (!func_19(iVar0))
{
return;
}
unk_0x191DDA30577F440A(&(Global_90122[iVar0 /*5*/].f_1), 5);
return;
}
}
else
{
func_24();
}
}
}
int func_388()
{
if (((Global_99370 == 13 || Global_99370 == 10) || Global_99370 == 11) || Global_99370 == 12)
{
return 0;
}
return 1;
}
| 20.615152 | 450 | 0.583395 | [
"object",
"vector"
] |
439942587d91d0fa50c494bc961ffbad2f9615c7 | 1,094 | h | C | Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomTypes.h | aaarsene/o3de | 37e3b0226958974defd14dd6d808e8557dcd7345 | [
"Apache-2.0",
"MIT"
] | 1 | 2021-09-13T00:01:12.000Z | 2021-09-13T00:01:12.000Z | Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomTypes.h | aaarsene/o3de | 37e3b0226958974defd14dd6d808e8557dcd7345 | [
"Apache-2.0",
"MIT"
] | null | null | null | Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomTypes.h | aaarsene/o3de | 37e3b0226958974defd14dd6d808e8557dcd7345 | [
"Apache-2.0",
"MIT"
] | 1 | 2021-07-20T11:07:25.000Z | 2021-07-20T11:07:25.000Z | /*
* Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#pragma once
#include <AzCore/JSON/document.h>
#include <AzCore/JSON/pointer.h>
#include <AzCore/std/containers/vector.h>
#include <AzCore/std/optional.h>
namespace AzToolsFramework
{
namespace Prefab
{
using PrefabDom = rapidjson::Document;
using PrefabDomValue = rapidjson::Value;
using PrefabDomPath = rapidjson::Pointer;
using PrefabDomList = AZStd::vector<PrefabDom>;
using PrefabDomReference = AZStd::optional<AZStd::reference_wrapper<PrefabDom>>;
using PrefabDomConstReference = AZStd::optional<AZStd::reference_wrapper<const PrefabDom>>;
using PrefabDomValueReference = AZStd::optional<AZStd::reference_wrapper<PrefabDomValue>>;
using PrefabDomValueConstReference = AZStd::optional<AZStd::reference_wrapper<const PrefabDomValue>>;
} // namespace Prefab
} // namespace AzToolsFramework
| 34.1875 | 158 | 0.734918 | [
"vector",
"3d"
] |
43a09a9d243568721c14529a3380710f060ef905 | 132,791 | h | C | Source/GeneratedServices/SQLAdmin/GTLRSQLAdminObjects.h | woxtu/google-api-objectivec-client-for-rest | 32430c0cee978abbad6158449c0b703daa725913 | [
"Apache-2.0"
] | 1 | 2022-02-07T21:18:49.000Z | 2022-02-07T21:18:49.000Z | Source/GeneratedServices/SQLAdmin/GTLRSQLAdminObjects.h | godshands40/google-api-objectivec-client-for-rest | 32430c0cee978abbad6158449c0b703daa725913 | [
"Apache-2.0"
] | null | null | null | Source/GeneratedServices/SQLAdmin/GTLRSQLAdminObjects.h | godshands40/google-api-objectivec-client-for-rest | 32430c0cee978abbad6158449c0b703daa725913 | [
"Apache-2.0"
] | 2 | 2020-12-26T20:56:21.000Z | 2022-02-07T21:05:20.000Z | // NOTE: This file was generated by the ServiceGenerator.
// ----------------------------------------------------------------------------
// API:
// Cloud SQL Admin API (sqladmin/v1beta4)
// Description:
// API for Cloud SQL database instance management
// Documentation:
// https://developers.google.com/cloud-sql/
#if SWIFT_PACKAGE || GTLR_USE_MODULAR_IMPORT
@import GoogleAPIClientForRESTCore;
#elif GTLR_BUILT_AS_FRAMEWORK
#import "GTLR/GTLRObject.h"
#else
#import "GTLRObject.h"
#endif
#if GTLR_RUNTIME_VERSION != 3000
#error This file was generated by a different version of ServiceGenerator which is incompatible with this GTLR library source.
#endif
@class GTLRSQLAdmin_AclEntry;
@class GTLRSQLAdmin_ApiWarning;
@class GTLRSQLAdmin_BackupConfiguration;
@class GTLRSQLAdmin_BackupContext;
@class GTLRSQLAdmin_BackupRetentionSettings;
@class GTLRSQLAdmin_BackupRun;
@class GTLRSQLAdmin_BinLogCoordinates;
@class GTLRSQLAdmin_CloneContext;
@class GTLRSQLAdmin_Database;
@class GTLRSQLAdmin_DatabaseFlags;
@class GTLRSQLAdmin_DatabaseInstance;
@class GTLRSQLAdmin_DatabaseInstance_FailoverReplica;
@class GTLRSQLAdmin_DemoteMasterConfiguration;
@class GTLRSQLAdmin_DemoteMasterContext;
@class GTLRSQLAdmin_DemoteMasterMySqlReplicaConfiguration;
@class GTLRSQLAdmin_DenyMaintenancePeriod;
@class GTLRSQLAdmin_DiskEncryptionConfiguration;
@class GTLRSQLAdmin_DiskEncryptionStatus;
@class GTLRSQLAdmin_ExportContext;
@class GTLRSQLAdmin_ExportContext_CsvExportOptions;
@class GTLRSQLAdmin_ExportContext_SqlExportOptions;
@class GTLRSQLAdmin_ExportContext_SqlExportOptions_MysqlExportOptions;
@class GTLRSQLAdmin_FailoverContext;
@class GTLRSQLAdmin_Flag;
@class GTLRSQLAdmin_ImportContext;
@class GTLRSQLAdmin_ImportContext_BakImportOptions;
@class GTLRSQLAdmin_ImportContext_BakImportOptions_EncryptionOptions;
@class GTLRSQLAdmin_ImportContext_CsvImportOptions;
@class GTLRSQLAdmin_InsightsConfig;
@class GTLRSQLAdmin_IpConfiguration;
@class GTLRSQLAdmin_IpMapping;
@class GTLRSQLAdmin_LocationPreference;
@class GTLRSQLAdmin_MaintenanceWindow;
@class GTLRSQLAdmin_MySqlReplicaConfiguration;
@class GTLRSQLAdmin_OnPremisesConfiguration;
@class GTLRSQLAdmin_Operation;
@class GTLRSQLAdmin_OperationError;
@class GTLRSQLAdmin_OperationErrors;
@class GTLRSQLAdmin_ReplicaConfiguration;
@class GTLRSQLAdmin_Reschedule;
@class GTLRSQLAdmin_RestoreBackupContext;
@class GTLRSQLAdmin_RotateServerCaContext;
@class GTLRSQLAdmin_Settings;
@class GTLRSQLAdmin_Settings_UserLabels;
@class GTLRSQLAdmin_SqlActiveDirectoryConfig;
@class GTLRSQLAdmin_SqlExternalSyncSettingError;
@class GTLRSQLAdmin_SqlScheduledMaintenance;
@class GTLRSQLAdmin_SqlServerDatabaseDetails;
@class GTLRSQLAdmin_SqlServerUserDetails;
@class GTLRSQLAdmin_SslCert;
@class GTLRSQLAdmin_SslCertDetail;
@class GTLRSQLAdmin_Tier;
@class GTLRSQLAdmin_TruncateLogContext;
@class GTLRSQLAdmin_User;
// Generated comments include content from the discovery document; avoid them
// causing warnings since clang's checks are some what arbitrary.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation"
NS_ASSUME_NONNULL_BEGIN
// ----------------------------------------------------------------------------
// Constants - For some of the classes' properties below.
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_ApiWarning.code
/**
* Warning when one or more regions are not reachable. The returned result set
* may be incomplete.
*
* Value: "REGION_UNREACHABLE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ApiWarning_Code_RegionUnreachable;
/**
* An unknown or unset warning type from Cloud SQL API.
*
* Value: "SQL_API_WARNING_CODE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ApiWarning_Code_SqlApiWarningCodeUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_BackupRetentionSettings.retentionUnit
/**
* Retention will be by count, eg. "retain the most recent 7 backups".
*
* Value: "COUNT"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRetentionSettings_RetentionUnit_Count;
/**
* Backup retention unit is unspecified, will be treated as COUNT.
*
* Value: "RETENTION_UNIT_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRetentionSettings_RetentionUnit_RetentionUnitUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_BackupRun.backupKind
/**
* Physical backups
*
* Value: "PHYSICAL"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_BackupKind_Physical;
/**
* The snapshot based backups
*
* Value: "SNAPSHOT"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_BackupKind_Snapshot;
/**
* This is an unknown BackupKind.
*
* Value: "SQL_BACKUP_KIND_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_BackupKind_SqlBackupKindUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_BackupRun.status
/**
* The backup has been deleted.
*
* Value: "DELETED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_Deleted;
/**
* The backup deletion failed.
*
* Value: "DELETION_FAILED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_DeletionFailed;
/**
* The backup is about to be deleted.
*
* Value: "DELETION_PENDING"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_DeletionPending;
/**
* The backup operation was enqueued.
*
* Value: "ENQUEUED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_Enqueued;
/**
* The backup failed.
*
* Value: "FAILED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_Failed;
/**
* The backup is overdue across a given backup window. Indicates a problem.
* Example: Long-running operation in progress during the whole window.
*
* Value: "OVERDUE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_Overdue;
/**
* The backup is in progress.
*
* Value: "RUNNING"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_Running;
/**
* The backup was skipped (without problems) for a given backup window.
* Example: Instance was idle.
*
* Value: "SKIPPED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_Skipped;
/**
* The status of the run is unknown.
*
* Value: "SQL_BACKUP_RUN_STATUS_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_SqlBackupRunStatusUnspecified;
/**
* The backup was successful.
*
* Value: "SUCCESSFUL"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Status_Successful;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_BackupRun.type
/**
* The backup schedule automatically triggers a backup.
*
* Value: "AUTOMATED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Type_Automated;
/**
* The user manually triggers a backup.
*
* Value: "ON_DEMAND"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Type_OnDemand;
/**
* This is an unknown BackupRun type.
*
* Value: "SQL_BACKUP_RUN_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_BackupRun_Type_SqlBackupRunTypeUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_DatabaseInstance.backendType
/**
* On premises instance.
*
* Value: "EXTERNAL"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_BackendType_External;
/**
* V1 speckle instance.
*
* Value: "FIRST_GEN"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_BackendType_FirstGen;
/**
* V2 speckle instance.
*
* Value: "SECOND_GEN"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_BackendType_SecondGen;
/**
* This is an unknown backend type for instance.
*
* Value: "SQL_BACKEND_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_BackendType_SqlBackendTypeUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_DatabaseInstance.databaseVersion
/**
* The database version is MySQL 5.1.
*
* Value: "MYSQL_5_1"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql51;
/**
* The database version is MySQL 5.5.
*
* Value: "MYSQL_5_5"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql55;
/**
* The database version is MySQL 5.6.
*
* Value: "MYSQL_5_6"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql56;
/**
* The database version is MySQL 5.7.
*
* Value: "MYSQL_5_7"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql57;
/**
* The database version is MySQL 8.
*
* Value: "MYSQL_8_0"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql80;
/**
* The database version is PostgreSQL 10.
*
* Value: "POSTGRES_10"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres10;
/**
* The database version is PostgreSQL 11.
*
* Value: "POSTGRES_11"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres11;
/**
* The database version is PostgreSQL 12.
*
* Value: "POSTGRES_12"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres12;
/**
* The database version is PostgreSQL 13.
*
* Value: "POSTGRES_13"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres13;
/**
* The database version is PostgreSQL 9.6.
*
* Value: "POSTGRES_9_6"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres96;
/**
* This is an unknown database version.
*
* Value: "SQL_DATABASE_VERSION_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_SqlDatabaseVersionUnspecified;
/**
* The database version is SQL Server 2017 Enterprise.
*
* Value: "SQLSERVER_2017_ENTERPRISE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Sqlserver2017Enterprise;
/**
* The database version is SQL Server 2017 Express.
*
* Value: "SQLSERVER_2017_EXPRESS"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Sqlserver2017Express;
/**
* The database version is SQL Server 2017 Standard.
*
* Value: "SQLSERVER_2017_STANDARD"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Sqlserver2017Standard;
/**
* The database version is SQL Server 2017 Web.
*
* Value: "SQLSERVER_2017_WEB"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Sqlserver2017Web;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_DatabaseInstance.instanceType
/**
* A regular Cloud SQL instance.
*
* Value: "CLOUD_SQL_INSTANCE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_InstanceType_CloudSqlInstance;
/**
* An instance running on the customer's premises that is not managed by Cloud
* SQL.
*
* Value: "ON_PREMISES_INSTANCE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_InstanceType_OnPremisesInstance;
/**
* A Cloud SQL instance acting as a read-replica.
*
* Value: "READ_REPLICA_INSTANCE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_InstanceType_ReadReplicaInstance;
/**
* This is an unknown Cloud SQL instance type.
*
* Value: "SQL_INSTANCE_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_InstanceType_SqlInstanceTypeUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_DatabaseInstance.state
/**
* The creation of the instance failed or a fatal error occurred during
* maintenance.
*
* Value: "FAILED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_State_Failed;
/**
* The instance is down for maintenance.
*
* Value: "MAINTENANCE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_State_Maintenance;
/**
* The instance is being created.
*
* Value: "PENDING_CREATE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_State_PendingCreate;
/**
* The instance is being deleted.
*
* Value: "PENDING_DELETE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_State_PendingDelete;
/**
* The instance has been stopped by owner. It is not currently running, but
* it's ready to be restarted.
*
* Value: "RUNNABLE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_State_Runnable;
/**
* The state of the instance is unknown.
*
* Value: "SQL_INSTANCE_STATE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_State_SqlInstanceStateUnspecified;
/**
* The instance is not available, for example due to problems with billing.
*
* Value: "SUSPENDED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_State_Suspended;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_DatabaseInstance.suspensionReason
/**
* The instance is suspended due to billing issues (for example:, GCP account
* issue)
*
* Value: "BILLING_ISSUE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_SuspensionReason_BillingIssue;
/**
* The KMS key used by the instance is either revoked or denied access to
*
* Value: "KMS_KEY_ISSUE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_SuspensionReason_KmsKeyIssue;
/**
* The instance is suspended due to illegal content (for example:, child
* pornography, copyrighted material, etc.).
*
* Value: "LEGAL_ISSUE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_SuspensionReason_LegalIssue;
/**
* The instance is causing operational issues (for example:, causing the
* database to crash).
*
* Value: "OPERATIONAL_ISSUE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_SuspensionReason_OperationalIssue;
/**
* This is an unknown suspension reason.
*
* Value: "SQL_SUSPENSION_REASON_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_DatabaseInstance_SuspensionReason_SqlSuspensionReasonUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_ExportContext.fileType
/** Value: "BAK" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ExportContext_FileType_Bak;
/**
* File in CSV format.
*
* Value: "CSV"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ExportContext_FileType_Csv;
/**
* File containing SQL statements.
*
* Value: "SQL"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ExportContext_FileType_Sql;
/**
* Unknown file type.
*
* Value: "SQL_FILE_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ExportContext_FileType_SqlFileTypeUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Flag.appliesTo
/**
* The database version is MySQL 5.1.
*
* Value: "MYSQL_5_1"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Mysql51;
/**
* The database version is MySQL 5.5.
*
* Value: "MYSQL_5_5"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Mysql55;
/**
* The database version is MySQL 5.6.
*
* Value: "MYSQL_5_6"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Mysql56;
/**
* The database version is MySQL 5.7.
*
* Value: "MYSQL_5_7"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Mysql57;
/**
* The database version is MySQL 8.
*
* Value: "MYSQL_8_0"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Mysql80;
/**
* The database version is PostgreSQL 10.
*
* Value: "POSTGRES_10"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Postgres10;
/**
* The database version is PostgreSQL 11.
*
* Value: "POSTGRES_11"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Postgres11;
/**
* The database version is PostgreSQL 12.
*
* Value: "POSTGRES_12"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Postgres12;
/**
* The database version is PostgreSQL 13.
*
* Value: "POSTGRES_13"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Postgres13;
/**
* The database version is PostgreSQL 9.6.
*
* Value: "POSTGRES_9_6"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Postgres96;
/**
* This is an unknown database version.
*
* Value: "SQL_DATABASE_VERSION_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_SqlDatabaseVersionUnspecified;
/**
* The database version is SQL Server 2017 Enterprise.
*
* Value: "SQLSERVER_2017_ENTERPRISE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Sqlserver2017Enterprise;
/**
* The database version is SQL Server 2017 Express.
*
* Value: "SQLSERVER_2017_EXPRESS"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Sqlserver2017Express;
/**
* The database version is SQL Server 2017 Standard.
*
* Value: "SQLSERVER_2017_STANDARD"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Sqlserver2017Standard;
/**
* The database version is SQL Server 2017 Web.
*
* Value: "SQLSERVER_2017_WEB"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_AppliesTo_Sqlserver2017Web;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Flag.type
/**
* Boolean type flag.
*
* Value: "BOOLEAN"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_Type_Boolean;
/**
* Float type flag.
*
* Value: "FLOAT"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_Type_Float;
/**
* Integer type flag.
*
* Value: "INTEGER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_Type_Integer;
/**
* Type introduced specically for MySQL TimeZone offset. Accept a string value
* with the format [-12:59, 13:00].
*
* Value: "MYSQL_TIMEZONE_OFFSET"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_Type_MysqlTimezoneOffset;
/**
* Flag type used for a server startup option.
*
* Value: "NONE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_Type_None;
/**
* Comma-separated list of the strings in a SqlFlagType enum.
*
* Value: "REPEATED_STRING"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_Type_RepeatedString;
/**
* This is an unknown flag type.
*
* Value: "SQL_FLAG_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_Type_SqlFlagTypeUnspecified;
/**
* String type flag.
*
* Value: "STRING"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Flag_Type_String;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_ImportContext.fileType
/** Value: "BAK" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ImportContext_FileType_Bak;
/**
* File in CSV format.
*
* Value: "CSV"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ImportContext_FileType_Csv;
/**
* File containing SQL statements.
*
* Value: "SQL"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ImportContext_FileType_Sql;
/**
* Unknown file type.
*
* Value: "SQL_FILE_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_ImportContext_FileType_SqlFileTypeUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_IpMapping.type
/**
* V1 IP of a migrated instance. We want the user to decommission this IP as
* soon as the migration is complete. Note: V1 instances with V1 ip addresses
* will be counted as PRIMARY.
*
* Value: "MIGRATED_1ST_GEN"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_IpMapping_Type_Migrated1stGen;
/**
* Source IP address of the connection a read replica establishes to its
* external primary instance. This IP address can be allowlisted by the
* customer in case it has a firewall that filters incoming connection to its
* on premises primary instance.
*
* Value: "OUTGOING"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_IpMapping_Type_Outgoing;
/**
* IP address the customer is supposed to connect to. Usually this is the load
* balancer's IP address
*
* Value: "PRIMARY"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_IpMapping_Type_Primary;
/**
* Private IP used when using private IPs and network peering.
*
* Value: "PRIVATE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_IpMapping_Type_Private;
/**
* This is an unknown IP address type.
*
* Value: "SQL_IP_ADDRESS_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_IpMapping_Type_SqlIpAddressTypeUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_MaintenanceWindow.updateTrack
/**
* For instance update that requires a restart, this update track indicates
* your instance prefer to restart for new version early in maintenance window.
*
* Value: "canary"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_MaintenanceWindow_UpdateTrack_Canary;
/**
* This is an unknown maintenance timing preference.
*
* Value: "SQL_UPDATE_TRACK_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_MaintenanceWindow_UpdateTrack_SqlUpdateTrackUnspecified;
/**
* For instance update that requires a restart, this update track indicates
* your instance prefer to let Cloud SQL choose the timing of restart (within
* its Maintenance window, if applicable).
*
* Value: "stable"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_MaintenanceWindow_UpdateTrack_Stable;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Operation.operationType
/** Value: "BACKUP" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Backup;
/**
* Performs instance backup.
*
* Value: "BACKUP_VOLUME"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_BackupVolume;
/**
* Clones a Cloud SQL instance.
*
* Value: "CLONE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Clone;
/**
* Creates a new Cloud SQL instance.
*
* Value: "CREATE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Create;
/**
* Creates clone instance.
*
* Value: "CREATE_CLONE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_CreateClone;
/**
* Creates a database in the Cloud SQL instance.
*
* Value: "CREATE_DATABASE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_CreateDatabase;
/**
* Creates a Cloud SQL replica instance.
*
* Value: "CREATE_REPLICA"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_CreateReplica;
/**
* Creates a new user in a Cloud SQL instance.
*
* Value: "CREATE_USER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_CreateUser;
/** Value: "DEFER_MAINTENANCE" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_DeferMaintenance;
/**
* Deletes a Cloud SQL instance.
*
* Value: "DELETE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Delete;
/**
* Deletes the backup taken by a backup run.
*
* Value: "DELETE_BACKUP"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_DeleteBackup;
/**
* Deletes a database in the Cloud SQL instance.
*
* Value: "DELETE_DATABASE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_DeleteDatabase;
/**
* Deletes a user from a Cloud SQL instance.
*
* Value: "DELETE_USER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_DeleteUser;
/**
* Deletes an instance backup.
*
* Value: "DELETE_VOLUME"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_DeleteVolume;
/**
* Demotes the stand-alone instance to be a Cloud SQL read replica for an
* external database server.
*
* Value: "DEMOTE_MASTER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_DemoteMaster;
/**
* This field is deprecated, and will be removed in future version of API.
*
* Value: "ENABLE_PRIVATE_IP"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_EnablePrivateIp;
/**
* Exports data from a Cloud SQL instance to a Cloud Storage bucket.
*
* Value: "EXPORT"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Export;
/**
* Performs failover of an HA-enabled Cloud SQL failover replica.
*
* Value: "FAILOVER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Failover;
/**
* Imports data into a Cloud SQL instance.
*
* Value: "IMPORT"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Import;
/**
* Injects a privileged user in mysql for MOB instances.
*
* Value: "INJECT_USER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_InjectUser;
/**
* Indicates that the instance is currently in maintenance. Maintenance
* typically causes the instance to be unavailable for 1-3 minutes.
*
* Value: "MAINTENANCE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Maintenance;
/**
* Promotes a Cloud SQL replica instance.
*
* Value: "PROMOTE_REPLICA"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_PromoteReplica;
/** Value: "RECREATE_REPLICA" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_RecreateReplica;
/**
* Reschedule maintenance to another time.
*
* Value: "RESCHEDULE_MAINTENANCE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_RescheduleMaintenance;
/**
* Restarts the Cloud SQL instance.
*
* Value: "RESTART"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Restart;
/**
* Restores an instance backup.
*
* Value: "RESTORE_VOLUME"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_RestoreVolume;
/** Value: "SNAPSHOT" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Snapshot;
/**
* Unknown operation type.
*
* Value: "SQL_OPERATION_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_SqlOperationTypeUnspecified;
/**
* Starts external sync of a Cloud SQL EM replica to an external primary
* instance.
*
* Value: "START_EXTERNAL_SYNC"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_StartExternalSync;
/**
* Starts replication on a Cloud SQL read replica instance.
*
* Value: "START_REPLICA"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_StartReplica;
/**
* Stops replication on a Cloud SQL read replica instance.
*
* Value: "STOP_REPLICA"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_StopReplica;
/**
* Truncates a general or slow log table in MySQL.
*
* Value: "TRUNCATE_LOG"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_TruncateLog;
/**
* Updates the settings of a Cloud SQL instance.
*
* Value: "UPDATE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_Update;
/**
* Updates a database in the Cloud SQL instance.
*
* Value: "UPDATE_DATABASE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_UpdateDatabase;
/**
* Updates an existing user in a Cloud SQL instance.
*
* Value: "UPDATE_USER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_OperationType_UpdateUser;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Operation.status
/**
* The operation completed.
*
* Value: "DONE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_Status_Done;
/**
* The operation has been queued, but has not started yet.
*
* Value: "PENDING"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_Status_Pending;
/**
* The operation is running.
*
* Value: "RUNNING"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_Status_Running;
/**
* The state of the operation is unknown.
*
* Value: "SQL_OPERATION_STATUS_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Operation_Status_SqlOperationStatusUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Reschedule.rescheduleType
/**
* If the user wants to schedule the maintenance to happen now.
*
* Value: "IMMEDIATE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Reschedule_RescheduleType_Immediate;
/**
* If the user wants to use the existing maintenance policy to find the next
* available window.
*
* Value: "NEXT_AVAILABLE_WINDOW"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Reschedule_RescheduleType_NextAvailableWindow;
/** Value: "RESCHEDULE_TYPE_UNSPECIFIED" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Reschedule_RescheduleType_RescheduleTypeUnspecified;
/**
* If the user wants to reschedule the maintenance to a specific time.
*
* Value: "SPECIFIC_TIME"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Reschedule_RescheduleType_SpecificTime;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Settings.activationPolicy
/**
* The instance is always up and running.
*
* Value: "ALWAYS"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_ActivationPolicy_Always;
/**
* The instance never starts.
*
* Value: "NEVER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_ActivationPolicy_Never;
/**
* The instance starts upon receiving requests.
*
* Value: "ON_DEMAND"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_ActivationPolicy_OnDemand;
/**
* Unknown activation plan.
*
* Value: "SQL_ACTIVATION_POLICY_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_ActivationPolicy_SqlActivationPolicyUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Settings.availabilityType
/**
* Regional available instance.
*
* Value: "REGIONAL"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_AvailabilityType_Regional;
/**
* This is an unknown Availability type.
*
* Value: "SQL_AVAILABILITY_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_AvailabilityType_SqlAvailabilityTypeUnspecified;
/**
* Zonal available instance.
*
* Value: "ZONAL"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_AvailabilityType_Zonal;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Settings.dataDiskType
/**
* This field is deprecated and will be removed from a future version of the
* API.
*
* Value: "OBSOLETE_LOCAL_SSD"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_DataDiskType_ObsoleteLocalSsd;
/**
* An HDD data disk.
*
* Value: "PD_HDD"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_DataDiskType_PdHdd;
/**
* An SSD data disk.
*
* Value: "PD_SSD"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_DataDiskType_PdSsd;
/**
* This is an unknown data disk type.
*
* Value: "SQL_DATA_DISK_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_DataDiskType_SqlDataDiskTypeUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Settings.pricingPlan
/**
* The instance is billed at a monthly flat rate.
*
* Value: "PACKAGE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_PricingPlan_Package;
/**
* The instance is billed per usage.
*
* Value: "PER_USE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_PricingPlan_PerUse;
/**
* This is an unknown pricing plan for this instance.
*
* Value: "SQL_PRICING_PLAN_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_PricingPlan_SqlPricingPlanUnspecified;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_Settings.replicationType
/**
* The asynchronous replication mode for First Generation instances. It
* provides a slight performance gain, but if an outage occurs while this
* option is set to asynchronous, you can lose up to a few seconds of updates
* to your data.
*
* Value: "ASYNCHRONOUS"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_ReplicationType_Asynchronous;
/**
* This is an unknown replication type for a Cloud SQL instance.
*
* Value: "SQL_REPLICATION_TYPE_UNSPECIFIED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_ReplicationType_SqlReplicationTypeUnspecified;
/**
* The synchronous replication mode for First Generation instances. It is the
* default value.
*
* Value: "SYNCHRONOUS"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_Settings_ReplicationType_Synchronous;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_SqlExternalSyncSettingError.type
/** Value: "BINLOG_NOT_ENABLED" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_BinlogNotEnabled;
/** Value: "CONNECTION_FAILURE" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_ConnectionFailure;
/** Value: "INCOMPATIBLE_DATABASE_VERSION" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_IncompatibleDatabaseVersion;
/**
* The value of parameter max_replication_slots is not sufficient.
*
* Value: "INSUFFICIENT_MAX_REPLICATION_SLOTS"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InsufficientMaxReplicationSlots;
/**
* The value of parameter max_wal_senders is not sufficient.
*
* Value: "INSUFFICIENT_MAX_WAL_SENDERS"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InsufficientMaxWalSenders;
/**
* The value of parameter max_worker_processes is not sufficient.
*
* Value: "INSUFFICIENT_MAX_WORKER_PROCESSES"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InsufficientMaxWorkerProcesses;
/** Value: "INSUFFICIENT_PRIVILEGE" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InsufficientPrivilege;
/**
* The primary instance database parameter setup doesn't allow EM sync.
*
* Value: "INVALID_DB_PARAM"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidDbParam;
/**
* The primary instance logging setup doesn't allow EM sync.
*
* Value: "INVALID_LOGGING_SETUP"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidLoggingSetup;
/**
* The value of parameter rds.logical_replication is not set to 1.
*
* Value: "INVALID_RDS_LOGICAL_REPLICATION"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidRdsLogicalReplication;
/**
* The value of parameter shared_preload_libraries does not include pglogical.
*
* Value: "INVALID_SHARED_PRELOAD_LIBRARY"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidSharedPreloadLibrary;
/**
* The value of parameter wal_level is not set to logical.
*
* Value: "INVALID_WAL_LEVEL"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidWalLevel;
/**
* No pglogical extension installed on databases, applicable for postgres.
*
* Value: "NO_PGLOGICAL_INSTALLED"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_NoPglogicalInstalled;
/**
* pglogical node already exists on databases, applicable for postgres.
*
* Value: "PGLOGICAL_NODE_ALREADY_EXISTS"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_PglogicalNodeAlreadyExists;
/** Value: "REPLICA_ALREADY_SETUP" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_ReplicaAlreadySetup;
/** Value: "SQL_EXTERNAL_SYNC_SETTING_ERROR_TYPE_UNSPECIFIED" */
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_SqlExternalSyncSettingErrorTypeUnspecified;
/**
* SQL Server Agent is not running.
*
* Value: "SQLSERVER_AGENT_NOT_RUNNING"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_SqlserverAgentNotRunning;
/**
* The customer has a definer that will break EM setup.
*
* Value: "UNSUPPORTED_DEFINER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedDefiner;
/**
* Extensions installed are either not supported or having unsupported versions
*
* Value: "UNSUPPORTED_EXTENSIONS"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedExtensions;
/**
* The gtid_mode is not supported, applicable for MySQL.
*
* Value: "UNSUPPORTED_GTID_MODE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedGtidMode;
/**
* Unsupported migration type.
*
* Value: "UNSUPPORTED_MIGRATION_TYPE"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedMigrationType;
/**
* The table definition is not support due to missing primary key or replica
* identity, applicable for postgres.
*
* Value: "UNSUPPORTED_TABLE_DEFINITION"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedTableDefinition;
// ----------------------------------------------------------------------------
// GTLRSQLAdmin_User.type
/**
* The database's built-in user type.
*
* Value: "BUILT_IN"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_User_Type_BuiltIn;
/**
* Cloud IAM service account.
*
* Value: "CLOUD_IAM_SERVICE_ACCOUNT"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_User_Type_CloudIamServiceAccount;
/**
* Cloud IAM user.
*
* Value: "CLOUD_IAM_USER"
*/
FOUNDATION_EXTERN NSString * const kGTLRSQLAdmin_User_Type_CloudIamUser;
/**
* An entry for an Access Control list.
*/
@interface GTLRSQLAdmin_AclEntry : GTLRObject
/**
* The time when this access control entry expires in RFC 3339 format, for
* example *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *expirationTime;
/** This is always *sql#aclEntry*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** Optional. A label to identify this entry. */
@property(nonatomic, copy, nullable) NSString *name;
/** The allowlisted value for the access control list. */
@property(nonatomic, copy, nullable) NSString *value;
@end
/**
* An Admin API warning message.
*/
@interface GTLRSQLAdmin_ApiWarning : GTLRObject
/**
* Code to uniquely identify the warning type.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_ApiWarning_Code_RegionUnreachable Warning when one
* or more regions are not reachable. The returned result set may be
* incomplete. (Value: "REGION_UNREACHABLE")
* @arg @c kGTLRSQLAdmin_ApiWarning_Code_SqlApiWarningCodeUnspecified An
* unknown or unset warning type from Cloud SQL API. (Value:
* "SQL_API_WARNING_CODE_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *code;
/** The warning message. */
@property(nonatomic, copy, nullable) NSString *message;
@end
/**
* Database instance backup configuration.
*/
@interface GTLRSQLAdmin_BackupConfiguration : GTLRObject
/** Backup retention settings. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_BackupRetentionSettings *backupRetentionSettings;
/**
* (MySQL only) Whether binary log is enabled. If backup configuration is
* disabled, binarylog must be disabled as well.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *binaryLogEnabled;
/**
* Whether this configuration is enabled.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *enabled;
/** This is always *sql#backupConfiguration*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** Location of the backup */
@property(nonatomic, copy, nullable) NSString *location;
/**
* Reserved for future use.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *pointInTimeRecoveryEnabled;
/**
* Reserved for future use.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *replicationLogArchivingEnabled;
/**
* Start time for the daily backup configuration in UTC timezone in the 24 hour
* format - *HH:MM*.
*/
@property(nonatomic, copy, nullable) NSString *startTime;
/**
* The number of days of transaction logs we retain for point in time restore,
* from 1-7.
*
* Uses NSNumber of intValue.
*/
@property(nonatomic, strong, nullable) NSNumber *transactionLogRetentionDays;
@end
/**
* Backup context.
*/
@interface GTLRSQLAdmin_BackupContext : GTLRObject
/**
* The identifier of the backup.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *backupId;
/** This is always *sql#backupContext*. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* We currently only support backup retention by specifying the number of
* backups we will retain.
*/
@interface GTLRSQLAdmin_BackupRetentionSettings : GTLRObject
/**
* Depending on the value of retention_unit, this is used to determine if a
* backup needs to be deleted. If retention_unit is 'COUNT', we will retain
* this many backups.
*
* Uses NSNumber of intValue.
*/
@property(nonatomic, strong, nullable) NSNumber *retainedBackups;
/**
* The unit that 'retained_backups' represents.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_BackupRetentionSettings_RetentionUnit_Count
* Retention will be by count, eg. "retain the most recent 7 backups".
* (Value: "COUNT")
* @arg @c kGTLRSQLAdmin_BackupRetentionSettings_RetentionUnit_RetentionUnitUnspecified
* Backup retention unit is unspecified, will be treated as COUNT.
* (Value: "RETENTION_UNIT_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *retentionUnit;
@end
/**
* A BackupRun resource.
*/
@interface GTLRSQLAdmin_BackupRun : GTLRObject
/**
* Specifies the kind of backup, PHYSICAL or DEFAULT_SNAPSHOT.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_BackupRun_BackupKind_Physical Physical backups
* (Value: "PHYSICAL")
* @arg @c kGTLRSQLAdmin_BackupRun_BackupKind_Snapshot The snapshot based
* backups (Value: "SNAPSHOT")
* @arg @c kGTLRSQLAdmin_BackupRun_BackupKind_SqlBackupKindUnspecified This
* is an unknown BackupKind. (Value: "SQL_BACKUP_KIND_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *backupKind;
/**
* The description of this run, only applicable to on-demand backups.
*
* Remapped to 'descriptionProperty' to avoid NSObject's 'description'.
*/
@property(nonatomic, copy, nullable) NSString *descriptionProperty;
/**
* Encryption configuration specific to a backup. Applies only to Second
* Generation instances.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_DiskEncryptionConfiguration *diskEncryptionConfiguration;
/**
* Encryption status specific to a backup. Applies only to Second Generation
* instances.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_DiskEncryptionStatus *diskEncryptionStatus;
/**
* The time the backup operation completed in UTC timezone in RFC 3339 format,
* for example *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *endTime;
/**
* The time the run was enqueued in UTC timezone in RFC 3339 format, for
* example *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *enqueuedTime;
/**
* Information about why the backup operation failed. This is only present if
* the run has the FAILED status.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_OperationError *error;
/**
* The identifier for this backup run. Unique only for a specific Cloud SQL
* instance.
*
* identifier property maps to 'id' in JSON (to avoid Objective C's 'id').
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *identifier;
/** Name of the database instance. */
@property(nonatomic, copy, nullable) NSString *instance;
/** This is always *sql#backupRun*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** Location of the backups. */
@property(nonatomic, copy, nullable) NSString *location;
/** The URI of this resource. */
@property(nonatomic, copy, nullable) NSString *selfLink;
/**
* The time the backup operation actually started in UTC timezone in RFC 3339
* format, for example *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *startTime;
/**
* The status of this run.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_BackupRun_Status_Deleted The backup has been
* deleted. (Value: "DELETED")
* @arg @c kGTLRSQLAdmin_BackupRun_Status_DeletionFailed The backup deletion
* failed. (Value: "DELETION_FAILED")
* @arg @c kGTLRSQLAdmin_BackupRun_Status_DeletionPending The backup is about
* to be deleted. (Value: "DELETION_PENDING")
* @arg @c kGTLRSQLAdmin_BackupRun_Status_Enqueued The backup operation was
* enqueued. (Value: "ENQUEUED")
* @arg @c kGTLRSQLAdmin_BackupRun_Status_Failed The backup failed. (Value:
* "FAILED")
* @arg @c kGTLRSQLAdmin_BackupRun_Status_Overdue The backup is overdue
* across a given backup window. Indicates a problem. Example:
* Long-running operation in progress during the whole window. (Value:
* "OVERDUE")
* @arg @c kGTLRSQLAdmin_BackupRun_Status_Running The backup is in progress.
* (Value: "RUNNING")
* @arg @c kGTLRSQLAdmin_BackupRun_Status_Skipped The backup was skipped
* (without problems) for a given backup window. Example: Instance was
* idle. (Value: "SKIPPED")
* @arg @c kGTLRSQLAdmin_BackupRun_Status_SqlBackupRunStatusUnspecified The
* status of the run is unknown. (Value:
* "SQL_BACKUP_RUN_STATUS_UNSPECIFIED")
* @arg @c kGTLRSQLAdmin_BackupRun_Status_Successful The backup was
* successful. (Value: "SUCCESSFUL")
*/
@property(nonatomic, copy, nullable) NSString *status;
/**
* The type of this run; can be either "AUTOMATED" or "ON_DEMAND".
*
* Likely values:
* @arg @c kGTLRSQLAdmin_BackupRun_Type_Automated The backup schedule
* automatically triggers a backup. (Value: "AUTOMATED")
* @arg @c kGTLRSQLAdmin_BackupRun_Type_OnDemand The user manually triggers a
* backup. (Value: "ON_DEMAND")
* @arg @c kGTLRSQLAdmin_BackupRun_Type_SqlBackupRunTypeUnspecified This is
* an unknown BackupRun type. (Value: "SQL_BACKUP_RUN_TYPE_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *type;
/**
* The start time of the backup window during which this the backup was
* attempted in RFC 3339 format, for example *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *windowStartTime;
@end
/**
* Backup run list results.
*
* @note This class supports NSFastEnumeration and indexed subscripting over
* its "items" property. If returned as the result of a query, it should
* support automatic pagination (when @c shouldFetchNextPages is
* enabled).
*/
@interface GTLRSQLAdmin_BackupRunsListResponse : GTLRCollectionObject
/**
* A list of backup runs in reverse chronological order of the enqueued time.
*
* @note This property is used to support NSFastEnumeration and indexed
* subscripting on this class.
*/
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_BackupRun *> *items;
/** This is always *sql#backupRunsList*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The continuation token, used to page through large result sets. Provide this
* value in a subsequent request to return the next page of results.
*/
@property(nonatomic, copy, nullable) NSString *nextPageToken;
@end
/**
* Binary log coordinates.
*/
@interface GTLRSQLAdmin_BinLogCoordinates : GTLRObject
/** Name of the binary log file for a Cloud SQL instance. */
@property(nonatomic, copy, nullable) NSString *binLogFileName;
/**
* Position (offset) within the binary log file.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *binLogPosition;
/** This is always *sql#binLogCoordinates*. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* Database instance clone context.
*/
@interface GTLRSQLAdmin_CloneContext : GTLRObject
/**
* Binary log coordinates, if specified, identify the position up to which the
* source instance is cloned. If not specified, the source instance is cloned
* up to the most recent binary log coordinates.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_BinLogCoordinates *binLogCoordinates;
/** Name of the Cloud SQL instance to be created as a clone. */
@property(nonatomic, copy, nullable) NSString *destinationInstanceName;
/** This is always *sql#cloneContext*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* Reserved for future use.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *pitrTimestampMs;
/** Reserved for future use. */
@property(nonatomic, strong, nullable) GTLRDateTime *pointInTime;
@end
/**
* Represents a SQL database on the Cloud SQL instance.
*/
@interface GTLRSQLAdmin_Database : GTLRObject
/** The Cloud SQL charset value. */
@property(nonatomic, copy, nullable) NSString *charset;
/** The Cloud SQL collation value. */
@property(nonatomic, copy, nullable) NSString *collation;
/**
* This field is deprecated and will be removed from a future version of the
* API.
*/
@property(nonatomic, copy, nullable) NSString *ETag;
/**
* The name of the Cloud SQL instance. This does not include the project ID.
*/
@property(nonatomic, copy, nullable) NSString *instance;
/** This is always *sql#database*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The name of the database in the Cloud SQL instance. This does not include
* the project ID or instance name.
*/
@property(nonatomic, copy, nullable) NSString *name;
/**
* The project ID of the project containing the Cloud SQL database. The Google
* apps domain is prefixed if applicable.
*/
@property(nonatomic, copy, nullable) NSString *project;
/** The URI of this resource. */
@property(nonatomic, copy, nullable) NSString *selfLink;
@property(nonatomic, strong, nullable) GTLRSQLAdmin_SqlServerDatabaseDetails *sqlserverDatabaseDetails;
@end
/**
* Database flags for Cloud SQL instances.
*/
@interface GTLRSQLAdmin_DatabaseFlags : GTLRObject
/**
* The name of the flag. These flags are passed at instance startup, so include
* both server options and system variables for MySQL. Flags are specified with
* underscores, not hyphens. For more information, see Configuring Database
* Flags in the Cloud SQL documentation.
*/
@property(nonatomic, copy, nullable) NSString *name;
/**
* The value of the flag. Booleans are set to *on* for true and *off* for
* false. This field must be omitted if the flag doesn't take a value.
*/
@property(nonatomic, copy, nullable) NSString *value;
@end
/**
* A Cloud SQL instance resource. Next field: 36
*/
@interface GTLRSQLAdmin_DatabaseInstance : GTLRObject
/**
* *SECOND_GEN*: Cloud SQL database instance. *EXTERNAL*: A database server
* that is not managed by Google. This property is read-only; use the *tier*
* property in the *settings* object to determine the database type.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_DatabaseInstance_BackendType_External On premises
* instance. (Value: "EXTERNAL")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_BackendType_FirstGen V1 speckle
* instance. (Value: "FIRST_GEN")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_BackendType_SecondGen V2 speckle
* instance. (Value: "SECOND_GEN")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_BackendType_SqlBackendTypeUnspecified
* This is an unknown backend type for instance. (Value:
* "SQL_BACKEND_TYPE_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *backendType;
/** Connection name of the Cloud SQL instance used in connection strings. */
@property(nonatomic, copy, nullable) NSString *connectionName;
/**
* The current disk usage of the instance in bytes. This property has been
* deprecated. Use the "cloudsql.googleapis.com/database/disk/bytes_used"
* metric in Cloud Monitoring API instead. Please see this announcement for
* details.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *currentDiskSize;
/**
* The database engine type and version. The *databaseVersion* field cannot be
* changed after instance creation. MySQL instances: *MYSQL_8_0*, *MYSQL_5_7*
* (default), or *MYSQL_5_6*. PostgreSQL instances: *POSTGRES_9_6*,
* *POSTGRES_10*, *POSTGRES_11* or *POSTGRES_12* (default). SQL Server
* instances: *SQLSERVER_2017_STANDARD* (default), *SQLSERVER_2017_ENTERPRISE*,
* *SQLSERVER_2017_EXPRESS*, or *SQLSERVER_2017_WEB*.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql51 The
* database version is MySQL 5.1. (Value: "MYSQL_5_1")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql55 The
* database version is MySQL 5.5. (Value: "MYSQL_5_5")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql56 The
* database version is MySQL 5.6. (Value: "MYSQL_5_6")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql57 The
* database version is MySQL 5.7. (Value: "MYSQL_5_7")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Mysql80 The
* database version is MySQL 8. (Value: "MYSQL_8_0")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres10 The
* database version is PostgreSQL 10. (Value: "POSTGRES_10")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres11 The
* database version is PostgreSQL 11. (Value: "POSTGRES_11")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres12 The
* database version is PostgreSQL 12. (Value: "POSTGRES_12")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres13 The
* database version is PostgreSQL 13. (Value: "POSTGRES_13")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Postgres96 The
* database version is PostgreSQL 9.6. (Value: "POSTGRES_9_6")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_SqlDatabaseVersionUnspecified
* This is an unknown database version. (Value:
* "SQL_DATABASE_VERSION_UNSPECIFIED")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Sqlserver2017Enterprise
* The database version is SQL Server 2017 Enterprise. (Value:
* "SQLSERVER_2017_ENTERPRISE")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Sqlserver2017Express
* The database version is SQL Server 2017 Express. (Value:
* "SQLSERVER_2017_EXPRESS")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Sqlserver2017Standard
* The database version is SQL Server 2017 Standard. (Value:
* "SQLSERVER_2017_STANDARD")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_DatabaseVersion_Sqlserver2017Web
* The database version is SQL Server 2017 Web. (Value:
* "SQLSERVER_2017_WEB")
*/
@property(nonatomic, copy, nullable) NSString *databaseVersion;
/**
* Disk encryption configuration specific to an instance. Applies only to
* Second Generation instances.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_DiskEncryptionConfiguration *diskEncryptionConfiguration;
/**
* Disk encryption status specific to an instance. Applies only to Second
* Generation instances.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_DiskEncryptionStatus *diskEncryptionStatus;
/**
* This field is deprecated and will be removed from a future version of the
* API. Use the *settings.settingsVersion* field instead.
*/
@property(nonatomic, copy, nullable) NSString *ETag;
/**
* The name and status of the failover replica. This property is applicable
* only to Second Generation instances.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_DatabaseInstance_FailoverReplica *failoverReplica;
/**
* The Compute Engine zone that the instance is currently serving from. This
* value could be different from the zone that was specified when the instance
* was created if the instance has failed over to its secondary zone.
*/
@property(nonatomic, copy, nullable) NSString *gceZone;
/**
* The instance type. This can be one of the following. *CLOUD_SQL_INSTANCE*: A
* Cloud SQL instance that is not replicating from a primary instance.
* *ON_PREMISES_INSTANCE*: An instance running on the customer's premises.
* *READ_REPLICA_INSTANCE*: A Cloud SQL instance configured as a read-replica.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_DatabaseInstance_InstanceType_CloudSqlInstance A
* regular Cloud SQL instance. (Value: "CLOUD_SQL_INSTANCE")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_InstanceType_OnPremisesInstance An
* instance running on the customer's premises that is not managed by
* Cloud SQL. (Value: "ON_PREMISES_INSTANCE")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_InstanceType_ReadReplicaInstance A
* Cloud SQL instance acting as a read-replica. (Value:
* "READ_REPLICA_INSTANCE")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_InstanceType_SqlInstanceTypeUnspecified
* This is an unknown Cloud SQL instance type. (Value:
* "SQL_INSTANCE_TYPE_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *instanceType;
/** The assigned IP addresses for the instance. */
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_IpMapping *> *ipAddresses;
/**
* The IPv6 address assigned to the instance. (Deprecated) This property was
* applicable only to First Generation instances.
*/
@property(nonatomic, copy, nullable) NSString *ipv6Address;
/** This is always *sql#instance*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The name of the instance which will act as primary in the replication setup.
*/
@property(nonatomic, copy, nullable) NSString *masterInstanceName;
/**
* The maximum disk size of the instance in bytes.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *maxDiskSize;
/** Name of the Cloud SQL instance. This does not include the project ID. */
@property(nonatomic, copy, nullable) NSString *name;
/** Configuration specific to on-premises instances. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_OnPremisesConfiguration *onPremisesConfiguration;
/**
* The project ID of the project containing the Cloud SQL instance. The Google
* apps domain is prefixed if applicable.
*/
@property(nonatomic, copy, nullable) NSString *project;
/**
* The geographical region. Can be *us-central* (*FIRST_GEN* instances only)
* *us-central1* (*SECOND_GEN* instances only) *asia-east1* or *europe-west1*.
* Defaults to *us-central* or *us-central1* depending on the instance type.
* The region cannot be changed after instance creation.
*/
@property(nonatomic, copy, nullable) NSString *region;
/** Configuration specific to failover replicas and read replicas. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ReplicaConfiguration *replicaConfiguration;
/** The replicas of the instance. */
@property(nonatomic, strong, nullable) NSArray<NSString *> *replicaNames;
/** Initial root password. Use only on creation. */
@property(nonatomic, copy, nullable) NSString *rootPassword;
/**
* The status indicating if instance satisfies physical zone separation.
* Reserved for future use.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *satisfiesPzs;
/** The start time of any upcoming scheduled maintenance for this instance. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_SqlScheduledMaintenance *scheduledMaintenance;
/**
* The Compute Engine zone that the failover instance is currently serving from
* for a regional instance. This value could be different from the zone that
* was specified when the instance was created if the instance has failed over
* to its secondary/failover zone. Reserved for future use.
*/
@property(nonatomic, copy, nullable) NSString *secondaryGceZone;
/** The URI of this resource. */
@property(nonatomic, copy, nullable) NSString *selfLink;
/** SSL configuration. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_SslCert *serverCaCert;
/**
* The service account email address assigned to the instance. This property is
* applicable only to Second Generation instances.
*/
@property(nonatomic, copy, nullable) NSString *serviceAccountEmailAddress;
/** The user settings. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_Settings *settings;
/**
* The current serving state of the Cloud SQL instance. This can be one of the
* following. *SQL_INSTANCE_STATE_UNSPECIFIED*: The state of the instance is
* unknown. *RUNNABLE*: The instance has been stopped by owner. It is not
* currently running, but it's ready to be restarted. *SUSPENDED*: The instance
* is not available, for example due to problems with billing. for example due
* to problems with billing. *PENDING_DELETE*: The instance is being deleted.
* *PENDING_CREATE*: The instance is being created. *MAINTENANCE*: The instance
* is down for maintenance. *FAILED*: The instance creation failed.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_DatabaseInstance_State_Failed The creation of the
* instance failed or a fatal error occurred during maintenance. (Value:
* "FAILED")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_State_Maintenance The instance is
* down for maintenance. (Value: "MAINTENANCE")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_State_PendingCreate The instance is
* being created. (Value: "PENDING_CREATE")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_State_PendingDelete The instance is
* being deleted. (Value: "PENDING_DELETE")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_State_Runnable The instance has
* been stopped by owner. It is not currently running, but it's ready to
* be restarted. (Value: "RUNNABLE")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_State_SqlInstanceStateUnspecified
* The state of the instance is unknown. (Value:
* "SQL_INSTANCE_STATE_UNSPECIFIED")
* @arg @c kGTLRSQLAdmin_DatabaseInstance_State_Suspended The instance is not
* available, for example due to problems with billing. (Value:
* "SUSPENDED")
*/
@property(nonatomic, copy, nullable) NSString *state;
/** If the instance state is SUSPENDED, the reason for the suspension. */
@property(nonatomic, strong, nullable) NSArray<NSString *> *suspensionReason;
@end
/**
* The name and status of the failover replica. This property is applicable
* only to Second Generation instances.
*/
@interface GTLRSQLAdmin_DatabaseInstance_FailoverReplica : GTLRObject
/**
* The availability status of the failover replica. A false status indicates
* that the failover replica is out of sync. The primary instance can only
* failover to the failover replica when the status is true.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *available;
/**
* The name of the failover replica. If specified at instance creation, a
* failover replica is created for the instance. The name doesn't include the
* project ID. This property is applicable only to Second Generation instances.
*/
@property(nonatomic, copy, nullable) NSString *name;
@end
/**
* Database list response.
*
* @note This class supports NSFastEnumeration and indexed subscripting over
* its "items" property.
*/
@interface GTLRSQLAdmin_DatabasesListResponse : GTLRCollectionObject
/**
* List of database resources in the instance.
*
* @note This property is used to support NSFastEnumeration and indexed
* subscripting on this class.
*/
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_Database *> *items;
/** This is always *sql#databasesList*. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* Read-replica configuration for connecting to the on-premises primary
* instance.
*/
@interface GTLRSQLAdmin_DemoteMasterConfiguration : GTLRObject
/** This is always *sql#demoteMasterConfiguration*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* MySQL specific configuration when replicating from a MySQL on-premises
* primary instance. Replication configuration information such as the
* username, password, certificates, and keys are not stored in the instance
* metadata. The configuration information is used only to set up the
* replication connection and is stored by MySQL in a file named *master.info*
* in the data directory.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_DemoteMasterMySqlReplicaConfiguration *mysqlReplicaConfiguration;
@end
/**
* Database instance demote primary instance context.
*/
@interface GTLRSQLAdmin_DemoteMasterContext : GTLRObject
/** This is always *sql#demoteMasterContext*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The name of the instance which will act as on-premises primary instance in
* the replication setup.
*/
@property(nonatomic, copy, nullable) NSString *masterInstanceName;
/**
* Configuration specific to read-replicas replicating from the on-premises
* primary instance.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_DemoteMasterConfiguration *replicaConfiguration;
/**
* Verify GTID consistency for demote operation. Default value: *True*. Second
* Generation instances only. Setting this flag to false enables you to bypass
* GTID consistency check between on-premises primary instance and Cloud SQL
* instance during the demotion operation but also exposes you to the risk of
* future replication failures. Change the value only if you know the reason
* for the GTID divergence and are confident that doing so will not cause any
* replication issues.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *verifyGtidConsistency;
@end
/**
* Read-replica configuration specific to MySQL databases.
*/
@interface GTLRSQLAdmin_DemoteMasterMySqlReplicaConfiguration : GTLRObject
/** PEM representation of the trusted CA's x509 certificate. */
@property(nonatomic, copy, nullable) NSString *caCertificate;
/** PEM representation of the replica's x509 certificate. */
@property(nonatomic, copy, nullable) NSString *clientCertificate;
/**
* PEM representation of the replica's private key. The corresponsing public
* key is encoded in the client's certificate. The format of the replica's
* private key can be either PKCS #1 or PKCS #8.
*/
@property(nonatomic, copy, nullable) NSString *clientKey;
/** This is always *sql#demoteMasterMysqlReplicaConfiguration*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** The password for the replication connection. */
@property(nonatomic, copy, nullable) NSString *password;
/** The username for the replication connection. */
@property(nonatomic, copy, nullable) NSString *username;
@end
/**
* Deny Maintenance Periods. This specifies a date range during when all CSA
* rollout will be denied.
*/
@interface GTLRSQLAdmin_DenyMaintenancePeriod : GTLRObject
/**
* "deny maintenance period" end date. If the year of the end date is empty,
* the year of the start date also must be empty. In this case, it means the
* deny maintenance period recurs every year. The date is in format yyyy-mm-dd
* i.e., 2020-11-01, or mm-dd, i.e., 11-01
*/
@property(nonatomic, copy, nullable) NSString *endDate;
/**
* "deny maintenance period" start date. If the year of the start date is
* empty, the year of the end date also must be empty. In this case, it means
* the deny maintenance period recurs every year. The date is in format
* yyyy-mm-dd i.e., 2020-11-01, or mm-dd, i.e., 11-01
*/
@property(nonatomic, copy, nullable) NSString *startDate;
/**
* Time in UTC when the "deny maintenance period" starts on start_date and ends
* on end_date. The time is in format: HH:mm:SS, i.e., 00:00:00
*/
@property(nonatomic, copy, nullable) NSString *time;
@end
/**
* Disk encryption configuration for an instance.
*/
@interface GTLRSQLAdmin_DiskEncryptionConfiguration : GTLRObject
/** This is always *sql#diskEncryptionConfiguration*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** Resource name of KMS key for disk encryption */
@property(nonatomic, copy, nullable) NSString *kmsKeyName;
@end
/**
* Disk encryption status for an instance.
*/
@interface GTLRSQLAdmin_DiskEncryptionStatus : GTLRObject
/** This is always *sql#diskEncryptionStatus*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** KMS key version used to encrypt the Cloud SQL instance resource */
@property(nonatomic, copy, nullable) NSString *kmsKeyVersionName;
@end
/**
* Database instance export context.
*/
@interface GTLRSQLAdmin_ExportContext : GTLRObject
/**
* Options for exporting data as CSV. *MySQL* and *PostgreSQL* instances only.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ExportContext_CsvExportOptions *csvExportOptions;
/**
* Databases to be exported. *MySQL instances:* If *fileType* is *SQL* and no
* database is specified, all databases are exported, except for the *mysql*
* system database. If *fileType* is *CSV*, you can specify one database,
* either by using this property or by using the *csvExportOptions.selectQuery*
* property, which takes precedence over this property. *PostgreSQL instances:*
* You must specify one database to be exported. If *fileType* is *CSV*, this
* database must match the one specified in the *csvExportOptions.selectQuery*
* property.
*/
@property(nonatomic, strong, nullable) NSArray<NSString *> *databases;
/**
* The file type for the specified uri. *SQL*: The file contains SQL
* statements. *CSV*: The file contains CSV data. *BAK*: The file contains
* backup data for a SQL Server instance.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_ExportContext_FileType_Bak Value "BAK"
* @arg @c kGTLRSQLAdmin_ExportContext_FileType_Csv File in CSV format.
* (Value: "CSV")
* @arg @c kGTLRSQLAdmin_ExportContext_FileType_Sql File containing SQL
* statements. (Value: "SQL")
* @arg @c kGTLRSQLAdmin_ExportContext_FileType_SqlFileTypeUnspecified
* Unknown file type. (Value: "SQL_FILE_TYPE_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *fileType;
/** This is always *sql#exportContext*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* Option for export offload.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *offload;
/** Options for exporting data as SQL statements. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ExportContext_SqlExportOptions *sqlExportOptions;
/**
* The path to the file in Google Cloud Storage where the export will be
* stored. The URI is in the form *gs: //bucketName/fileName*. If the file
* already exists, the requests // succeeds, but the operation fails. If
* *fileType* is // *SQL* and the filename ends with .gz, the contents are //
* compressed.
*/
@property(nonatomic, copy, nullable) NSString *uri;
@end
/**
* Options for exporting data as CSV. *MySQL* and *PostgreSQL* instances only.
*/
@interface GTLRSQLAdmin_ExportContext_CsvExportOptions : GTLRObject
/** The select query used to extract the data. */
@property(nonatomic, copy, nullable) NSString *selectQuery;
@end
/**
* Options for exporting data as SQL statements.
*/
@interface GTLRSQLAdmin_ExportContext_SqlExportOptions : GTLRObject
/** Options for exporting from MySQL. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ExportContext_SqlExportOptions_MysqlExportOptions *mysqlExportOptions;
/**
* Export only schemas.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *schemaOnly;
/**
* Tables to export, or that were exported, from the specified database. If you
* specify tables, specify one and only one database. For PostgreSQL instances,
* you can specify only one table.
*/
@property(nonatomic, strong, nullable) NSArray<NSString *> *tables;
@end
/**
* Options for exporting from MySQL.
*/
@interface GTLRSQLAdmin_ExportContext_SqlExportOptions_MysqlExportOptions : GTLRObject
/**
* Option to include SQL statement required to set up replication. If set to
* *1*, the dump file includes a CHANGE MASTER TO statement with the binary log
* coordinates, and --set-gtid-purged is set to ON. If set to *2*, the CHANGE
* MASTER TO statement is written as a SQL comment and has no effect. If set to
* any value other than *1*, --set-gtid-purged is set to OFF.
*
* Uses NSNumber of intValue.
*/
@property(nonatomic, strong, nullable) NSNumber *masterData;
@end
/**
* Database instance failover context.
*/
@interface GTLRSQLAdmin_FailoverContext : GTLRObject
/** This is always *sql#failoverContext*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The current settings version of this instance. Request will be rejected if
* this version doesn't match the current settings version.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *settingsVersion;
@end
/**
* A flag resource.
*/
@interface GTLRSQLAdmin_Flag : GTLRObject
/**
* Use this field if only certain integers are accepted. Can be combined with
* min_value and max_value to add additional values.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSArray<NSNumber *> *allowedIntValues;
/** For *STRING* flags, a list of strings that the value can be set to. */
@property(nonatomic, strong, nullable) NSArray<NSString *> *allowedStringValues;
/**
* The database version this flag applies to. Can be *MYSQL_8_0*, *MYSQL_5_6*,
* or *MYSQL_5_7*.
*/
@property(nonatomic, strong, nullable) NSArray<NSString *> *appliesTo;
/**
* Whether or not the flag is considered in beta.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *inBeta;
/** This is always *sql#flag*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* For *INTEGER* flags, the maximum allowed value.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *maxValue;
/**
* For *INTEGER* flags, the minimum allowed value.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *minValue;
/**
* This is the name of the flag. Flag names always use underscores, not
* hyphens, for example: *max_allowed_packet*
*/
@property(nonatomic, copy, nullable) NSString *name;
/**
* Indicates whether changing this flag will trigger a database restart. Only
* applicable to Second Generation instances.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *requiresRestart;
/**
* The type of the flag. Flags are typed to being *BOOLEAN*, *STRING*,
* *INTEGER* or *NONE*. *NONE* is used for flags which do not take a value,
* such as *skip_grant_tables*.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_Flag_Type_Boolean Boolean type flag. (Value:
* "BOOLEAN")
* @arg @c kGTLRSQLAdmin_Flag_Type_Float Float type flag. (Value: "FLOAT")
* @arg @c kGTLRSQLAdmin_Flag_Type_Integer Integer type flag. (Value:
* "INTEGER")
* @arg @c kGTLRSQLAdmin_Flag_Type_MysqlTimezoneOffset Type introduced
* specically for MySQL TimeZone offset. Accept a string value with the
* format [-12:59, 13:00]. (Value: "MYSQL_TIMEZONE_OFFSET")
* @arg @c kGTLRSQLAdmin_Flag_Type_None Flag type used for a server startup
* option. (Value: "NONE")
* @arg @c kGTLRSQLAdmin_Flag_Type_RepeatedString Comma-separated list of the
* strings in a SqlFlagType enum. (Value: "REPEATED_STRING")
* @arg @c kGTLRSQLAdmin_Flag_Type_SqlFlagTypeUnspecified This is an unknown
* flag type. (Value: "SQL_FLAG_TYPE_UNSPECIFIED")
* @arg @c kGTLRSQLAdmin_Flag_Type_String String type flag. (Value: "STRING")
*/
@property(nonatomic, copy, nullable) NSString *type;
@end
/**
* Flags list response.
*
* @note This class supports NSFastEnumeration and indexed subscripting over
* its "items" property.
*/
@interface GTLRSQLAdmin_FlagsListResponse : GTLRCollectionObject
/**
* List of flags.
*
* @note This property is used to support NSFastEnumeration and indexed
* subscripting on this class.
*/
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_Flag *> *items;
/** This is always *sql#flagsList*. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* Database instance import context.
*/
@interface GTLRSQLAdmin_ImportContext : GTLRObject
/** Import parameters specific to SQL Server .BAK files */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ImportContext_BakImportOptions *bakImportOptions;
/** Options for importing data as CSV. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ImportContext_CsvImportOptions *csvImportOptions;
/**
* The target database for the import. If *fileType* is *SQL*, this field is
* required only if the import file does not specify a database, and is
* overridden by any database specification in the import file. If *fileType*
* is *CSV*, one database must be specified.
*/
@property(nonatomic, copy, nullable) NSString *database;
/**
* The file type for the specified uri. *SQL*: The file contains SQL
* statements. *CSV*: The file contains CSV data.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_ImportContext_FileType_Bak Value "BAK"
* @arg @c kGTLRSQLAdmin_ImportContext_FileType_Csv File in CSV format.
* (Value: "CSV")
* @arg @c kGTLRSQLAdmin_ImportContext_FileType_Sql File containing SQL
* statements. (Value: "SQL")
* @arg @c kGTLRSQLAdmin_ImportContext_FileType_SqlFileTypeUnspecified
* Unknown file type. (Value: "SQL_FILE_TYPE_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *fileType;
/**
* The PostgreSQL user for this import operation. PostgreSQL instances only.
*/
@property(nonatomic, copy, nullable) NSString *importUser;
/** This is always *sql#importContext*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* Path to the import file in Cloud Storage, in the form *gs:
* //bucketName/fileName*. Compressed gzip files (.gz) are supported // when
* *fileType* is *SQL*. The instance must have // write permissions to the
* bucket and read access to the file.
*/
@property(nonatomic, copy, nullable) NSString *uri;
@end
/**
* Import parameters specific to SQL Server .BAK files
*/
@interface GTLRSQLAdmin_ImportContext_BakImportOptions : GTLRObject
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ImportContext_BakImportOptions_EncryptionOptions *encryptionOptions;
@end
/**
* Options for importing data as CSV.
*/
@interface GTLRSQLAdmin_ImportContext_CsvImportOptions : GTLRObject
/**
* The columns to which CSV data is imported. If not specified, all columns of
* the database table are loaded with CSV data.
*/
@property(nonatomic, strong, nullable) NSArray<NSString *> *columns;
/** The table to which CSV data is imported. */
@property(nonatomic, copy, nullable) NSString *table;
@end
/**
* GTLRSQLAdmin_ImportContext_BakImportOptions_EncryptionOptions
*/
@interface GTLRSQLAdmin_ImportContext_BakImportOptions_EncryptionOptions : GTLRObject
/**
* Path to the Certificate (.cer) in Cloud Storage, in the form
* *gs://bucketName/fileName*. The instance must have write permissions to the
* bucket and read access to the file.
*/
@property(nonatomic, copy, nullable) NSString *certPath;
/** Password that encrypts the private key */
@property(nonatomic, copy, nullable) NSString *pvkPassword;
/**
* Path to the Certificate Private Key (.pvk) in Cloud Storage, in the form
* *gs://bucketName/fileName*. The instance must have write permissions to the
* bucket and read access to the file.
*/
@property(nonatomic, copy, nullable) NSString *pvkPath;
@end
/**
* Insights configuration. This specifies when Cloud SQL Insights feature is
* enabled and optional configuration.
*/
@interface GTLRSQLAdmin_InsightsConfig : GTLRObject
/**
* Whether Query Insights feature is enabled.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *queryInsightsEnabled;
/**
* Maximum query length stored in bytes. Default value: 1024 bytes. Range:
* 256-4500 bytes. Query length more than this field value will be truncated to
* this value. When unset, query length will be the default value.
*
* Uses NSNumber of intValue.
*/
@property(nonatomic, strong, nullable) NSNumber *queryStringLength;
/**
* Whether Query Insights will record application tags from query when enabled.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *recordApplicationTags;
/**
* Whether Query Insights will record client address when enabled.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *recordClientAddress;
@end
/**
* Database instance clone request.
*/
@interface GTLRSQLAdmin_InstancesCloneRequest : GTLRObject
/** Contains details about the clone operation. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_CloneContext *cloneContext;
@end
/**
* Database demote primary instance request.
*/
@interface GTLRSQLAdmin_InstancesDemoteMasterRequest : GTLRObject
/** Contains details about the demoteMaster operation. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_DemoteMasterContext *demoteMasterContext;
@end
/**
* Database instance export request.
*/
@interface GTLRSQLAdmin_InstancesExportRequest : GTLRObject
/** Contains details about the export operation. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ExportContext *exportContext;
@end
/**
* Instance failover request.
*/
@interface GTLRSQLAdmin_InstancesFailoverRequest : GTLRObject
/** Failover Context. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_FailoverContext *failoverContext;
@end
/**
* Database instance import request.
*/
@interface GTLRSQLAdmin_InstancesImportRequest : GTLRObject
/** Contains details about the import operation. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ImportContext *importContext;
@end
/**
* Database instances list response.
*
* @note This class supports NSFastEnumeration and indexed subscripting over
* its "items" property. If returned as the result of a query, it should
* support automatic pagination (when @c shouldFetchNextPages is
* enabled).
*/
@interface GTLRSQLAdmin_InstancesListResponse : GTLRCollectionObject
/**
* List of database instance resources.
*
* @note This property is used to support NSFastEnumeration and indexed
* subscripting on this class.
*/
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_DatabaseInstance *> *items;
/** This is always *sql#instancesList*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The continuation token, used to page through large result sets. Provide this
* value in a subsequent request to return the next page of results.
*/
@property(nonatomic, copy, nullable) NSString *nextPageToken;
/** List of warnings that occurred while handling the request. */
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_ApiWarning *> *warnings;
@end
/**
* Instances ListServerCas response.
*/
@interface GTLRSQLAdmin_InstancesListServerCasResponse : GTLRObject
@property(nonatomic, copy, nullable) NSString *activeVersion;
/** List of server CA certificates for the instance. */
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_SslCert *> *certs;
/** This is always *sql#instancesListServerCas*. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* Database instance restore backup request.
*/
@interface GTLRSQLAdmin_InstancesRestoreBackupRequest : GTLRObject
/** Parameters required to perform the restore backup operation. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_RestoreBackupContext *restoreBackupContext;
@end
/**
* Rotate Server CA request.
*/
@interface GTLRSQLAdmin_InstancesRotateServerCaRequest : GTLRObject
/** Contains details about the rotate server CA operation. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_RotateServerCaContext *rotateServerCaContext;
@end
/**
* Instance truncate log request.
*/
@interface GTLRSQLAdmin_InstancesTruncateLogRequest : GTLRObject
/** Contains details about the truncate log operation. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_TruncateLogContext *truncateLogContext;
@end
/**
* IP Management configuration.
*/
@interface GTLRSQLAdmin_IpConfiguration : GTLRObject
/**
* The list of external networks that are allowed to connect to the instance
* using the IP. In 'CIDR' notation, also known as 'slash' notation (for
* example: *192.168.100.0/24*).
*/
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_AclEntry *> *authorizedNetworks;
/**
* Whether the instance is assigned a public IP address or not.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *ipv4Enabled;
/**
* The resource link for the VPC network from which the Cloud SQL instance is
* accessible for private IP. For example, *
* /projects/myProject/global/networks/default*. This setting can be updated,
* but it cannot be removed after it is set.
*/
@property(nonatomic, copy, nullable) NSString *privateNetwork;
/**
* Whether SSL connections over IP are enforced or not.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *requireSsl;
@end
/**
* Database instance IP Mapping.
*/
@interface GTLRSQLAdmin_IpMapping : GTLRObject
/** The IP address assigned. */
@property(nonatomic, copy, nullable) NSString *ipAddress;
/**
* The due time for this IP to be retired in RFC 3339 format, for example
* *2012-11-15T16:19:00.094Z*. This field is only available when the IP is
* scheduled to be retired.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *timeToRetire;
/**
* The type of this IP address. A *PRIMARY* address is a public address that
* can accept incoming connections. A *PRIVATE* address is a private address
* that can accept incoming connections. An *OUTGOING* address is the source
* address of connections originating from the instance, if supported.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_IpMapping_Type_Migrated1stGen V1 IP of a migrated
* instance. We want the user to decommission this IP as soon as the
* migration is complete. Note: V1 instances with V1 ip addresses will be
* counted as PRIMARY. (Value: "MIGRATED_1ST_GEN")
* @arg @c kGTLRSQLAdmin_IpMapping_Type_Outgoing Source IP address of the
* connection a read replica establishes to its external primary
* instance. This IP address can be allowlisted by the customer in case
* it has a firewall that filters incoming connection to its on premises
* primary instance. (Value: "OUTGOING")
* @arg @c kGTLRSQLAdmin_IpMapping_Type_Primary IP address the customer is
* supposed to connect to. Usually this is the load balancer's IP address
* (Value: "PRIMARY")
* @arg @c kGTLRSQLAdmin_IpMapping_Type_Private Private IP used when using
* private IPs and network peering. (Value: "PRIVATE")
* @arg @c kGTLRSQLAdmin_IpMapping_Type_SqlIpAddressTypeUnspecified This is
* an unknown IP address type. (Value: "SQL_IP_ADDRESS_TYPE_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *type;
@end
/**
* Preferred location. This specifies where a Cloud SQL instance is located,
* either in a specific Compute Engine zone, or co-located with an App Engine
* application. Note that if the preferred location is not available, the
* instance will be located as close as possible within the region. Only one
* location may be specified.
*/
@interface GTLRSQLAdmin_LocationPreference : GTLRObject
/**
* The App Engine application to follow, it must be in the same region as the
* Cloud SQL instance.
*/
@property(nonatomic, copy, nullable) NSString *followGaeApplication;
/** This is always *sql#locationPreference*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The preferred Compute Engine zone for the secondary/failover (for example:
* us-central1-a, us-central1-b, etc.). Reserved for future use.
*/
@property(nonatomic, copy, nullable) NSString *secondaryZone;
/**
* The preferred Compute Engine zone (for example: us-central1-a,
* us-central1-b, etc.).
*
* Remapped to 'zoneProperty' to avoid NSObject's 'zone'.
*/
@property(nonatomic, copy, nullable) NSString *zoneProperty;
@end
/**
* Maintenance window. This specifies when a Cloud SQL instance is restarted
* for system maintenance purposes.
*/
@interface GTLRSQLAdmin_MaintenanceWindow : GTLRObject
/**
* day of week (1-7), starting on Monday.
*
* Uses NSNumber of intValue.
*/
@property(nonatomic, strong, nullable) NSNumber *day;
/**
* hour of day - 0 to 23.
*
* Uses NSNumber of intValue.
*/
@property(nonatomic, strong, nullable) NSNumber *hour;
/** This is always *sql#maintenanceWindow*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* Maintenance timing setting: *canary* (Earlier) or *stable* (Later). Learn
* more.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_MaintenanceWindow_UpdateTrack_Canary For instance
* update that requires a restart, this update track indicates your
* instance prefer to restart for new version early in maintenance
* window. (Value: "canary")
* @arg @c kGTLRSQLAdmin_MaintenanceWindow_UpdateTrack_SqlUpdateTrackUnspecified
* This is an unknown maintenance timing preference. (Value:
* "SQL_UPDATE_TRACK_UNSPECIFIED")
* @arg @c kGTLRSQLAdmin_MaintenanceWindow_UpdateTrack_Stable For instance
* update that requires a restart, this update track indicates your
* instance prefer to let Cloud SQL choose the timing of restart (within
* its Maintenance window, if applicable). (Value: "stable")
*/
@property(nonatomic, copy, nullable) NSString *updateTrack;
@end
/**
* Read-replica configuration specific to MySQL databases.
*/
@interface GTLRSQLAdmin_MySqlReplicaConfiguration : GTLRObject
/** PEM representation of the trusted CA's x509 certificate. */
@property(nonatomic, copy, nullable) NSString *caCertificate;
/** PEM representation of the replica's x509 certificate. */
@property(nonatomic, copy, nullable) NSString *clientCertificate;
/**
* PEM representation of the replica's private key. The corresponsing public
* key is encoded in the client's certificate.
*/
@property(nonatomic, copy, nullable) NSString *clientKey;
/**
* Seconds to wait between connect retries. MySQL's default is 60 seconds.
*
* Uses NSNumber of intValue.
*/
@property(nonatomic, strong, nullable) NSNumber *connectRetryInterval;
/**
* Path to a SQL dump file in Google Cloud Storage from which the replica
* instance is to be created. The URI is in the form gs://bucketName/fileName.
* Compressed gzip files (.gz) are also supported. Dumps have the binlog
* co-ordinates from which replication begins. This can be accomplished by
* setting --master-data to 1 when using mysqldump.
*/
@property(nonatomic, copy, nullable) NSString *dumpFilePath;
/** This is always *sql#mysqlReplicaConfiguration*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* Interval in milliseconds between replication heartbeats.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *masterHeartbeatPeriod;
/** The password for the replication connection. */
@property(nonatomic, copy, nullable) NSString *password;
/** A list of permissible ciphers to use for SSL encryption. */
@property(nonatomic, copy, nullable) NSString *sslCipher;
/** The username for the replication connection. */
@property(nonatomic, copy, nullable) NSString *username;
/**
* Whether or not to check the primary instance's Common Name value in the
* certificate that it sends during the SSL handshake.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *verifyServerCertificate;
@end
/**
* On-premises instance configuration.
*/
@interface GTLRSQLAdmin_OnPremisesConfiguration : GTLRObject
/** PEM representation of the trusted CA's x509 certificate. */
@property(nonatomic, copy, nullable) NSString *caCertificate;
/** PEM representation of the replica's x509 certificate. */
@property(nonatomic, copy, nullable) NSString *clientCertificate;
/**
* PEM representation of the replica's private key. The corresponsing public
* key is encoded in the client's certificate.
*/
@property(nonatomic, copy, nullable) NSString *clientKey;
/** The dump file to create the Cloud SQL replica. */
@property(nonatomic, copy, nullable) NSString *dumpFilePath;
/** The host and port of the on-premises instance in host:port format */
@property(nonatomic, copy, nullable) NSString *hostPort;
/** This is always *sql#onPremisesConfiguration*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** The password for connecting to on-premises instance. */
@property(nonatomic, copy, nullable) NSString *password;
/** The username for connecting to on-premises instance. */
@property(nonatomic, copy, nullable) NSString *username;
@end
/**
* An Operation resource. For successful operations that return an Operation
* resource, only the fields relevant to the operation are populated in the
* resource. Next field: 18
*/
@interface GTLRSQLAdmin_Operation : GTLRObject
/** The context for backup operation, if applicable. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_BackupContext *backupContext;
/**
* The time this operation finished in UTC timezone in RFC 3339 format, for
* example *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *endTime;
/**
* If errors occurred during processing of this operation, this field will be
* populated.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_OperationErrors *error;
/** The context for export operation, if applicable. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ExportContext *exportContext;
/** The context for import operation, if applicable. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_ImportContext *importContext;
/**
* The time this operation was enqueued in UTC timezone in RFC 3339 format, for
* example *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *insertTime;
/** This is always *sql#operation*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* An identifier that uniquely identifies the operation. You can use this
* identifier to retrieve the Operations resource that has information about
* the operation.
*/
@property(nonatomic, copy, nullable) NSString *name;
/**
* The type of the operation. Valid values are: *CREATE* *DELETE* *UPDATE*
* *RESTART* *IMPORT* *EXPORT* *BACKUP_VOLUME* *RESTORE_VOLUME* *CREATE_USER*
* *DELETE_USER* *CREATE_DATABASE* *DELETE_DATABASE*
*
* Likely values:
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Backup Value "BACKUP"
* @arg @c kGTLRSQLAdmin_Operation_OperationType_BackupVolume Performs
* instance backup. (Value: "BACKUP_VOLUME")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Clone Clones a Cloud SQL
* instance. (Value: "CLONE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Create Creates a new Cloud
* SQL instance. (Value: "CREATE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_CreateClone Creates clone
* instance. (Value: "CREATE_CLONE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_CreateDatabase Creates a
* database in the Cloud SQL instance. (Value: "CREATE_DATABASE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_CreateReplica Creates a
* Cloud SQL replica instance. (Value: "CREATE_REPLICA")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_CreateUser Creates a new
* user in a Cloud SQL instance. (Value: "CREATE_USER")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_DeferMaintenance Value
* "DEFER_MAINTENANCE"
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Delete Deletes a Cloud SQL
* instance. (Value: "DELETE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_DeleteBackup Deletes the
* backup taken by a backup run. (Value: "DELETE_BACKUP")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_DeleteDatabase Deletes a
* database in the Cloud SQL instance. (Value: "DELETE_DATABASE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_DeleteUser Deletes a user
* from a Cloud SQL instance. (Value: "DELETE_USER")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_DeleteVolume Deletes an
* instance backup. (Value: "DELETE_VOLUME")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_DemoteMaster Demotes the
* stand-alone instance to be a Cloud SQL read replica for an external
* database server. (Value: "DEMOTE_MASTER")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_EnablePrivateIp This field
* is deprecated, and will be removed in future version of API. (Value:
* "ENABLE_PRIVATE_IP")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Export Exports data from a
* Cloud SQL instance to a Cloud Storage bucket. (Value: "EXPORT")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Failover Performs failover
* of an HA-enabled Cloud SQL failover replica. (Value: "FAILOVER")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Import Imports data into a
* Cloud SQL instance. (Value: "IMPORT")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_InjectUser Injects a
* privileged user in mysql for MOB instances. (Value: "INJECT_USER")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Maintenance Indicates that
* the instance is currently in maintenance. Maintenance typically causes
* the instance to be unavailable for 1-3 minutes. (Value: "MAINTENANCE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_PromoteReplica Promotes a
* Cloud SQL replica instance. (Value: "PROMOTE_REPLICA")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_RecreateReplica Value
* "RECREATE_REPLICA"
* @arg @c kGTLRSQLAdmin_Operation_OperationType_RescheduleMaintenance
* Reschedule maintenance to another time. (Value:
* "RESCHEDULE_MAINTENANCE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Restart Restarts the Cloud
* SQL instance. (Value: "RESTART")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_RestoreVolume Restores an
* instance backup. (Value: "RESTORE_VOLUME")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Snapshot Value "SNAPSHOT"
* @arg @c kGTLRSQLAdmin_Operation_OperationType_SqlOperationTypeUnspecified
* Unknown operation type. (Value: "SQL_OPERATION_TYPE_UNSPECIFIED")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_StartExternalSync Starts
* external sync of a Cloud SQL EM replica to an external primary
* instance. (Value: "START_EXTERNAL_SYNC")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_StartReplica Starts
* replication on a Cloud SQL read replica instance. (Value:
* "START_REPLICA")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_StopReplica Stops
* replication on a Cloud SQL read replica instance. (Value:
* "STOP_REPLICA")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_TruncateLog Truncates a
* general or slow log table in MySQL. (Value: "TRUNCATE_LOG")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_Update Updates the settings
* of a Cloud SQL instance. (Value: "UPDATE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_UpdateDatabase Updates a
* database in the Cloud SQL instance. (Value: "UPDATE_DATABASE")
* @arg @c kGTLRSQLAdmin_Operation_OperationType_UpdateUser Updates an
* existing user in a Cloud SQL instance. (Value: "UPDATE_USER")
*/
@property(nonatomic, copy, nullable) NSString *operationType;
/** The URI of this resource. */
@property(nonatomic, copy, nullable) NSString *selfLink;
/**
* The time this operation actually started in UTC timezone in RFC 3339 format,
* for example *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *startTime;
/**
* The status of an operation. Valid values are: *PENDING* *RUNNING* *DONE*
* *SQL_OPERATION_STATUS_UNSPECIFIED*
*
* Likely values:
* @arg @c kGTLRSQLAdmin_Operation_Status_Done The operation completed.
* (Value: "DONE")
* @arg @c kGTLRSQLAdmin_Operation_Status_Pending The operation has been
* queued, but has not started yet. (Value: "PENDING")
* @arg @c kGTLRSQLAdmin_Operation_Status_Running The operation is running.
* (Value: "RUNNING")
* @arg @c kGTLRSQLAdmin_Operation_Status_SqlOperationStatusUnspecified The
* state of the operation is unknown. (Value:
* "SQL_OPERATION_STATUS_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *status;
/** Name of the database instance related to this operation. */
@property(nonatomic, copy, nullable) NSString *targetId;
@property(nonatomic, copy, nullable) NSString *targetLink;
/** The project ID of the target instance related to this operation. */
@property(nonatomic, copy, nullable) NSString *targetProject;
/** The email address of the user who initiated this operation. */
@property(nonatomic, copy, nullable) NSString *user;
@end
/**
* Database instance operation error.
*/
@interface GTLRSQLAdmin_OperationError : GTLRObject
/** Identifies the specific error that occurred. */
@property(nonatomic, copy, nullable) NSString *code;
/** This is always *sql#operationError*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** Additional information about the error encountered. */
@property(nonatomic, copy, nullable) NSString *message;
@end
/**
* Database instance operation errors list wrapper.
*/
@interface GTLRSQLAdmin_OperationErrors : GTLRObject
/** The list of errors encountered while processing this operation. */
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_OperationError *> *errors;
/** This is always *sql#operationErrors*. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* Database instance list operations response.
*
* @note This class supports NSFastEnumeration and indexed subscripting over
* its "items" property. If returned as the result of a query, it should
* support automatic pagination (when @c shouldFetchNextPages is
* enabled).
*/
@interface GTLRSQLAdmin_OperationsListResponse : GTLRCollectionObject
/**
* List of operation resources.
*
* @note This property is used to support NSFastEnumeration and indexed
* subscripting on this class.
*/
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_Operation *> *items;
/** This is always *sql#operationsList*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The continuation token, used to page through large result sets. Provide this
* value in a subsequent request to return the next page of results.
*/
@property(nonatomic, copy, nullable) NSString *nextPageToken;
@end
/**
* Read-replica configuration for connecting to the primary instance.
*/
@interface GTLRSQLAdmin_ReplicaConfiguration : GTLRObject
/**
* Specifies if the replica is the failover target. If the field is set to
* *true* the replica will be designated as a failover replica. In case the
* primary instance fails, the replica instance will be promoted as the new
* primary instance. Only one replica can be specified as failover target, and
* the replica has to be in different zone with the primary instance.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *failoverTarget;
/** This is always *sql#replicaConfiguration*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* MySQL specific configuration when replicating from a MySQL on-premises
* primary instance. Replication configuration information such as the
* username, password, certificates, and keys are not stored in the instance
* metadata. The configuration information is used only to set up the
* replication connection and is stored by MySQL in a file named *master.info*
* in the data directory.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_MySqlReplicaConfiguration *mysqlReplicaConfiguration;
@end
/**
* GTLRSQLAdmin_Reschedule
*/
@interface GTLRSQLAdmin_Reschedule : GTLRObject
/**
* Required. The type of the reschedule.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_Reschedule_RescheduleType_Immediate If the user
* wants to schedule the maintenance to happen now. (Value: "IMMEDIATE")
* @arg @c kGTLRSQLAdmin_Reschedule_RescheduleType_NextAvailableWindow If the
* user wants to use the existing maintenance policy to find the next
* available window. (Value: "NEXT_AVAILABLE_WINDOW")
* @arg @c kGTLRSQLAdmin_Reschedule_RescheduleType_RescheduleTypeUnspecified
* Value "RESCHEDULE_TYPE_UNSPECIFIED"
* @arg @c kGTLRSQLAdmin_Reschedule_RescheduleType_SpecificTime If the user
* wants to reschedule the maintenance to a specific time. (Value:
* "SPECIFIC_TIME")
*/
@property(nonatomic, copy, nullable) NSString *rescheduleType;
/**
* Optional. Timestamp when the maintenance shall be rescheduled to if
* reschedule_type=SPECIFIC_TIME, in RFC 3339 format, for example
* *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *scheduleTime;
@end
/**
* Database instance restore from backup context. Backup context contains
* source instance id and project id.
*/
@interface GTLRSQLAdmin_RestoreBackupContext : GTLRObject
/**
* The ID of the backup run to restore from.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *backupRunId;
/** The ID of the instance that the backup was taken from. */
@property(nonatomic, copy, nullable) NSString *instanceId;
/** This is always *sql#restoreBackupContext*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** The full project ID of the source instance. */
@property(nonatomic, copy, nullable) NSString *project;
@end
/**
* Instance rotate server CA context.
*/
@interface GTLRSQLAdmin_RotateServerCaContext : GTLRObject
/** This is always *sql#rotateServerCaContext*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The fingerprint of the next version to be rotated to. If left unspecified,
* will be rotated to the most recently added server CA version.
*/
@property(nonatomic, copy, nullable) NSString *nextVersion;
@end
/**
* Database instance settings.
*/
@interface GTLRSQLAdmin_Settings : GTLRObject
/**
* The activation policy specifies when the instance is activated; it is
* applicable only when the instance state is RUNNABLE. Valid values: *ALWAYS*:
* The instance is on, and remains so even in the absence of connection
* requests. *NEVER*: The instance is off; it is not activated, even if a
* connection request arrives.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_Settings_ActivationPolicy_Always The instance is
* always up and running. (Value: "ALWAYS")
* @arg @c kGTLRSQLAdmin_Settings_ActivationPolicy_Never The instance never
* starts. (Value: "NEVER")
* @arg @c kGTLRSQLAdmin_Settings_ActivationPolicy_OnDemand The instance
* starts upon receiving requests. (Value: "ON_DEMAND")
* @arg @c kGTLRSQLAdmin_Settings_ActivationPolicy_SqlActivationPolicyUnspecified
* Unknown activation plan. (Value: "SQL_ACTIVATION_POLICY_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *activationPolicy;
/**
* Active Directory configuration, relevant only for Cloud SQL for SQL Server.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_SqlActiveDirectoryConfig *activeDirectoryConfig;
/**
* The App Engine app IDs that can access this instance. (Deprecated) Applied
* to First Generation instances only.
*/
@property(nonatomic, strong, nullable) NSArray<NSString *> *authorizedGaeApplications;
/**
* Availability type. Potential values: *ZONAL*: The instance serves data from
* only one zone. Outages in that zone affect data accessibility. *REGIONAL*:
* The instance can serve data from more than one zone in a region (it is
* highly available). For more information, see Overview of the High
* Availability Configuration.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_Settings_AvailabilityType_Regional Regional
* available instance. (Value: "REGIONAL")
* @arg @c kGTLRSQLAdmin_Settings_AvailabilityType_SqlAvailabilityTypeUnspecified
* This is an unknown Availability type. (Value:
* "SQL_AVAILABILITY_TYPE_UNSPECIFIED")
* @arg @c kGTLRSQLAdmin_Settings_AvailabilityType_Zonal Zonal available
* instance. (Value: "ZONAL")
*/
@property(nonatomic, copy, nullable) NSString *availabilityType;
/** The daily backup configuration for the instance. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_BackupConfiguration *backupConfiguration;
/** The name of server Instance collation. */
@property(nonatomic, copy, nullable) NSString *collation;
/**
* Configuration specific to read replica instances. Indicates whether database
* flags for crash-safe replication are enabled. This property was only
* applicable to First Generation instances.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *crashSafeReplicationEnabled;
/** The database flags passed to the instance at startup. */
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_DatabaseFlags *> *databaseFlags;
/**
* Configuration specific to read replica instances. Indicates whether
* replication is enabled or not.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *databaseReplicationEnabled;
/**
* The size of data disk, in GB. The data disk size minimum is 10GB.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *dataDiskSizeGb;
/**
* The type of data disk: PD_SSD (default) or PD_HDD. Not used for First
* Generation instances.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_Settings_DataDiskType_ObsoleteLocalSsd This field is
* deprecated and will be removed from a future version of the API.
* (Value: "OBSOLETE_LOCAL_SSD")
* @arg @c kGTLRSQLAdmin_Settings_DataDiskType_PdHdd An HDD data disk.
* (Value: "PD_HDD")
* @arg @c kGTLRSQLAdmin_Settings_DataDiskType_PdSsd An SSD data disk.
* (Value: "PD_SSD")
* @arg @c kGTLRSQLAdmin_Settings_DataDiskType_SqlDataDiskTypeUnspecified
* This is an unknown data disk type. (Value:
* "SQL_DATA_DISK_TYPE_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *dataDiskType;
/** Deny maintenance periods */
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_DenyMaintenancePeriod *> *denyMaintenancePeriods;
/** Insights configuration, for now relevant only for Postgres. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_InsightsConfig *insightsConfig;
/**
* The settings for IP Management. This allows to enable or disable the
* instance IP and manage which external networks can connect to the instance.
* The IPv4 address cannot be disabled for Second Generation instances.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_IpConfiguration *ipConfiguration;
/** This is always *sql#settings*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The location preference settings. This allows the instance to be located as
* near as possible to either an App Engine app or Compute Engine zone for
* better performance. App Engine co-location was only applicable to First
* Generation instances.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_LocationPreference *locationPreference;
/**
* The maintenance window for this instance. This specifies when the instance
* can be restarted for maintenance purposes.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_MaintenanceWindow *maintenanceWindow;
/**
* The pricing plan for this instance. This can be either *PER_USE* or
* *PACKAGE*. Only *PER_USE* is supported for Second Generation instances.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_Settings_PricingPlan_Package The instance is billed
* at a monthly flat rate. (Value: "PACKAGE")
* @arg @c kGTLRSQLAdmin_Settings_PricingPlan_PerUse The instance is billed
* per usage. (Value: "PER_USE")
* @arg @c kGTLRSQLAdmin_Settings_PricingPlan_SqlPricingPlanUnspecified This
* is an unknown pricing plan for this instance. (Value:
* "SQL_PRICING_PLAN_UNSPECIFIED")
*/
@property(nonatomic, copy, nullable) NSString *pricingPlan;
/**
* The type of replication this instance uses. This can be either
* *ASYNCHRONOUS* or *SYNCHRONOUS*. (Deprecated_ This property was only
* applicable to First Generation instances.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_Settings_ReplicationType_Asynchronous The
* asynchronous replication mode for First Generation instances. It
* provides a slight performance gain, but if an outage occurs while this
* option is set to asynchronous, you can lose up to a few seconds of
* updates to your data. (Value: "ASYNCHRONOUS")
* @arg @c kGTLRSQLAdmin_Settings_ReplicationType_SqlReplicationTypeUnspecified
* This is an unknown replication type for a Cloud SQL instance. (Value:
* "SQL_REPLICATION_TYPE_UNSPECIFIED")
* @arg @c kGTLRSQLAdmin_Settings_ReplicationType_Synchronous The synchronous
* replication mode for First Generation instances. It is the default
* value. (Value: "SYNCHRONOUS")
*/
@property(nonatomic, copy, nullable) NSString *replicationType;
/**
* The version of instance settings. This is a required field for update method
* to make sure concurrent updates are handled properly. During update, use the
* most recent settingsVersion value for this instance and do not try to update
* this value.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *settingsVersion;
/**
* Configuration to increase storage size automatically. The default value is
* true.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *storageAutoResize;
/**
* The maximum size to which storage capacity can be automatically increased.
* The default value is 0, which specifies that there is no limit.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *storageAutoResizeLimit;
/**
* The tier (or machine type) for this instance, for example *db-n1-standard-1*
* (MySQL instances) or *db-custom-1-3840* (PostgreSQL instances).
*/
@property(nonatomic, copy, nullable) NSString *tier;
/**
* User-provided labels, represented as a dictionary where each label is a
* single key value pair.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_Settings_UserLabels *userLabels;
@end
/**
* User-provided labels, represented as a dictionary where each label is a
* single key value pair.
*
* @note This class is documented as having more properties of NSString. Use @c
* -additionalJSONKeys and @c -additionalPropertyForName: to get the list
* of properties and then fetch them; or @c -additionalProperties to
* fetch them all at once.
*/
@interface GTLRSQLAdmin_Settings_UserLabels : GTLRObject
@end
/**
* Active Directory configuration, relevant only for Cloud SQL for SQL Server.
*/
@interface GTLRSQLAdmin_SqlActiveDirectoryConfig : GTLRObject
/** The name of the domain (e.g., mydomain.com). */
@property(nonatomic, copy, nullable) NSString *domain;
/** This is always sql#activeDirectoryConfig. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* External primary instance migration setting error.
*/
@interface GTLRSQLAdmin_SqlExternalSyncSettingError : GTLRObject
/** Additional information about the error encountered. */
@property(nonatomic, copy, nullable) NSString *detail;
/** This is always *sql#migrationSettingError*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* Identifies the specific error that occurred.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_BinlogNotEnabled
* Value "BINLOG_NOT_ENABLED"
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_ConnectionFailure
* Value "CONNECTION_FAILURE"
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_IncompatibleDatabaseVersion
* Value "INCOMPATIBLE_DATABASE_VERSION"
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InsufficientMaxReplicationSlots
* The value of parameter max_replication_slots is not sufficient.
* (Value: "INSUFFICIENT_MAX_REPLICATION_SLOTS")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InsufficientMaxWalSenders
* The value of parameter max_wal_senders is not sufficient. (Value:
* "INSUFFICIENT_MAX_WAL_SENDERS")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InsufficientMaxWorkerProcesses
* The value of parameter max_worker_processes is not sufficient. (Value:
* "INSUFFICIENT_MAX_WORKER_PROCESSES")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InsufficientPrivilege
* Value "INSUFFICIENT_PRIVILEGE"
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidDbParam The
* primary instance database parameter setup doesn't allow EM sync.
* (Value: "INVALID_DB_PARAM")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidLoggingSetup
* The primary instance logging setup doesn't allow EM sync. (Value:
* "INVALID_LOGGING_SETUP")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidRdsLogicalReplication
* The value of parameter rds.logical_replication is not set to 1.
* (Value: "INVALID_RDS_LOGICAL_REPLICATION")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidSharedPreloadLibrary
* The value of parameter shared_preload_libraries does not include
* pglogical. (Value: "INVALID_SHARED_PRELOAD_LIBRARY")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_InvalidWalLevel The
* value of parameter wal_level is not set to logical. (Value:
* "INVALID_WAL_LEVEL")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_NoPglogicalInstalled
* No pglogical extension installed on databases, applicable for
* postgres. (Value: "NO_PGLOGICAL_INSTALLED")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_PglogicalNodeAlreadyExists
* pglogical node already exists on databases, applicable for postgres.
* (Value: "PGLOGICAL_NODE_ALREADY_EXISTS")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_ReplicaAlreadySetup
* Value "REPLICA_ALREADY_SETUP"
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_SqlExternalSyncSettingErrorTypeUnspecified
* Value "SQL_EXTERNAL_SYNC_SETTING_ERROR_TYPE_UNSPECIFIED"
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_SqlserverAgentNotRunning
* SQL Server Agent is not running. (Value:
* "SQLSERVER_AGENT_NOT_RUNNING")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedDefiner
* The customer has a definer that will break EM setup. (Value:
* "UNSUPPORTED_DEFINER")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedExtensions
* Extensions installed are either not supported or having unsupported
* versions (Value: "UNSUPPORTED_EXTENSIONS")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedGtidMode
* The gtid_mode is not supported, applicable for MySQL. (Value:
* "UNSUPPORTED_GTID_MODE")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedMigrationType
* Unsupported migration type. (Value: "UNSUPPORTED_MIGRATION_TYPE")
* @arg @c kGTLRSQLAdmin_SqlExternalSyncSettingError_Type_UnsupportedTableDefinition
* The table definition is not support due to missing primary key or
* replica identity, applicable for postgres. (Value:
* "UNSUPPORTED_TABLE_DEFINITION")
*/
@property(nonatomic, copy, nullable) NSString *type;
@end
/**
* Reschedule options for maintenance windows.
*/
@interface GTLRSQLAdmin_SqlInstancesRescheduleMaintenanceRequestBody : GTLRObject
/** Required. The type of the reschedule the user wants. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_Reschedule *reschedule;
@end
/**
* Instance verify external sync settings response.
*/
@interface GTLRSQLAdmin_SqlInstancesVerifyExternalSyncSettingsResponse : GTLRObject
/** List of migration violations. */
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_SqlExternalSyncSettingError *> *errors;
/** This is always *sql#migrationSettingErrorList*. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* Any scheduled maintenancce for this instance.
*/
@interface GTLRSQLAdmin_SqlScheduledMaintenance : GTLRObject
/**
* canDefer
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *canDefer;
/**
* If the scheduled maintenance can be rescheduled.
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *canReschedule;
/** The start time of any upcoming scheduled maintenance for this instance. */
@property(nonatomic, strong, nullable) GTLRDateTime *startTime;
@end
/**
* Represents a Sql Server database on the Cloud SQL instance.
*/
@interface GTLRSQLAdmin_SqlServerDatabaseDetails : GTLRObject
/**
* The version of SQL Server with which the database is to be made compatible
*
* Uses NSNumber of intValue.
*/
@property(nonatomic, strong, nullable) NSNumber *compatibilityLevel;
/** The recovery model of a SQL Server database */
@property(nonatomic, copy, nullable) NSString *recoveryModel;
@end
/**
* Represents a Sql Server user on the Cloud SQL instance.
*/
@interface GTLRSQLAdmin_SqlServerUserDetails : GTLRObject
/**
* If the user has been disabled
*
* Uses NSNumber of boolValue.
*/
@property(nonatomic, strong, nullable) NSNumber *disabled;
/** The server roles for this user */
@property(nonatomic, strong, nullable) NSArray<NSString *> *serverRoles;
@end
/**
* SslCerts Resource
*/
@interface GTLRSQLAdmin_SslCert : GTLRObject
/** PEM representation. */
@property(nonatomic, copy, nullable) NSString *cert;
/** Serial number, as extracted from the certificate. */
@property(nonatomic, copy, nullable) NSString *certSerialNumber;
/** User supplied name. Constrained to [a-zA-Z.-_ ]+. */
@property(nonatomic, copy, nullable) NSString *commonName;
/**
* The time when the certificate was created in RFC 3339 format, for example
* *2012-11-15T16:19:00.094Z*
*/
@property(nonatomic, strong, nullable) GTLRDateTime *createTime;
/**
* The time when the certificate expires in RFC 3339 format, for example
* *2012-11-15T16:19:00.094Z*.
*/
@property(nonatomic, strong, nullable) GTLRDateTime *expirationTime;
/** Name of the database instance. */
@property(nonatomic, copy, nullable) NSString *instance;
/** This is always *sql#sslCert*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** The URI of this resource. */
@property(nonatomic, copy, nullable) NSString *selfLink;
/** Sha1 Fingerprint. */
@property(nonatomic, copy, nullable) NSString *sha1Fingerprint;
@end
/**
* SslCertDetail.
*/
@interface GTLRSQLAdmin_SslCertDetail : GTLRObject
/** The public information about the cert. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_SslCert *certInfo;
/**
* The private key for the client cert, in pem format. Keep private in order to
* protect your security.
*/
@property(nonatomic, copy, nullable) NSString *certPrivateKey;
@end
/**
* SslCerts create ephemeral certificate request.
*/
@interface GTLRSQLAdmin_SslCertsCreateEphemeralRequest : GTLRObject
/** PEM encoded public key to include in the signed certificate. */
@property(nonatomic, copy, nullable) NSString *publicKey;
@end
/**
* SslCerts insert request.
*/
@interface GTLRSQLAdmin_SslCertsInsertRequest : GTLRObject
/**
* User supplied name. Must be a distinct name from the other certificates for
* this instance.
*/
@property(nonatomic, copy, nullable) NSString *commonName;
@end
/**
* SslCert insert response.
*/
@interface GTLRSQLAdmin_SslCertsInsertResponse : GTLRObject
/** The new client certificate and private key. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_SslCertDetail *clientCert;
/** This is always *sql#sslCertsInsert*. */
@property(nonatomic, copy, nullable) NSString *kind;
/** The operation to track the ssl certs insert request. */
@property(nonatomic, strong, nullable) GTLRSQLAdmin_Operation *operation;
/**
* The server Certificate Authority's certificate. If this is missing you can
* force a new one to be generated by calling resetSslConfig method on
* instances resource.
*/
@property(nonatomic, strong, nullable) GTLRSQLAdmin_SslCert *serverCaCert;
@end
/**
* SslCerts list response.
*
* @note This class supports NSFastEnumeration and indexed subscripting over
* its "items" property.
*/
@interface GTLRSQLAdmin_SslCertsListResponse : GTLRCollectionObject
/**
* List of client certificates for the instance.
*
* @note This property is used to support NSFastEnumeration and indexed
* subscripting on this class.
*/
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_SslCert *> *items;
/** This is always *sql#sslCertsList*. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* A Google Cloud SQL service tier resource.
*/
@interface GTLRSQLAdmin_Tier : GTLRObject
/**
* The maximum disk size of this tier in bytes.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *DiskQuota;
/** This is always *sql#tier*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The maximum RAM usage of this tier in bytes.
*
* Uses NSNumber of longLongValue.
*/
@property(nonatomic, strong, nullable) NSNumber *RAM;
/** The applicable regions for this tier. */
@property(nonatomic, strong, nullable) NSArray<NSString *> *region;
/**
* An identifier for the machine type, for example, db-n1-standard-1. For
* related information, see Pricing.
*/
@property(nonatomic, copy, nullable) NSString *tier;
@end
/**
* Tiers list response.
*
* @note This class supports NSFastEnumeration and indexed subscripting over
* its "items" property.
*/
@interface GTLRSQLAdmin_TiersListResponse : GTLRCollectionObject
/**
* List of tiers.
*
* @note This property is used to support NSFastEnumeration and indexed
* subscripting on this class.
*/
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_Tier *> *items;
/** This is always *sql#tiersList*. */
@property(nonatomic, copy, nullable) NSString *kind;
@end
/**
* Database Instance truncate log context.
*/
@interface GTLRSQLAdmin_TruncateLogContext : GTLRObject
/** This is always *sql#truncateLogContext*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The type of log to truncate. Valid values are *MYSQL_GENERAL_TABLE* and
* *MYSQL_SLOW_TABLE*.
*/
@property(nonatomic, copy, nullable) NSString *logType;
@end
/**
* A Cloud SQL user resource.
*/
@interface GTLRSQLAdmin_User : GTLRObject
/**
* This field is deprecated and will be removed from a future version of the
* API.
*/
@property(nonatomic, copy, nullable) NSString *ETag;
/**
* The host name from which the user can connect. For *insert* operations, host
* defaults to an empty string. For *update* operations, host is specified as
* part of the request URL. The host name cannot be updated after insertion.
*/
@property(nonatomic, copy, nullable) NSString *host;
/**
* The name of the Cloud SQL instance. This does not include the project ID.
* Can be omitted for *update* since it is already specified on the URL.
*/
@property(nonatomic, copy, nullable) NSString *instance;
/** This is always *sql#user*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* The name of the user in the Cloud SQL instance. Can be omitted for *update*
* since it is already specified in the URL.
*/
@property(nonatomic, copy, nullable) NSString *name;
/** The password for the user. */
@property(nonatomic, copy, nullable) NSString *password;
/**
* The project ID of the project containing the Cloud SQL database. The Google
* apps domain is prefixed if applicable. Can be omitted for *update* since it
* is already specified on the URL.
*/
@property(nonatomic, copy, nullable) NSString *project;
@property(nonatomic, strong, nullable) GTLRSQLAdmin_SqlServerUserDetails *sqlserverUserDetails;
/**
* The user type. It determines the method to authenticate the user during
* login. The default is the database's built-in user type.
*
* Likely values:
* @arg @c kGTLRSQLAdmin_User_Type_BuiltIn The database's built-in user type.
* (Value: "BUILT_IN")
* @arg @c kGTLRSQLAdmin_User_Type_CloudIamServiceAccount Cloud IAM service
* account. (Value: "CLOUD_IAM_SERVICE_ACCOUNT")
* @arg @c kGTLRSQLAdmin_User_Type_CloudIamUser Cloud IAM user. (Value:
* "CLOUD_IAM_USER")
*/
@property(nonatomic, copy, nullable) NSString *type;
@end
/**
* User list response.
*
* @note This class supports NSFastEnumeration and indexed subscripting over
* its "items" property. If returned as the result of a query, it should
* support automatic pagination (when @c shouldFetchNextPages is
* enabled).
*/
@interface GTLRSQLAdmin_UsersListResponse : GTLRCollectionObject
/**
* List of user resources in the instance.
*
* @note This property is used to support NSFastEnumeration and indexed
* subscripting on this class.
*/
@property(nonatomic, strong, nullable) NSArray<GTLRSQLAdmin_User *> *items;
/** This is always *sql#usersList*. */
@property(nonatomic, copy, nullable) NSString *kind;
/**
* An identifier that uniquely identifies the operation. You can use this
* identifier to retrieve the Operations resource that has information about
* the operation.
*/
@property(nonatomic, copy, nullable) NSString *nextPageToken;
@end
NS_ASSUME_NONNULL_END
#pragma clang diagnostic pop
| 33.533081 | 126 | 0.740638 | [
"object",
"model"
] |
43a226a609de764b88d955714c825e8058369497 | 19,750 | h | C | Hg.h | PaulMWatt/Alchemy | 626bf72d060f523513ad7084111fb21115f8a585 | [
"MIT"
] | 19 | 2015-05-31T22:28:44.000Z | 2021-11-20T05:14:11.000Z | Hg.h | PaulMWatt/Alchemy | 626bf72d060f523513ad7084111fb21115f8a585 | [
"MIT"
] | 20 | 2015-02-03T22:24:07.000Z | 2016-08-06T05:47:04.000Z | Hg.h | PaulMWatt/Alchemy | 626bf72d060f523513ad7084111fb21115f8a585 | [
"MIT"
] | 2 | 2016-09-05T03:25:28.000Z | 2019-11-29T16:19:07.000Z | /// @file Hg.h
///
/// Contains the Hg (Mercury) Message template definition.
/// This format is used to access data fields in formatted message buffers.
///
/// The MIT License(MIT)
///
/// @copyright 2014 Paul M Watt
///
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files(the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions :
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
/// THE SOFTWARE.
///
// ****************************************************************************
#ifndef HG_H_INCLUDED
#define HG_H_INCLUDED
// Includes *******************************************************************
#include <alchemy.h>
// Place this guard for all C++ Headers in the Alchemy base directory.
#ifdef __cplusplus
#include <Hg/msg_buffer.h>
#include <Hg/msg_view.h>
#include <Hg/pack_message.h>
#include <Hg/unpack_message.h>
#include <Pb/dynamic.h>
namespace Hg
{
// Forward Declarations *******************************************************
template< typename T >
size_t dynamic_size_of(const T& msg);
// ****************************************************************************
template< typename MsgT,
typename StorageT
>
class basic_msg;
// ****************************************************************************
template< class HgMsgT,
bool has_dynamic
>
struct msg_size;
// ****************************************************************************
/// An object that defines and manages access to a formatted message buffer.
///
/// @tparam HgT A message description that has
/// defined the format and utilities for field access.
/// @tparam ByteOrderT The specified byte-order for this
/// message definition. HostByteOrder is the default.
///
template< typename HgT,
typename ByteOrderT = Hg::HostByteOrder
>
class Message
: public HgT
{
public:
// Aliases ******************************************************************
using this_type = Message;
using base_type = HgT;
using message_type = typename base_type::message_type;
using format_type = typename base_type::format_type;
using storage_type = typename base_type::storage_type;
using const_pointer = typename base_type::const_pointer;
using byte_order_type = ByteOrderT;
// Construction *************************************************************
// **************************************************************************
/// Default Constructor
///
Message()
: base_type()
{ }
// **************************************************************************
/// Copy Constructor
///
/// @param rhs The Hg message object from which data is copied.
///
Message(const Message& rhs)
: base_type(rhs)
{ }
// **************************************************************************
/// Move Constructor
///
/// @param rhs The Hg message object from which data is moved.
///
Message(Message&& rhs)
: base_type(std::move(rhs))
{ }
// **************************************************************************
/// Copy Constructor
///
/// @param rhs The Hg message object from which data is copied.
///
Message(const message_type& rhs)
{
*static_cast<message_type*>(this) = rhs;
}
// **************************************************************************
/// Move Constructor
///
/// @param rhs The Hg message object from which data is moved.
///
Message(message_type&& rhs)
: base_type(std::move(rhs))
{ }
// **************************************************************************
/// Copy Constructor
///
/// @param rhs The Hg message object from which data is copied.
///
Message(const base_type& rhs)
: base_type(rhs)
{ }
// **************************************************************************
/// Move Constructor
///
/// @param rhs The Hg message object from which data is moved.
///
Message(base_type&& rhs)
: base_type(std::move(rhs))
{ }
// **************************************************************************
/// Value constructor. Constructs an initialized message from a raw data buffer.
///
/// @param p The initialization data. The contents will only
/// be verified for validity of the pointer if the
/// size n is larger than zero.
/// @param n The size of the buffer in sp.
///
Message(const_pointer p, size_t n)
: base_type(p,n)
{ }
// Operations ***************************************************************
// **************************************************************************
/// Copy Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
Message& operator=(const Message& rhs)
{
if (this != &rhs)
{
base_type::operator=(rhs);
}
return *this;
}
// **************************************************************************
/// Move Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
Message& operator=(Message&& rhs)
{
if (this != &rhs)
{
base_type::operator=(std::move(rhs));
}
return *this;
}
// **************************************************************************
/// Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
Message& operator=(const base_type& rhs)
{
if (this != &rhs)
{
base_type::operator=(rhs);
}
return *this;
}
// **************************************************************************
/// Move Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
Message& operator=(base_type&& rhs)
{
if (this != &rhs)
{
base_type::operator=(std::move(rhs));
}
return *this;
}
// **************************************************************************
/// Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
Message& operator=(const message_type& rhs)
{
if (this != &rhs)
{
base_type::operator=(rhs);
}
return *this;
}
// **************************************************************************
/// Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
Message& operator=(message_type&& rhs)
{
if (this != &rhs)
{
base_type::operator=(std::move(rhs));
}
return *this;
}
// **************************************************************************
/// Indicates if the byte-order of the message is host-order.
///
/// @return true - The message is defined in host byte-order.
/// false - The mesage is not in host byte-order.
/// Most likely net byte-order.
///
bool is_host_order() const
{
return byte_order_type::is_host;
}
// Give friendship to message instantiations of other types for conversion.
template< typename other_MsgT,
typename other_ByteOrderT
>
friend
class Message;
};
// ****************************************************************************
/// An object that defines and manages access to a formatted message buffer.
///
/// @tparam MsgT A message description that has
/// defined the format and utilities for field access.
/// The MsgT must define these member-types:
/// format_type: type_list defines the format
/// @tparam StorageT StoragePolicy that manages access rules for the buffer.
///
/// @note The HG declaration MACROs define a template
/// format that is compatible with Hg::basic_msg.
///
template< typename MsgT,
typename StorageT = Hg::BufferedStoragePolicy
>
class basic_msg
: public MsgT
{
public:
// Aliases ******************************************************************
using message_type = MsgT;
using format_type = typename MsgT::format_type;
using storage_type = StorageT;
using buffer_type = MsgBuffer<storage_type>;
using size_trait = message_size_trait_t<format_type>;
using data_type = typename storage_type::data_type;
using pointer = data_type*;
using const_pointer = const data_type*;
using reference = MsgT&;
using const_reference = const MsgT&;
using rval_reference = MsgT&&;
using this_type = basic_msg<MsgT, StorageT>;
using host_t = Message<this_type, Hg::HostByteOrder>;
using net_t = Message<this_type, Hg::NetByteOrder>;
using big_t = Message<this_type, Hg::BigEndian>;
using little_t = Message<this_type, Hg::LittleEndian>;
// Constants ****************************************************************
enum { k_size = size_of<format_type>::value };
///< Indicates the size in bytes of the
/// data buffer managed by this message.
static const
bool k_has_dynamic = has_dynamic<format_type>::value;
///< Indicates if the format of this
/// message contains fields that are
/// potentially dynamically allocated.
// Construction *************************************************************
// **************************************************************************
/// Default Constructor
///
basic_msg()
{ }
// **************************************************************************
/// Copy Constructor
///
/// @param rhs The Hg message object from which data is copied.
///
basic_msg(const basic_msg& rhs)
{
*static_cast<message_type*>(this) = rhs;
}
// **************************************************************************
/// Move Constructor
///
/// @param rhs The Hg message object from which data is moved.
///
basic_msg(basic_msg&& rhs)
: message_type(std::move(rhs))
{ }
// **************************************************************************
/// Copy Constructor
///
/// @param rhs The Hg message object from which data is copied.
///
basic_msg(const message_type& rhs)
: message_type(rhs)
{ }
// **************************************************************************
/// Move Constructor
///
/// @param rhs The Hg message object from which data is moved.
///
basic_msg(message_type&& rhs)
: message_type(std::move(rhs))
{ }
// **************************************************************************
/// Value constructor. Constructs an initialized message from a raw data buffer.
///
/// @param p The initialization data. The contents will only
/// be verified for validity of the pointer if the
/// size n is larger than zero.
/// @param n The size of the buffer in sp.
///
basic_msg(const_pointer p, size_t n)
{
assign(p,n);
}
// Operations ***************************************************************
// **************************************************************************
/// Copy Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
basic_msg& operator=(const basic_msg& rhs)
{
if (this != &rhs)
{
message_type::operator=(rhs);
}
return *this;
}
// **************************************************************************
/// Move Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
basic_msg& operator=(basic_msg&& rhs)
{
if (this != &rhs)
{
message_type::operator=(std::move(rhs));
}
return *this;
}
// **************************************************************************
/// Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
basic_msg& operator=(const message_type& rhs)
{
if (this != &rhs)
{
message_type::operator=(rhs);
}
return *this;
}
// **************************************************************************
/// Move Assignment Operator
///
/// @param rhs Basic message values to initialize this instance.
///
basic_msg& operator=(message_type&& rhs)
{
if (this != &rhs)
{
message_type::operator=(std::move(rhs));
}
return *this;
}
// Status *******************************************************************
// **************************************************************************
/// Indicates if the buffer has allocated space.
///
/// @return true - Buffer space has been allocated for the message.
/// false - There is no buffer space allocated.
///
bool empty() const
{
return m_msgBuffer.empty();
}
// **************************************************************************
/// Indicates the number of bytes required by this message.
///
/// @return The number of bytes that are used to pack this message.
///
size_t size() const
{
return msg_size<this_type,
k_has_dynamic>::calculate(*this);
}
// Methods ******************************************************************
// **************************************************************************
/// Assigns the contents of an incoming raw memory buffer to the message.
///
/// @param pBuffer A memory buffer whose contents will be assigned to
/// this message object. The values of the buffer are
/// copied into the message.
/// @param n The number of bytes held in p_buffer.
///
void assign(const_pointer pBuffer, size_t n)
{
if ( pBuffer
&& n > 0)
{
m_msgBuffer.assign(pBuffer, n);
// Casting this object to the base object MsgT.
// This pointer will accept the data read in from the buffer.
basic_msg &refThis = *static_cast<basic_msg*>(this);
refThis = unpack_message< message_type,
buffer_type,
size_trait
>(*this, m_msgBuffer);
}
else
{
#if ALCHEMY_HAS_EXCEPTIONS
throw std::invalid_argument("Hg::basic_msg<>::assign() - pBuffer is invalid or length n is 0");
#endif
}
}
// **************************************************************************
/// Releases any reference to internal memory buffers.
/// The message will be MT after this call.
///
void clear()
{
m_msgBuffer.clear();
}
// **************************************************************************
/// Returns a const reference to the underlying collection of value objects.
///
const_reference values() const
{
return *this;
}
// **************************************************************************
/// Returns a reference to the underlying collection of value objects.
///
reference values()
{
return *this;
}
// **************************************************************************
/// Returns an reference refernce to the underlying collection of value objects.
///
rval_reference move_values() &&
{
return std::move(*this);
}
// **************************************************************************
/// Returns a pointer to the memory buffer that contains the packed message.
///
const_pointer data() const
{
basic_msg *pThis = const_cast<basic_msg*>(this);
pThis->pack_data();
return m_msgBuffer.data();
}
// **************************************************************************
/// Copies the data from this object
///
bool data(pointer pBuffer, size_t n)
{
return pack_data(pBuffer, n);
}
private:
// Private Data Members *****************************************************
buffer_type m_msgBuffer;
// **************************************************************************
void pack_data()
{
pack_message< message_type,
buffer_type,
size_trait
>(values(), size(), m_msgBuffer);
}
// **************************************************************************
bool pack_data(pointer pBuffer, size_t n)
{
using static_buffer_type = MsgBuffer<BufferedStaticStoragePolicy>;
static_buffer_type msg_buffer;
msg_buffer.assign(pBuffer, n);
return pack_message < message_type,
static_buffer_type
>(values(), msg_buffer);
}
// Give friendship to message instantiations of other types for conversion.
template <typename other_MsgT,
typename other_StorageT
>
friend
class basic_msg;
};
// ****************************************************************************
/// Reports the number of bytes this message object occupies.
/// This instance of size calculates the size for dynamically sized messages.
///
/// @return The number of bytes that are used to pack this message.
///
template< typename T,
bool has_dynamic
>
struct msg_size
{
static size_t calculate(const T &msg)
{
size_t fixed_size = Hg::size_of<typename T::format_type>::value;
size_t dynamic_size = dynamic_size_of<typename T::message_type,
typename T::storage_type>(msg);
return fixed_size + dynamic_size;
}
};
// ****************************************************************************
/// Specialization returns the size of a fixed size message.
///
/// @return The number of bytes that are used to pack this message.
///
template< typename T >
struct msg_size<T, false>
{
static size_t calculate(const T &msg)
{
return Hg::size_of<typename T::format_type>::value;
}
};
} // namespace Hg
// Includes *******************************************************************
#include <Hg/message_byte_order.h>
#include <Hg/message_dynamic.h>
#endif // __cplusplus
#endif
| 31.25 | 101 | 0.467342 | [
"object"
] |
43a5ce4ec323331f77a3633b42922fb252664c3c | 111,992 | c | C | src/parcsr_ls/par_amg.c | ZedThree/hypre | 4409ee92ed0ceb166c78657a7c11abe5e8e31205 | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | null | null | null | src/parcsr_ls/par_amg.c | ZedThree/hypre | 4409ee92ed0ceb166c78657a7c11abe5e8e31205 | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | null | null | null | src/parcsr_ls/par_amg.c | ZedThree/hypre | 4409ee92ed0ceb166c78657a7c11abe5e8e31205 | [
"ECL-2.0",
"Apache-2.0",
"MIT"
] | null | null | null | /******************************************************************************
* Copyright 1998-2019 Lawrence Livermore National Security, LLC and other
* HYPRE Project Developers. See the top-level COPYRIGHT file for details.
*
* SPDX-License-Identifier: (Apache-2.0 OR MIT)
******************************************************************************/
/******************************************************************************
*
* ParAMG functions
*
*****************************************************************************/
#include "_hypre_parcsr_ls.h"
#include "par_amg.h"
#ifdef HYPRE_USING_DSUPERLU
#include <math.h>
#include "superlu_ddefs.h"
#endif
/*--------------------------------------------------------------------------
* hypre_BoomerAMGCreate
*--------------------------------------------------------------------------*/
void *
hypre_BoomerAMGCreate()
{
hypre_ParAMGData *amg_data;
/* setup params */
HYPRE_Int max_levels;
HYPRE_Int max_coarse_size;
HYPRE_Int min_coarse_size;
HYPRE_Real strong_threshold;
HYPRE_Real strong_threshold_R;
HYPRE_Real filter_threshold_R;
HYPRE_Int Sabs;
HYPRE_Real max_row_sum;
HYPRE_Real trunc_factor;
HYPRE_Real agg_trunc_factor;
HYPRE_Real agg_P12_trunc_factor;
HYPRE_Real jacobi_trunc_threshold;
HYPRE_Real S_commpkg_switch;
HYPRE_Real CR_rate;
HYPRE_Real CR_strong_th;
HYPRE_Real A_drop_tol;
HYPRE_Int A_drop_type;
HYPRE_Int interp_type;
HYPRE_Int sep_weight;
HYPRE_Int coarsen_type;
HYPRE_Int measure_type;
HYPRE_Int setup_type;
HYPRE_Int P_max_elmts;
HYPRE_Int num_functions;
HYPRE_Int nodal, nodal_levels, nodal_diag;
HYPRE_Int num_paths;
HYPRE_Int agg_num_levels;
HYPRE_Int agg_interp_type;
HYPRE_Int agg_P_max_elmts;
HYPRE_Int agg_P12_max_elmts;
HYPRE_Int post_interp_type;
HYPRE_Int num_CR_relax_steps;
HYPRE_Int IS_type;
HYPRE_Int CR_use_CG;
HYPRE_Int cgc_its;
HYPRE_Int seq_threshold;
HYPRE_Int redundant;
/* solve params */
HYPRE_Int min_iter;
HYPRE_Int max_iter;
HYPRE_Int fcycle;
HYPRE_Int cycle_type;
HYPRE_Int converge_type;
HYPRE_Real tol;
HYPRE_Int num_sweeps;
HYPRE_Int relax_down;
HYPRE_Int relax_up;
HYPRE_Int relax_coarse;
HYPRE_Int relax_order;
HYPRE_Real relax_wt;
HYPRE_Real outer_wt;
HYPRE_Real nongalerkin_tol;
HYPRE_Int smooth_type;
HYPRE_Int smooth_num_levels;
HYPRE_Int smooth_num_sweeps;
HYPRE_Int variant, overlap, domain_type, schwarz_use_nonsymm;
HYPRE_Real schwarz_rlx_weight;
HYPRE_Int level, sym;
HYPRE_Int eu_level, eu_bj;
HYPRE_Int max_nz_per_row;
HYPRE_Real thresh, filter;
HYPRE_Real drop_tol;
HYPRE_Real eu_sparse_A;
char *euclidfile;
HYPRE_Int cheby_order;
HYPRE_Int cheby_eig_est;
HYPRE_Int cheby_variant;
HYPRE_Int cheby_scale;
HYPRE_Real cheby_eig_ratio;
HYPRE_Int block_mode;
HYPRE_Int additive;
HYPRE_Int mult_additive;
HYPRE_Int simple;
HYPRE_Int add_last_lvl;
HYPRE_Real add_trunc_factor;
HYPRE_Int add_P_max_elmts;
HYPRE_Int add_rlx_type;
HYPRE_Real add_rlx_wt;
/* log info */
HYPRE_Int num_iterations;
HYPRE_Int cum_num_iterations;
/* output params */
HYPRE_Int print_level;
HYPRE_Int logging;
/* HYPRE_Int cycle_op_count; */
char log_file_name[256];
HYPRE_Int debug_flag;
char plot_file_name[251] = {0};
/*-----------------------------------------------------------------------
* Setup default values for parameters
*-----------------------------------------------------------------------*/
/* setup params */
max_levels = 25;
max_coarse_size = 9;
min_coarse_size = 0;
seq_threshold = 0;
redundant = 0;
strong_threshold = 0.25;
strong_threshold_R = 0.25;
filter_threshold_R = 0.0;
Sabs = 0;
max_row_sum = 0.9;
trunc_factor = 0.0;
agg_trunc_factor = 0.0;
agg_P12_trunc_factor = 0.0;
jacobi_trunc_threshold = 0.01;
S_commpkg_switch = 1.0;
interp_type = 0;
sep_weight = 0;
coarsen_type = 10;
interp_type = 6;
measure_type = 0;
setup_type = 1;
P_max_elmts = 4;
agg_P_max_elmts = 0;
agg_P12_max_elmts = 0;
num_functions = 1;
nodal = 0;
nodal_levels = max_levels;
nodal_diag = 0;
num_paths = 1;
agg_num_levels = 0;
post_interp_type = 0;
agg_interp_type = 4;
num_CR_relax_steps = 2;
CR_rate = 0.7;
CR_strong_th = 0;
A_drop_tol = 0.0;
A_drop_type = -1;
IS_type = 1;
CR_use_CG = 0;
cgc_its = 1;
variant = 0;
overlap = 1;
domain_type = 2;
schwarz_rlx_weight = 1.0;
smooth_num_sweeps = 1;
smooth_num_levels = 0;
smooth_type = 6;
schwarz_use_nonsymm = 0;
level = 1;
sym = 0;
thresh = 0.1;
filter = 0.05;
drop_tol = 0.0001;
max_nz_per_row = 20;
euclidfile = NULL;
eu_level = 0;
eu_sparse_A = 0.0;
eu_bj = 0;
/* solve params */
min_iter = 0;
max_iter = 20;
fcycle = 0;
cycle_type = 1;
converge_type = 0;
tol = 1.0e-7;
num_sweeps = 1;
relax_down = 13;
relax_up = 14;
relax_coarse = 9;
relax_order = 0;
relax_wt = 1.0;
outer_wt = 1.0;
cheby_order = 2;
cheby_variant = 0;
cheby_scale = 1;
cheby_eig_est = 10;
cheby_eig_ratio = .3;
block_mode = 0;
additive = -1;
mult_additive = -1;
simple = -1;
add_last_lvl = -1;
add_trunc_factor = 0.0;
add_P_max_elmts = 0;
add_rlx_type = 18;
add_rlx_wt = 1.0;
/* log info */
num_iterations = 0;
cum_num_iterations = 0;
/* output params */
print_level = 0;
logging = 0;
hypre_sprintf(log_file_name, "%s", "amg.out.log");
/* cycle_op_count = 0; */
debug_flag = 0;
nongalerkin_tol = 0.0;
HYPRE_ANNOTATION_BEGIN("BoomerAMG.create");
/*-----------------------------------------------------------------------
* Create the hypre_ParAMGData structure and return
*-----------------------------------------------------------------------*/
amg_data = hypre_CTAlloc(hypre_ParAMGData, 1, HYPRE_MEMORY_HOST);
hypre_ParAMGDataMaxLevels(amg_data) = max_levels;
hypre_ParAMGDataUserCoarseRelaxType(amg_data) = 9;
hypre_ParAMGDataUserRelaxType(amg_data) = -1;
hypre_ParAMGDataUserNumSweeps(amg_data) = -1;
hypre_ParAMGDataUserRelaxWeight(amg_data) = relax_wt;
hypre_ParAMGDataOuterWt(amg_data) = outer_wt;
hypre_BoomerAMGSetMaxCoarseSize(amg_data, max_coarse_size);
hypre_BoomerAMGSetMinCoarseSize(amg_data, min_coarse_size);
hypre_BoomerAMGSetStrongThreshold(amg_data, strong_threshold);
hypre_BoomerAMGSetStrongThresholdR(amg_data, strong_threshold_R);
hypre_BoomerAMGSetFilterThresholdR(amg_data, filter_threshold_R);
hypre_BoomerAMGSetSabs(amg_data, Sabs);
hypre_BoomerAMGSetMaxRowSum(amg_data, max_row_sum);
hypre_BoomerAMGSetTruncFactor(amg_data, trunc_factor);
hypre_BoomerAMGSetAggTruncFactor(amg_data, agg_trunc_factor);
hypre_BoomerAMGSetAggP12TruncFactor(amg_data, agg_P12_trunc_factor);
hypre_BoomerAMGSetJacobiTruncThreshold(amg_data, jacobi_trunc_threshold);
hypre_BoomerAMGSetSCommPkgSwitch(amg_data, S_commpkg_switch);
hypre_BoomerAMGSetSepWeight(amg_data, sep_weight);
hypre_BoomerAMGSetMeasureType(amg_data, measure_type);
hypre_BoomerAMGSetCoarsenType(amg_data, coarsen_type);
hypre_BoomerAMGSetInterpType(amg_data, interp_type);
hypre_BoomerAMGSetSetupType(amg_data, setup_type);
hypre_BoomerAMGSetPMaxElmts(amg_data, P_max_elmts);
hypre_BoomerAMGSetAggPMaxElmts(amg_data, agg_P_max_elmts);
hypre_BoomerAMGSetAggP12MaxElmts(amg_data, agg_P12_max_elmts);
hypre_BoomerAMGSetNumFunctions(amg_data, num_functions);
hypre_BoomerAMGSetNodal(amg_data, nodal);
hypre_BoomerAMGSetNodalLevels(amg_data, nodal_levels);
hypre_BoomerAMGSetNodal(amg_data, nodal_diag);
hypre_BoomerAMGSetNumPaths(amg_data, num_paths);
hypre_BoomerAMGSetAggNumLevels(amg_data, agg_num_levels);
hypre_BoomerAMGSetAggInterpType(amg_data, agg_interp_type);
hypre_BoomerAMGSetPostInterpType(amg_data, post_interp_type);
hypre_BoomerAMGSetNumCRRelaxSteps(amg_data, num_CR_relax_steps);
hypre_BoomerAMGSetCRRate(amg_data, CR_rate);
hypre_BoomerAMGSetCRStrongTh(amg_data, CR_strong_th);
hypre_BoomerAMGSetADropTol(amg_data, A_drop_tol);
hypre_BoomerAMGSetADropType(amg_data, A_drop_type);
hypre_BoomerAMGSetISType(amg_data, IS_type);
hypre_BoomerAMGSetCRUseCG(amg_data, CR_use_CG);
hypre_BoomerAMGSetCGCIts(amg_data, cgc_its);
hypre_BoomerAMGSetVariant(amg_data, variant);
hypre_BoomerAMGSetOverlap(amg_data, overlap);
hypre_BoomerAMGSetSchwarzRlxWeight(amg_data, schwarz_rlx_weight);
hypre_BoomerAMGSetSchwarzUseNonSymm(amg_data, schwarz_use_nonsymm);
hypre_BoomerAMGSetDomainType(amg_data, domain_type);
hypre_BoomerAMGSetSym(amg_data, sym);
hypre_BoomerAMGSetLevel(amg_data, level);
hypre_BoomerAMGSetThreshold(amg_data, thresh);
hypre_BoomerAMGSetFilter(amg_data, filter);
hypre_BoomerAMGSetDropTol(amg_data, drop_tol);
hypre_BoomerAMGSetMaxNzPerRow(amg_data, max_nz_per_row);
hypre_BoomerAMGSetEuclidFile(amg_data, euclidfile);
hypre_BoomerAMGSetEuLevel(amg_data, eu_level);
hypre_BoomerAMGSetEuSparseA(amg_data, eu_sparse_A);
hypre_BoomerAMGSetEuBJ(amg_data, eu_bj);
hypre_BoomerAMGSetMinIter(amg_data, min_iter);
hypre_BoomerAMGSetMaxIter(amg_data, max_iter);
hypre_BoomerAMGSetCycleType(amg_data, cycle_type);
hypre_BoomerAMGSetFCycle(amg_data, fcycle);
hypre_BoomerAMGSetConvergeType(amg_data, converge_type);
hypre_BoomerAMGSetTol(amg_data, tol);
hypre_BoomerAMGSetNumSweeps(amg_data, num_sweeps);
hypre_BoomerAMGSetCycleRelaxType(amg_data, relax_down, 1);
hypre_BoomerAMGSetCycleRelaxType(amg_data, relax_up, 2);
hypre_BoomerAMGSetCycleRelaxType(amg_data, relax_coarse, 3);
hypre_BoomerAMGSetRelaxOrder(amg_data, relax_order);
hypre_BoomerAMGSetRelaxWt(amg_data, relax_wt);
hypre_BoomerAMGSetOuterWt(amg_data, outer_wt);
hypre_BoomerAMGSetSmoothType(amg_data, smooth_type);
hypre_BoomerAMGSetSmoothNumLevels(amg_data, smooth_num_levels);
hypre_BoomerAMGSetSmoothNumSweeps(amg_data, smooth_num_sweeps);
hypre_BoomerAMGSetChebyOrder(amg_data, cheby_order);
hypre_BoomerAMGSetChebyFraction(amg_data, cheby_eig_ratio);
hypre_BoomerAMGSetChebyEigEst(amg_data, cheby_eig_est);
hypre_BoomerAMGSetChebyVariant(amg_data, cheby_variant);
hypre_BoomerAMGSetChebyScale(amg_data, cheby_scale);
hypre_BoomerAMGSetNumIterations(amg_data, num_iterations);
hypre_BoomerAMGSetAdditive(amg_data, additive);
hypre_BoomerAMGSetMultAdditive(amg_data, mult_additive);
hypre_BoomerAMGSetSimple(amg_data, simple);
hypre_BoomerAMGSetMultAddPMaxElmts(amg_data, add_P_max_elmts);
hypre_BoomerAMGSetMultAddTruncFactor(amg_data, add_trunc_factor);
hypre_BoomerAMGSetAddRelaxType(amg_data, add_rlx_type);
hypre_BoomerAMGSetAddRelaxWt(amg_data, add_rlx_wt);
hypre_ParAMGDataAddLastLvl(amg_data) = add_last_lvl;
hypre_ParAMGDataLambda(amg_data) = NULL;
hypre_ParAMGDataXtilde(amg_data) = NULL;
hypre_ParAMGDataRtilde(amg_data) = NULL;
hypre_ParAMGDataDinv(amg_data) = NULL;
#ifdef CUMNUMIT
hypre_ParAMGDataCumNumIterations(amg_data) = cum_num_iterations;
#endif
hypre_BoomerAMGSetPrintLevel(amg_data, print_level);
hypre_BoomerAMGSetLogging(amg_data, logging);
hypre_BoomerAMGSetPrintFileName(amg_data, log_file_name);
hypre_BoomerAMGSetDebugFlag(amg_data, debug_flag);
hypre_BoomerAMGSetRestriction(amg_data, 0);
hypre_BoomerAMGSetIsTriangular(amg_data, 0);
hypre_BoomerAMGSetGMRESSwitchR(amg_data, 64);
hypre_BoomerAMGSetGSMG(amg_data, 0);
hypre_BoomerAMGSetNumSamples(amg_data, 0);
hypre_ParAMGDataAArray(amg_data) = NULL;
hypre_ParAMGDataPArray(amg_data) = NULL;
hypre_ParAMGDataRArray(amg_data) = NULL;
hypre_ParAMGDataCFMarkerArray(amg_data) = NULL;
hypre_ParAMGDataVtemp(amg_data) = NULL;
hypre_ParAMGDataRtemp(amg_data) = NULL;
hypre_ParAMGDataPtemp(amg_data) = NULL;
hypre_ParAMGDataZtemp(amg_data) = NULL;
hypre_ParAMGDataFArray(amg_data) = NULL;
hypre_ParAMGDataUArray(amg_data) = NULL;
hypre_ParAMGDataDofFunc(amg_data) = NULL;
hypre_ParAMGDataDofFuncArray(amg_data) = NULL;
hypre_ParAMGDataDofPointArray(amg_data) = NULL;
hypre_ParAMGDataDofPointArray(amg_data) = NULL;
hypre_ParAMGDataPointDofMapArray(amg_data) = NULL;
hypre_ParAMGDataSmoother(amg_data) = NULL;
hypre_ParAMGDataL1Norms(amg_data) = NULL;
hypre_ParAMGDataABlockArray(amg_data) = NULL;
hypre_ParAMGDataPBlockArray(amg_data) = NULL;
hypre_ParAMGDataRBlockArray(amg_data) = NULL;
/* this can not be set by the user currently */
hypre_ParAMGDataBlockMode(amg_data) = block_mode;
/* Stuff for Chebyshev smoothing */
hypre_ParAMGDataMaxEigEst(amg_data) = NULL;
hypre_ParAMGDataMinEigEst(amg_data) = NULL;
hypre_ParAMGDataChebyDS(amg_data) = NULL;
hypre_ParAMGDataChebyCoefs(amg_data) = NULL;
/* BM Oct 22, 2006 */
hypre_ParAMGDataPlotGrids(amg_data) = 0;
hypre_BoomerAMGSetPlotFileName (amg_data, plot_file_name);
/* BM Oct 17, 2006 */
hypre_ParAMGDataCoordDim(amg_data) = 0;
hypre_ParAMGDataCoordinates(amg_data) = NULL;
/* for fitting vectors for interp */
hypre_BoomerAMGSetInterpVecVariant(amg_data, 0);
hypre_BoomerAMGSetInterpVectors(amg_data, 0, NULL);
hypre_ParAMGNumLevelsInterpVectors(amg_data) = max_levels;
hypre_ParAMGInterpVectorsArray(amg_data) = NULL;
hypre_ParAMGInterpVecQMax(amg_data) = 0;
hypre_ParAMGInterpVecAbsQTrunc(amg_data) = 0.0;
hypre_ParAMGInterpRefine(amg_data) = 0;
hypre_ParAMGInterpVecFirstLevel(amg_data) = 0;
hypre_ParAMGNumInterpVectors(amg_data) = 0;
hypre_ParAMGSmoothInterpVectors(amg_data) = 0;
hypre_ParAMGDataExpandPWeights(amg_data) = NULL;
/* for redundant coarse grid solve */
hypre_ParAMGDataSeqThreshold(amg_data) = seq_threshold;
hypre_ParAMGDataRedundant(amg_data) = redundant;
hypre_ParAMGDataCoarseSolver(amg_data) = NULL;
hypre_ParAMGDataACoarse(amg_data) = NULL;
hypre_ParAMGDataFCoarse(amg_data) = NULL;
hypre_ParAMGDataUCoarse(amg_data) = NULL;
hypre_ParAMGDataNewComm(amg_data) = hypre_MPI_COMM_NULL;
/* for Gaussian elimination coarse grid solve */
hypre_ParAMGDataGSSetup(amg_data) = 0;
hypre_ParAMGDataAMat(amg_data) = NULL;
hypre_ParAMGDataAInv(amg_data) = NULL;
hypre_ParAMGDataBVec(amg_data) = NULL;
hypre_ParAMGDataCommInfo(amg_data) = NULL;
hypre_ParAMGDataNonGalerkinTol(amg_data) = nongalerkin_tol;
hypre_ParAMGDataNonGalTolArray(amg_data) = NULL;
#if defined(HYPRE_USING_CUDA) || defined(HYPRE_USING_DEVICE_OPENMP)
hypre_ParAMGDataRAP2(amg_data) = 1;
hypre_ParAMGDataKeepTranspose(amg_data) = 1;
hypre_ParAMGDataModularizedMatMat(amg_data) = 1;
#else
hypre_ParAMGDataRAP2(amg_data) = 0;
hypre_ParAMGDataKeepTranspose(amg_data) = 0;
hypre_ParAMGDataModularizedMatMat(amg_data) = 0;
#endif
/* information for preserving indices as coarse grid points */
hypre_ParAMGDataCPointKeepMarkerArray(amg_data) = NULL;
hypre_ParAMGDataCPointKeepLevel(amg_data) = 0;
hypre_ParAMGDataNumCPointKeep(amg_data) = 0;
#ifdef HYPRE_USING_DSUPERLU
hypre_ParAMGDataDSLUThreshold(amg_data) = 0;
hypre_ParAMGDataDSLUSolver(amg_data) = NULL;
#endif
HYPRE_ANNOTATION_END("BoomerAMG.create");
return (void *) amg_data;
}
/*--------------------------------------------------------------------------
* hypre_BoomerAMGDestroy
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGDestroy( void *data )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
HYPRE_Int num_levels = hypre_ParAMGDataNumLevels(amg_data);
HYPRE_Int smooth_num_levels = hypre_ParAMGDataSmoothNumLevels(amg_data);
HYPRE_Solver *smoother = hypre_ParAMGDataSmoother(amg_data);
void *amg = hypre_ParAMGDataCoarseSolver(amg_data);
MPI_Comm new_comm = hypre_ParAMGDataNewComm(amg_data);
HYPRE_Int i;
HYPRE_Int *grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
HYPRE_ANNOTATION_BEGIN("BoomerAMG.destroy");
#ifdef HYPRE_USING_DSUPERLU
if (hypre_ParAMGDataDSLUThreshold(amg_data) > 0)
hypre_SLUDistDestroy(hypre_ParAMGDataDSLUSolver(amg_data));
#endif
if (hypre_ParAMGDataMaxEigEst(amg_data))
{
hypre_TFree(hypre_ParAMGDataMaxEigEst(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataMaxEigEst(amg_data) = NULL;
}
if (hypre_ParAMGDataMinEigEst(amg_data))
{
hypre_TFree(hypre_ParAMGDataMinEigEst(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataMinEigEst(amg_data) = NULL;
}
if (hypre_ParAMGDataNumGridSweeps(amg_data))
{
hypre_TFree(hypre_ParAMGDataNumGridSweeps(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataNumGridSweeps(amg_data) = NULL;
}
if (grid_relax_type)
{
HYPRE_Int num_levels = hypre_ParAMGDataNumLevels(amg_data);
if (grid_relax_type[1] == 15 || grid_relax_type[3] == 15 )
{
if (grid_relax_type[1] == 15)
for (i=0; i < num_levels; i++)
HYPRE_ParCSRPCGDestroy(smoother[i]);
if (grid_relax_type[3] == 15 && grid_relax_type[1] != 15)
HYPRE_ParCSRPCGDestroy(smoother[num_levels-1]);
hypre_TFree(smoother, HYPRE_MEMORY_HOST);
}
hypre_TFree(hypre_ParAMGDataGridRelaxType(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataGridRelaxType(amg_data) = NULL;
}
if (hypre_ParAMGDataRelaxWeight(amg_data))
{
hypre_TFree(hypre_ParAMGDataRelaxWeight(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataRelaxWeight(amg_data) = NULL;
}
if (hypre_ParAMGDataOmega(amg_data))
{
hypre_TFree(hypre_ParAMGDataOmega(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataOmega(amg_data) = NULL;
}
if (hypre_ParAMGDataNonGalTolArray(amg_data))
{
hypre_TFree(hypre_ParAMGDataNonGalTolArray(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataNonGalTolArray(amg_data) = NULL;
}
if (hypre_ParAMGDataDofFunc(amg_data))
{
hypre_TFree(hypre_ParAMGDataDofFunc(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataDofFunc(amg_data) = NULL;
}
if (hypre_ParAMGDataGridRelaxPoints(amg_data))
{
for (i=0; i < 4; i++)
hypre_TFree(hypre_ParAMGDataGridRelaxPoints(amg_data)[i], HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataGridRelaxPoints(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataGridRelaxPoints(amg_data) = NULL;
}
for (i=1; i < num_levels; i++)
{
hypre_ParVectorDestroy(hypre_ParAMGDataFArray(amg_data)[i]);
hypre_ParVectorDestroy(hypre_ParAMGDataUArray(amg_data)[i]);
if (hypre_ParAMGDataAArray(amg_data)[i])
hypre_ParCSRMatrixDestroy(hypre_ParAMGDataAArray(amg_data)[i]);
if (hypre_ParAMGDataPArray(amg_data)[i-1])
hypre_ParCSRMatrixDestroy(hypre_ParAMGDataPArray(amg_data)[i-1]);
/* RL */
if (hypre_ParAMGDataRestriction(amg_data))
{
if (hypre_ParAMGDataRArray(amg_data)[i-1])
{
hypre_ParCSRMatrixDestroy(hypre_ParAMGDataRArray(amg_data)[i-1]);
}
}
hypre_TFree(hypre_ParAMGDataCFMarkerArray(amg_data)[i-1], HYPRE_MEMORY_HOST);
/* get rid of any block structures */
if (hypre_ParAMGDataABlockArray(amg_data)[i])
hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataABlockArray(amg_data)[i]);
if (hypre_ParAMGDataPBlockArray(amg_data)[i-1])
hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataPBlockArray(amg_data)[i-1]);
/* RL */
if (hypre_ParAMGDataRestriction(amg_data))
{
if (hypre_ParAMGDataRBlockArray(amg_data)[i-1])
{
hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataRBlockArray(amg_data)[i-1]);
}
}
}
if (hypre_ParAMGDataLambda(amg_data))
{
hypre_ParCSRMatrixDestroy(hypre_ParAMGDataLambda(amg_data));
}
if (hypre_ParAMGDataAtilde(amg_data))
{
hypre_ParCSRMatrix *Atilde = hypre_ParAMGDataAtilde(amg_data);
hypre_CSRMatrixDestroy(hypre_ParCSRMatrixDiag(Atilde));
hypre_CSRMatrixDestroy(hypre_ParCSRMatrixOffd(Atilde));
hypre_TFree(Atilde, HYPRE_MEMORY_HOST);
}
if (hypre_ParAMGDataXtilde(amg_data))
hypre_ParVectorDestroy(hypre_ParAMGDataXtilde(amg_data));
if (hypre_ParAMGDataRtilde(amg_data))
hypre_ParVectorDestroy(hypre_ParAMGDataRtilde(amg_data));
if (hypre_ParAMGDataL1Norms(amg_data))
{
for (i=0; i < num_levels; i++)
if (hypre_ParAMGDataL1Norms(amg_data)[i])
hypre_TFree(hypre_ParAMGDataL1Norms(amg_data)[i], HYPRE_MEMORY_SHARED);
hypre_TFree(hypre_ParAMGDataL1Norms(amg_data), HYPRE_MEMORY_HOST);
}
if (hypre_ParAMGDataChebyCoefs(amg_data))
{
for (i=0; i < num_levels; i++)
if (hypre_ParAMGDataChebyCoefs(amg_data)[i])
hypre_TFree(hypre_ParAMGDataChebyCoefs(amg_data)[i], HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataChebyCoefs(amg_data), HYPRE_MEMORY_HOST);
}
if (hypre_ParAMGDataChebyDS(amg_data))
{
for (i=0; i < num_levels; i++)
if (hypre_ParAMGDataChebyDS(amg_data)[i])
hypre_TFree(hypre_ParAMGDataChebyDS(amg_data)[i], HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataChebyDS(amg_data), HYPRE_MEMORY_HOST);
}
if (hypre_ParAMGDataDinv(amg_data))
hypre_TFree(hypre_ParAMGDataDinv(amg_data), HYPRE_MEMORY_HOST);
/* get rid of a fine level block matrix */
if (hypre_ParAMGDataABlockArray(amg_data))
if (hypre_ParAMGDataABlockArray(amg_data)[0])
hypre_ParCSRBlockMatrixDestroy(hypre_ParAMGDataABlockArray(amg_data)[0]);
/* see comments in par_coarsen.c regarding special case for CF_marker */
if (num_levels == 1)
{
hypre_TFree(hypre_ParAMGDataCFMarkerArray(amg_data)[0], HYPRE_MEMORY_HOST);
}
hypre_ParVectorDestroy(hypre_ParAMGDataVtemp(amg_data));
hypre_TFree(hypre_ParAMGDataFArray(amg_data), HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataUArray(amg_data), HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataAArray(amg_data), HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataABlockArray(amg_data), HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataPBlockArray(amg_data), HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataPArray(amg_data), HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataCFMarkerArray(amg_data), HYPRE_MEMORY_HOST);
if (hypre_ParAMGDataRtemp(amg_data))
hypre_ParVectorDestroy(hypre_ParAMGDataRtemp(amg_data));
if (hypre_ParAMGDataPtemp(amg_data))
hypre_ParVectorDestroy(hypre_ParAMGDataPtemp(amg_data));
if (hypre_ParAMGDataZtemp(amg_data))
hypre_ParVectorDestroy(hypre_ParAMGDataZtemp(amg_data));
if (hypre_ParAMGDataDofFuncArray(amg_data))
{
for (i=1; i < num_levels; i++)
hypre_TFree(hypre_ParAMGDataDofFuncArray(amg_data)[i], HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataDofFuncArray(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataDofFuncArray(amg_data) = NULL;
}
if (hypre_ParAMGDataRestriction(amg_data))
{
hypre_TFree(hypre_ParAMGDataRBlockArray(amg_data),HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataRArray(amg_data),HYPRE_MEMORY_HOST);
hypre_ParAMGDataRArray(amg_data) = NULL;
}
if (hypre_ParAMGDataDofPointArray(amg_data))
{
for (i=0; i < num_levels; i++)
hypre_TFree(hypre_ParAMGDataDofPointArray(amg_data)[i], HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataDofPointArray(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataDofPointArray(amg_data) = NULL;
}
if (hypre_ParAMGDataPointDofMapArray(amg_data))
{
for (i=0; i < num_levels; i++)
hypre_TFree(hypre_ParAMGDataPointDofMapArray(amg_data)[i], HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataPointDofMapArray(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataPointDofMapArray(amg_data) = NULL;
}
if (smooth_num_levels)
{
if (hypre_ParAMGDataSmoothType(amg_data) == 7)
{
for (i=0; i < smooth_num_levels; i++)
{
HYPRE_ParCSRPilutDestroy(smoother[i]);
}
}
else if (hypre_ParAMGDataSmoothType(amg_data) == 8)
{
for (i=0; i < smooth_num_levels; i++)
{
HYPRE_ParCSRParaSailsDestroy(smoother[i]);
}
}
else if (hypre_ParAMGDataSmoothType(amg_data) == 9)
{
for (i=0; i < smooth_num_levels; i++)
{
HYPRE_EuclidDestroy(smoother[i]);
}
}
else if (hypre_ParAMGDataSmoothType(amg_data) == 6)
{
for (i=0; i < smooth_num_levels; i++)
{
HYPRE_SchwarzDestroy(smoother[i]);
}
}
hypre_TFree(hypre_ParAMGDataSmoother(amg_data), HYPRE_MEMORY_HOST);
}
if ( hypre_ParAMGDataResidual(amg_data) ) {
/* jfp: was... hypre_TFree( hypre_ParAMGDataResidual(amg_data) );*/
hypre_ParVectorDestroy( hypre_ParAMGDataResidual(amg_data) );
hypre_ParAMGDataResidual(amg_data) = NULL;
}
if (hypre_ParAMGInterpVecVariant(amg_data) > 0
&& hypre_ParAMGNumInterpVectors(amg_data) > 0)
{
HYPRE_Int j;
HYPRE_Int num_vecs = hypre_ParAMGNumInterpVectors(amg_data);
hypre_ParVector **sm_vecs;
HYPRE_Int num_il;
num_il = hypre_min(hypre_ParAMGNumLevelsInterpVectors(amg_data),num_levels);
/* don't destroy lev = 0 - this was user input */
for (i = 1; i< num_il; i++)
{
sm_vecs = hypre_ParAMGInterpVectorsArray(amg_data)[i];
for (j = 0; j< num_vecs; j++)
{
hypre_ParVectorDestroy(sm_vecs[j]);
}
hypre_TFree(sm_vecs, HYPRE_MEMORY_HOST);
}
hypre_TFree( hypre_ParAMGInterpVectorsArray(amg_data), HYPRE_MEMORY_HOST);
}
if (amg) hypre_BoomerAMGDestroy(amg);
if (hypre_ParAMGDataACoarse(amg_data))
hypre_ParCSRMatrixDestroy(hypre_ParAMGDataACoarse(amg_data));
if (hypre_ParAMGDataUCoarse(amg_data))
hypre_ParVectorDestroy(hypre_ParAMGDataUCoarse(amg_data));
if (hypre_ParAMGDataFCoarse(amg_data))
hypre_ParVectorDestroy(hypre_ParAMGDataFCoarse(amg_data));
/* destroy Cpoint_keep data */
if (hypre_ParAMGDataCPointKeepMarkerArray(amg_data))
{
for (i=0; i<hypre_ParAMGDataCPointKeepLevel(amg_data); i++)
{
if (hypre_ParAMGDataCPointKeepMarkerArray(amg_data)[i])
{
hypre_TFree(hypre_ParAMGDataCPointKeepMarkerArray(amg_data)[i], HYPRE_MEMORY_HOST);
hypre_ParAMGDataCPointKeepMarkerArray(amg_data)[i] = NULL;
}
}
hypre_TFree(hypre_ParAMGDataCPointKeepMarkerArray(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataCPointKeepMarkerArray(amg_data) = NULL;
}
if (hypre_ParAMGDataAMat(amg_data)) hypre_TFree(hypre_ParAMGDataAMat(amg_data), HYPRE_MEMORY_HOST);
if (hypre_ParAMGDataAInv(amg_data)) hypre_TFree(hypre_ParAMGDataAInv(amg_data), HYPRE_MEMORY_HOST);
if (hypre_ParAMGDataBVec(amg_data)) hypre_TFree(hypre_ParAMGDataBVec(amg_data), HYPRE_MEMORY_HOST);
if (hypre_ParAMGDataCommInfo(amg_data)) hypre_TFree(hypre_ParAMGDataCommInfo(amg_data), HYPRE_MEMORY_HOST);
if (new_comm != hypre_MPI_COMM_NULL)
{
hypre_MPI_Comm_free (&new_comm);
}
hypre_TFree(amg_data, HYPRE_MEMORY_HOST);
HYPRE_ANNOTATION_END("BoomerAMG.destroy");
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Routines to set the setup phase parameters
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetRestriction( void *data,
HYPRE_Int restr_par )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
/* RL: currently, only 0: R = P^T
* 1: AIR
* 2: AIR-2
* 15: a special version of AIR-2 with less communication cost
* k(k>=3,k!=15): Neumann AIR of degree k-3
*/
if (restr_par < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataRestriction(amg_data) = restr_par;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetIsTriangular(void *data,
HYPRE_Int is_triangular )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataIsTriangular(amg_data) = is_triangular;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetGMRESSwitchR(void *data,
HYPRE_Int gmres_switch )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataGMRESSwitchR(amg_data) = gmres_switch;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetMaxLevels( void *data,
HYPRE_Int max_levels )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
HYPRE_Int old_max_levels;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (max_levels < 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
old_max_levels = hypre_ParAMGDataMaxLevels(amg_data);
if (old_max_levels < max_levels)
{
HYPRE_Real *relax_weight, *omega, *nongal_tol_array;
HYPRE_Real relax_wt, outer_wt, nongalerkin_tol;
HYPRE_Int i;
relax_weight = hypre_ParAMGDataRelaxWeight(amg_data);
if (relax_weight)
{
relax_wt = hypre_ParAMGDataUserRelaxWeight(amg_data);
relax_weight = hypre_TReAlloc(relax_weight, HYPRE_Real, max_levels, HYPRE_MEMORY_HOST);
for (i=old_max_levels; i < max_levels; i++)
relax_weight[i] = relax_wt;
hypre_ParAMGDataRelaxWeight(amg_data) = relax_weight;
}
omega = hypre_ParAMGDataOmega(amg_data);
if (omega)
{
outer_wt = hypre_ParAMGDataOuterWt(amg_data);
omega = hypre_TReAlloc(omega, HYPRE_Real, max_levels, HYPRE_MEMORY_HOST);
for (i=old_max_levels; i < max_levels; i++)
omega[i] = outer_wt;
hypre_ParAMGDataOmega(amg_data) = omega;
}
nongal_tol_array = hypre_ParAMGDataNonGalTolArray(amg_data);
if (nongal_tol_array)
{
nongalerkin_tol = hypre_ParAMGDataNonGalerkinTol(amg_data);
nongal_tol_array = hypre_TReAlloc(nongal_tol_array, HYPRE_Real, max_levels, HYPRE_MEMORY_HOST);
for (i=old_max_levels; i < max_levels; i++)
nongal_tol_array[i] = nongalerkin_tol;
hypre_ParAMGDataNonGalTolArray(amg_data) = nongal_tol_array;
}
}
hypre_ParAMGDataMaxLevels(amg_data) = max_levels;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetMaxLevels( void *data,
HYPRE_Int * max_levels )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*max_levels = hypre_ParAMGDataMaxLevels(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetMaxCoarseSize( void *data,
HYPRE_Int max_coarse_size )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (max_coarse_size < 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataMaxCoarseSize(amg_data) = max_coarse_size;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetMaxCoarseSize( void *data,
HYPRE_Int * max_coarse_size )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*max_coarse_size = hypre_ParAMGDataMaxCoarseSize(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetMinCoarseSize( void *data,
HYPRE_Int min_coarse_size )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (min_coarse_size < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataMinCoarseSize(amg_data) = min_coarse_size;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetMinCoarseSize( void *data,
HYPRE_Int * min_coarse_size )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*min_coarse_size = hypre_ParAMGDataMinCoarseSize(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSeqThreshold( void *data,
HYPRE_Int seq_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (seq_threshold < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataSeqThreshold(amg_data) = seq_threshold;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetSeqThreshold( void *data,
HYPRE_Int * seq_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*seq_threshold = hypre_ParAMGDataSeqThreshold(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetRedundant( void *data,
HYPRE_Int redundant )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (redundant < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataRedundant(amg_data) = redundant;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetRedundant( void *data,
HYPRE_Int * redundant )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*redundant = hypre_ParAMGDataRedundant(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetStrongThreshold( void *data,
HYPRE_Real strong_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (strong_threshold < 0 || strong_threshold > 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataStrongThreshold(amg_data) = strong_threshold;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetStrongThreshold( void *data,
HYPRE_Real * strong_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*strong_threshold = hypre_ParAMGDataStrongThreshold(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetStrongThresholdR( void *data,
HYPRE_Real strong_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (strong_threshold < 0 || strong_threshold > 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataStrongThresholdR(amg_data) = strong_threshold;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetStrongThresholdR( void *data,
HYPRE_Real *strong_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*strong_threshold = hypre_ParAMGDataStrongThresholdR(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetFilterThresholdR( void *data,
HYPRE_Real filter_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (filter_threshold < 0 || filter_threshold > 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataFilterThresholdR(amg_data) = filter_threshold;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetFilterThresholdR( void *data,
HYPRE_Real *filter_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*filter_threshold = hypre_ParAMGDataFilterThresholdR(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSabs( void *data,
HYPRE_Int Sabs )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataSabs(amg_data) = Sabs != 0;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetMaxRowSum( void *data,
HYPRE_Real max_row_sum )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (max_row_sum <= 0 || max_row_sum > 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataMaxRowSum(amg_data) = max_row_sum;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetMaxRowSum( void *data,
HYPRE_Real * max_row_sum )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*max_row_sum = hypre_ParAMGDataMaxRowSum(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetTruncFactor( void *data,
HYPRE_Real trunc_factor )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (trunc_factor < 0 || trunc_factor >= 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataTruncFactor(amg_data) = trunc_factor;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetTruncFactor( void *data,
HYPRE_Real * trunc_factor )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*trunc_factor = hypre_ParAMGDataTruncFactor(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetPMaxElmts( void *data,
HYPRE_Int P_max_elmts )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (P_max_elmts < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataPMaxElmts(amg_data) = P_max_elmts;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetPMaxElmts( void *data,
HYPRE_Int * P_max_elmts )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*P_max_elmts = hypre_ParAMGDataPMaxElmts(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetJacobiTruncThreshold( void *data,
HYPRE_Real jacobi_trunc_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (jacobi_trunc_threshold < 0 || jacobi_trunc_threshold >= 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataJacobiTruncThreshold(amg_data) = jacobi_trunc_threshold;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetJacobiTruncThreshold( void *data,
HYPRE_Real * jacobi_trunc_threshold )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*jacobi_trunc_threshold = hypre_ParAMGDataJacobiTruncThreshold(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetPostInterpType( void *data,
HYPRE_Int post_interp_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (post_interp_type < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataPostInterpType(amg_data) = post_interp_type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetPostInterpType( void *data,
HYPRE_Int * post_interp_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*post_interp_type = hypre_ParAMGDataPostInterpType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSCommPkgSwitch( void *data,
HYPRE_Real S_commpkg_switch )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataSCommPkgSwitch(amg_data) = S_commpkg_switch;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetSCommPkgSwitch( void *data,
HYPRE_Real * S_commpkg_switch )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*S_commpkg_switch = hypre_ParAMGDataSCommPkgSwitch(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetInterpType( void *data,
HYPRE_Int interp_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if ((interp_type < 0 || interp_type > 25) && interp_type != 100)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataInterpType(amg_data) = interp_type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetInterpType( void *data,
HYPRE_Int * interp_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*interp_type = hypre_ParAMGDataInterpType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSepWeight( void *data,
HYPRE_Int sep_weight )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataSepWeight(amg_data) = sep_weight;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetMinIter( void *data,
HYPRE_Int min_iter )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataMinIter(amg_data) = min_iter;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetMinIter( void *data,
HYPRE_Int * min_iter )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*min_iter = hypre_ParAMGDataMinIter(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetMaxIter( void *data,
HYPRE_Int max_iter )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (max_iter < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataMaxIter(amg_data) = max_iter;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetMaxIter( void *data,
HYPRE_Int * max_iter )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*max_iter = hypre_ParAMGDataMaxIter(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetCoarsenType( void *data,
HYPRE_Int coarsen_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataCoarsenType(amg_data) = coarsen_type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetCoarsenType( void *data,
HYPRE_Int * coarsen_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*coarsen_type = hypre_ParAMGDataCoarsenType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetMeasureType( void *data,
HYPRE_Int measure_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataMeasureType(amg_data) = measure_type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetMeasureType( void *data,
HYPRE_Int * measure_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*measure_type = hypre_ParAMGDataMeasureType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSetupType( void *data,
HYPRE_Int setup_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataSetupType(amg_data) = setup_type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetSetupType( void *data,
HYPRE_Int * setup_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*setup_type = hypre_ParAMGDataSetupType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetCycleType( void *data,
HYPRE_Int cycle_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (cycle_type < 0 || cycle_type > 2)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataCycleType(amg_data) = cycle_type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetCycleType( void *data,
HYPRE_Int * cycle_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*cycle_type = hypre_ParAMGDataCycleType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetFCycle( void *data,
HYPRE_Int fcycle )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataFCycle(amg_data) = fcycle != 0;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetFCycle( void *data,
HYPRE_Int *fcycle )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*fcycle = hypre_ParAMGDataFCycle(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetConvergeType( void *data,
HYPRE_Int type )
{
/* type 0: default. relative over ||b||
* 1: relative over ||r0||
*/
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
/*
if ()
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
*/
hypre_ParAMGDataConvergeType(amg_data) = type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetConvergeType( void *data,
HYPRE_Int *type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*type = hypre_ParAMGDataConvergeType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetTol( void *data,
HYPRE_Real tol )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (tol < 0 || tol > 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataTol(amg_data) = tol;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetTol( void *data,
HYPRE_Real * tol )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*tol = hypre_ParAMGDataTol(amg_data);
return hypre_error_flag;
}
/* The "Get" function for SetNumSweeps is GetCycleNumSweeps. */
HYPRE_Int
hypre_BoomerAMGSetNumSweeps( void *data,
HYPRE_Int num_sweeps )
{
HYPRE_Int i;
HYPRE_Int *num_grid_sweeps;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (num_sweeps < 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (hypre_ParAMGDataNumGridSweeps(amg_data) == NULL)
hypre_ParAMGDataNumGridSweeps(amg_data) = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
num_grid_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data);
for (i=0; i < 3; i++)
num_grid_sweeps[i] = num_sweeps;
num_grid_sweeps[3] = 1;
hypre_ParAMGDataUserNumSweeps(amg_data) = num_sweeps;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetCycleNumSweeps( void *data,
HYPRE_Int num_sweeps,
HYPRE_Int k )
{
HYPRE_Int i;
HYPRE_Int *num_grid_sweeps;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (num_sweeps < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (k < 1 || k > 3)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (hypre_ParAMGDataNumGridSweeps(amg_data) == NULL)
{
num_grid_sweeps = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
for (i=0; i < 4; i++)
num_grid_sweeps[i] = 1;
hypre_ParAMGDataNumGridSweeps(amg_data) = num_grid_sweeps;
}
hypre_ParAMGDataNumGridSweeps(amg_data)[k] = num_sweeps;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetCycleNumSweeps( void *data,
HYPRE_Int * num_sweeps,
HYPRE_Int k )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (k < 1 || k > 3)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (hypre_ParAMGDataNumGridSweeps(amg_data) == NULL)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*num_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data)[k];
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetNumGridSweeps( void *data,
HYPRE_Int *num_grid_sweeps )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (!num_grid_sweeps)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (hypre_ParAMGDataNumGridSweeps(amg_data))
hypre_TFree(hypre_ParAMGDataNumGridSweeps(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataNumGridSweeps(amg_data) = num_grid_sweeps;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetNumGridSweeps( void *data,
HYPRE_Int ** num_grid_sweeps )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*num_grid_sweeps = hypre_ParAMGDataNumGridSweeps(amg_data);
return hypre_error_flag;
}
/* The "Get" function for SetRelaxType is GetCycleRelaxType. */
HYPRE_Int
hypre_BoomerAMGSetRelaxType( void *data,
HYPRE_Int relax_type )
{
HYPRE_Int i;
HYPRE_Int *grid_relax_type;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (relax_type < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (hypre_ParAMGDataGridRelaxType(amg_data) == NULL)
hypre_ParAMGDataGridRelaxType(amg_data) = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
for (i=0; i < 3; i++)
grid_relax_type[i] = relax_type;
grid_relax_type[3] = 9;
hypre_ParAMGDataUserCoarseRelaxType(amg_data) = 9;
hypre_ParAMGDataUserRelaxType(amg_data) = relax_type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetCycleRelaxType( void *data,
HYPRE_Int relax_type,
HYPRE_Int k )
{
HYPRE_Int i;
HYPRE_Int *grid_relax_type;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (k < 1 || k > 3)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (relax_type < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (hypre_ParAMGDataGridRelaxType(amg_data) == NULL)
{
grid_relax_type = hypre_CTAlloc(HYPRE_Int, 4, HYPRE_MEMORY_HOST);
for (i=0; i < 3; i++)
{
grid_relax_type[i] = 3;
}
grid_relax_type[3] = 9;
hypre_ParAMGDataGridRelaxType(amg_data) = grid_relax_type;
}
hypre_ParAMGDataGridRelaxType(amg_data)[k] = relax_type;
if (k == 3)
{
hypre_ParAMGDataUserCoarseRelaxType(amg_data) = relax_type;
}
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetCycleRelaxType( void *data,
HYPRE_Int * relax_type,
HYPRE_Int k )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (k < 1 || k > 3)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (hypre_ParAMGDataGridRelaxType(amg_data) == NULL)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*relax_type = hypre_ParAMGDataGridRelaxType(amg_data)[k];
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetRelaxOrder( void *data,
HYPRE_Int relax_order)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataRelaxOrder(amg_data) = relax_order;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetRelaxOrder( void *data,
HYPRE_Int * relax_order)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*relax_order = hypre_ParAMGDataRelaxOrder(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetGridRelaxType( void *data,
HYPRE_Int *grid_relax_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (!grid_relax_type)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (hypre_ParAMGDataGridRelaxType(amg_data))
hypre_TFree(hypre_ParAMGDataGridRelaxType(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataGridRelaxType(amg_data) = grid_relax_type;
hypre_ParAMGDataUserCoarseRelaxType(amg_data) = grid_relax_type[3];
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetGridRelaxType( void *data,
HYPRE_Int ** grid_relax_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*grid_relax_type = hypre_ParAMGDataGridRelaxType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetGridRelaxPoints( void *data,
HYPRE_Int **grid_relax_points )
{
HYPRE_Int i;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (!grid_relax_points)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (hypre_ParAMGDataGridRelaxPoints(amg_data))
{
for (i=0; i < 4; i++)
hypre_TFree(hypre_ParAMGDataGridRelaxPoints(amg_data)[i], HYPRE_MEMORY_HOST);
hypre_TFree(hypre_ParAMGDataGridRelaxPoints(amg_data), HYPRE_MEMORY_HOST);
}
hypre_ParAMGDataGridRelaxPoints(amg_data) = grid_relax_points;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetGridRelaxPoints( void *data,
HYPRE_Int *** grid_relax_points )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*grid_relax_points = hypre_ParAMGDataGridRelaxPoints(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetRelaxWeight( void *data,
HYPRE_Real *relax_weight )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (!relax_weight)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (hypre_ParAMGDataRelaxWeight(amg_data))
hypre_TFree(hypre_ParAMGDataRelaxWeight(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataRelaxWeight(amg_data) = relax_weight;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetRelaxWeight( void *data,
HYPRE_Real ** relax_weight )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*relax_weight = hypre_ParAMGDataRelaxWeight(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetRelaxWt( void *data,
HYPRE_Real relax_weight )
{
HYPRE_Int i, num_levels;
HYPRE_Real *relax_weight_array;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
num_levels = hypre_ParAMGDataMaxLevels(amg_data);
if (hypre_ParAMGDataRelaxWeight(amg_data) == NULL)
hypre_ParAMGDataRelaxWeight(amg_data) = hypre_CTAlloc(HYPRE_Real, num_levels, HYPRE_MEMORY_HOST);
relax_weight_array = hypre_ParAMGDataRelaxWeight(amg_data);
for (i=0; i < num_levels; i++)
relax_weight_array[i] = relax_weight;
hypre_ParAMGDataUserRelaxWeight(amg_data) = relax_weight;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetLevelRelaxWt( void *data,
HYPRE_Real relax_weight,
HYPRE_Int level )
{
HYPRE_Int i, num_levels;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
num_levels = hypre_ParAMGDataMaxLevels(amg_data);
if (level > num_levels-1 || level < 0)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (hypre_ParAMGDataRelaxWeight(amg_data) == NULL)
{
hypre_ParAMGDataRelaxWeight(amg_data) = hypre_CTAlloc(HYPRE_Real, num_levels, HYPRE_MEMORY_HOST);
for (i=0; i < num_levels; i++)
hypre_ParAMGDataRelaxWeight(amg_data)[i] = 1.0;
}
hypre_ParAMGDataRelaxWeight(amg_data)[level] = relax_weight;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetLevelRelaxWt( void *data,
HYPRE_Real * relax_weight,
HYPRE_Int level )
{
HYPRE_Int num_levels;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
num_levels = hypre_ParAMGDataMaxLevels(amg_data);
if (level > num_levels-1 || level < 0)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (hypre_ParAMGDataRelaxWeight(amg_data) == NULL)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*relax_weight = hypre_ParAMGDataRelaxWeight(amg_data)[level];
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetOmega( void *data,
HYPRE_Real *omega )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (!omega)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (hypre_ParAMGDataOmega(amg_data))
hypre_TFree(hypre_ParAMGDataOmega(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataOmega(amg_data) = omega;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetOmega( void *data,
HYPRE_Real ** omega )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*omega = hypre_ParAMGDataOmega(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetOuterWt( void *data,
HYPRE_Real omega )
{
HYPRE_Int i, num_levels;
HYPRE_Real *omega_array;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
num_levels = hypre_ParAMGDataMaxLevels(amg_data);
if (hypre_ParAMGDataOmega(amg_data) == NULL)
hypre_ParAMGDataOmega(amg_data) = hypre_CTAlloc(HYPRE_Real, num_levels, HYPRE_MEMORY_HOST);
omega_array = hypre_ParAMGDataOmega(amg_data);
for (i=0; i < num_levels; i++)
omega_array[i] = omega;
hypre_ParAMGDataOuterWt(amg_data) = omega;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetLevelOuterWt( void *data,
HYPRE_Real omega,
HYPRE_Int level )
{
HYPRE_Int i, num_levels;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
num_levels = hypre_ParAMGDataMaxLevels(amg_data);
if (level > num_levels-1)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (hypre_ParAMGDataOmega(amg_data) == NULL)
{
hypre_ParAMGDataOmega(amg_data) = hypre_CTAlloc(HYPRE_Real, num_levels, HYPRE_MEMORY_HOST);
for (i=0; i < num_levels; i++)
hypre_ParAMGDataOmega(amg_data)[i] = 1.0;
}
hypre_ParAMGDataOmega(amg_data)[level] = omega;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetLevelOuterWt( void *data,
HYPRE_Real * omega,
HYPRE_Int level )
{
HYPRE_Int num_levels;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
num_levels = hypre_ParAMGDataMaxLevels(amg_data);
if (level > num_levels-1)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
if (hypre_ParAMGDataOmega(amg_data) == NULL)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*omega = hypre_ParAMGDataOmega(amg_data)[level];
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSmoothType( void *data,
HYPRE_Int smooth_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataSmoothType(amg_data) = smooth_type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetSmoothType( void *data,
HYPRE_Int * smooth_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*smooth_type = hypre_ParAMGDataSmoothType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSmoothNumLevels( void *data,
HYPRE_Int smooth_num_levels )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (smooth_num_levels < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataSmoothNumLevels(amg_data) = smooth_num_levels;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetSmoothNumLevels( void *data,
HYPRE_Int * smooth_num_levels )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*smooth_num_levels = hypre_ParAMGDataSmoothNumLevels(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSmoothNumSweeps( void *data,
HYPRE_Int smooth_num_sweeps )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (smooth_num_sweeps < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataSmoothNumSweeps(amg_data) = smooth_num_sweeps;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetSmoothNumSweeps( void *data,
HYPRE_Int * smooth_num_sweeps )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*smooth_num_sweeps = hypre_ParAMGDataSmoothNumSweeps(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetLogging( void *data,
HYPRE_Int logging )
{
/* This function should be called before Setup. Logging changes
may require allocation or freeing of arrays, which is presently
only done there.
It may be possible to support logging changes at other times,
but there is little need.
*/
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataLogging(amg_data) = logging;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetLogging( void *data,
HYPRE_Int * logging )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*logging = hypre_ParAMGDataLogging(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetPrintLevel( void *data,
HYPRE_Int print_level )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataPrintLevel(amg_data) = print_level;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetPrintLevel( void *data,
HYPRE_Int * print_level )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*print_level = hypre_ParAMGDataPrintLevel(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetPrintFileName( void *data,
const char *print_file_name )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*)data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if ( strlen(print_file_name) > 256 )
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_sprintf(hypre_ParAMGDataLogFileName(amg_data), "%s", print_file_name);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetPrintFileName( void *data,
char ** print_file_name )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_sprintf( *print_file_name, "%s", hypre_ParAMGDataLogFileName(amg_data) );
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetNumIterations( void *data,
HYPRE_Int num_iterations )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataNumIterations(amg_data) = num_iterations;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetDebugFlag( void *data,
HYPRE_Int debug_flag )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataDebugFlag(amg_data) = debug_flag;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetDebugFlag( void *data,
HYPRE_Int * debug_flag )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*debug_flag = hypre_ParAMGDataDebugFlag(amg_data);
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* hypre_BoomerAMGSetGSMG
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetGSMG( void *data,
HYPRE_Int par )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
amg_data->gsmg = par;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* hypre_BoomerAMGSetNumSamples
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetNumSamples( void *data,
HYPRE_Int par )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
amg_data->num_samples = par;
return hypre_error_flag;
}
/* BM Aug 25, 2006 */
HYPRE_Int
hypre_BoomerAMGSetCGCIts( void *data,
HYPRE_Int its)
{
HYPRE_Int ierr = 0;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
hypre_ParAMGDataCGCIts(amg_data) = its;
return (ierr);
}
/* BM Oct 22, 2006 */
HYPRE_Int
hypre_BoomerAMGSetPlotGrids( void *data,
HYPRE_Int plotgrids)
{
HYPRE_Int ierr = 0;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
hypre_ParAMGDataPlotGrids(amg_data) = plotgrids;
return (ierr);
}
HYPRE_Int
hypre_BoomerAMGSetPlotFileName( void *data,
const char *plot_file_name )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if ( strlen(plot_file_name)>251 )
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (strlen(plot_file_name)==0 )
hypre_sprintf(hypre_ParAMGDataPlotFileName(amg_data), "%s", "AMGgrids.CF.dat");
else
hypre_sprintf(hypre_ParAMGDataPlotFileName(amg_data), "%s", plot_file_name);
return hypre_error_flag;
}
/* BM Oct 17, 2006 */
HYPRE_Int
hypre_BoomerAMGSetCoordDim( void *data,
HYPRE_Int coorddim)
{
HYPRE_Int ierr = 0;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
hypre_ParAMGDataCoordDim(amg_data) = coorddim;
return (ierr);
}
HYPRE_Int
hypre_BoomerAMGSetCoordinates( void *data,
float *coordinates)
{
HYPRE_Int ierr = 0;
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
hypre_ParAMGDataCoordinates(amg_data) = coordinates;
return (ierr);
}
/*--------------------------------------------------------------------------
* Routines to set the problem data parameters
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetNumFunctions( void *data,
HYPRE_Int num_functions )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (num_functions < 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataNumFunctions(amg_data) = num_functions;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetNumFunctions( void *data,
HYPRE_Int * num_functions )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*num_functions = hypre_ParAMGDataNumFunctions(amg_data);
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicate whether to use nodal systems function
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetNodal( void *data,
HYPRE_Int nodal )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataNodal(amg_data) = nodal;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicate number of levels for nodal coarsening
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetNodalLevels( void *data,
HYPRE_Int nodal_levels )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataNodalLevels(amg_data) = nodal_levels;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicate how to treat diag for primary matrix with nodal systems function
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetNodalDiag( void *data,
HYPRE_Int nodal )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataNodalDiag(amg_data) = nodal;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicate the degree of aggressive coarsening
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetNumPaths( void *data,
HYPRE_Int num_paths )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (num_paths < 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataNumPaths(amg_data) = num_paths;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates the number of levels of aggressive coarsening
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetAggNumLevels( void *data,
HYPRE_Int agg_num_levels )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (agg_num_levels < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataAggNumLevels(amg_data) = agg_num_levels;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates the interpolation used with aggressive coarsening
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetAggInterpType( void *data,
HYPRE_Int agg_interp_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (agg_interp_type < 0 || agg_interp_type > 4)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataAggInterpType(amg_data) = agg_interp_type;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates max number of elements per row for aggressive coarsening
* interpolation
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetAggPMaxElmts( void *data,
HYPRE_Int agg_P_max_elmts )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (agg_P_max_elmts < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataAggPMaxElmts(amg_data) = agg_P_max_elmts;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates max number of elements per row for smoothed
* interpolation in mult-additive or simple method
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetMultAddPMaxElmts( void *data,
HYPRE_Int add_P_max_elmts )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (add_P_max_elmts < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataMultAddPMaxElmts(amg_data) = add_P_max_elmts;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates Relaxtion Type for Additive Cycle
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetAddRelaxType( void *data,
HYPRE_Int add_rlx_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataAddRelaxType(amg_data) = add_rlx_type;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates Relaxation Weight for Additive Cycle
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetAddRelaxWt( void *data,
HYPRE_Real add_rlx_wt )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataAddRelaxWt(amg_data) = add_rlx_wt;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates max number of elements per row for 1st stage of aggressive
* coarsening two-stage interpolation
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetAggP12MaxElmts( void *data,
HYPRE_Int agg_P12_max_elmts )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (agg_P12_max_elmts < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataAggP12MaxElmts(amg_data) = agg_P12_max_elmts;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates truncation factor for aggressive coarsening interpolation
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetAggTruncFactor( void *data,
HYPRE_Real agg_trunc_factor )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (agg_trunc_factor < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataAggTruncFactor(amg_data) = agg_trunc_factor;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates the truncation factor for smoothed interpolation when using
* mult-additive or simple method
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetMultAddTruncFactor( void *data,
HYPRE_Real add_trunc_factor )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (add_trunc_factor < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataMultAddTruncFactor(amg_data) = add_trunc_factor;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates truncation factor for 1 stage of aggressive coarsening
* two stage interpolation
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetAggP12TruncFactor( void *data,
HYPRE_Real agg_P12_trunc_factor )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (agg_P12_trunc_factor < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataAggP12TruncFactor(amg_data) = agg_P12_trunc_factor;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates the number of relaxation steps for Compatible relaxation
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetNumCRRelaxSteps( void *data,
HYPRE_Int num_CR_relax_steps )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (num_CR_relax_steps < 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataNumCRRelaxSteps(amg_data) = num_CR_relax_steps;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates the desired convergence rate for Compatible relaxation
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetCRRate( void *data,
HYPRE_Real CR_rate )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataCRRate(amg_data) = CR_rate;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates the desired convergence rate for Compatible relaxation
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetCRStrongTh( void *data,
HYPRE_Real CR_strong_th )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataCRStrongTh(amg_data) = CR_strong_th;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates the drop tolerance for A-matrices from the 2nd level of AMG
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetADropTol( void *data,
HYPRE_Real A_drop_tol )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataADropTol(amg_data) = A_drop_tol;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetADropType( void *data,
HYPRE_Int A_drop_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataADropType(amg_data) = A_drop_type;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates which independent set algorithm is used for CR
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetISType( void *data,
HYPRE_Int IS_type )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (IS_type < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataISType(amg_data) = IS_type;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* Indicates whether to use CG for compatible relaxation
*--------------------------------------------------------------------------*/
HYPRE_Int
hypre_BoomerAMGSetCRUseCG( void *data,
HYPRE_Int CR_use_CG )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataCRUseCG(amg_data) = CR_use_CG;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetNumPoints( void *data,
HYPRE_Int num_points )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataNumPoints(amg_data) = num_points;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetDofFunc( void *data,
HYPRE_Int *dof_func )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_TFree(hypre_ParAMGDataDofFunc(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataDofFunc(amg_data) = dof_func;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetPointDofMap( void *data,
HYPRE_Int *point_dof_map )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_TFree(hypre_ParAMGDataPointDofMap(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataPointDofMap(amg_data) = point_dof_map;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetDofPoint( void *data,
HYPRE_Int *dof_point )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_TFree(hypre_ParAMGDataDofPoint(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataDofPoint(amg_data) = dof_point;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetNumIterations( void *data,
HYPRE_Int *num_iterations )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*num_iterations = hypre_ParAMGDataNumIterations(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetCumNumIterations( void *data,
HYPRE_Int *cum_num_iterations )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
#ifdef CUMNUMIT
*cum_num_iterations = hypre_ParAMGDataCumNumIterations(amg_data);
#endif
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetResidual( void * data, hypre_ParVector ** resid )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*resid = hypre_ParAMGDataResidual( amg_data );
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetRelResidualNorm( void *data,
HYPRE_Real *rel_resid_norm )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*rel_resid_norm = hypre_ParAMGDataRelativeResidualNorm(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetVariant( void *data,
HYPRE_Int variant)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (variant < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataVariant(amg_data) = variant;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetVariant( void *data,
HYPRE_Int * variant)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*variant = hypre_ParAMGDataVariant(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetOverlap( void *data,
HYPRE_Int overlap)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (overlap < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataOverlap(amg_data) = overlap;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetOverlap( void *data,
HYPRE_Int * overlap)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*overlap = hypre_ParAMGDataOverlap(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetDomainType( void *data,
HYPRE_Int domain_type)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (domain_type < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataDomainType(amg_data) = domain_type;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetDomainType( void *data,
HYPRE_Int * domain_type)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*domain_type = hypre_ParAMGDataDomainType(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSchwarzRlxWeight( void *data,
HYPRE_Real schwarz_rlx_weight)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*)data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataSchwarzRlxWeight(amg_data) = schwarz_rlx_weight;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetSchwarzRlxWeight( void *data,
HYPRE_Real * schwarz_rlx_weight)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*schwarz_rlx_weight = hypre_ParAMGDataSchwarzRlxWeight(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSchwarzUseNonSymm( void *data,
HYPRE_Int use_nonsymm)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataSchwarzUseNonSymm(amg_data) = use_nonsymm;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSym( void *data,
HYPRE_Int sym)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataSym(amg_data) = sym;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetLevel( void *data,
HYPRE_Int level)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataLevel(amg_data) = level;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetThreshold( void *data,
HYPRE_Real thresh)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataThreshold(amg_data) = thresh;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetFilter( void *data,
HYPRE_Real filter)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataFilter(amg_data) = filter;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetDropTol( void *data,
HYPRE_Real drop_tol)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataDropTol(amg_data) = drop_tol;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetMaxNzPerRow( void *data,
HYPRE_Int max_nz_per_row)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (max_nz_per_row < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataMaxNzPerRow(amg_data) = max_nz_per_row;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetEuclidFile( void *data,
char *euclidfile)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataEuclidFile(amg_data) = euclidfile;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetEuLevel( void *data,
HYPRE_Int eu_level)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataEuLevel(amg_data) = eu_level;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetEuSparseA( void *data,
HYPRE_Real eu_sparse_A)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataEuSparseA(amg_data) = eu_sparse_A;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetEuBJ( void *data,
HYPRE_Int eu_bj)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataEuBJ(amg_data) = eu_bj;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetChebyOrder( void *data,
HYPRE_Int order)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (order < 1)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataChebyOrder(amg_data) = order;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetChebyFraction( void *data,
HYPRE_Real ratio)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (ratio <= 0.0 || ratio > 1.0 )
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataChebyFraction(amg_data) = ratio;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetChebyEigEst( void *data,
HYPRE_Int cheby_eig_est)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (cheby_eig_est < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
hypre_ParAMGDataChebyEigEst(amg_data) = cheby_eig_est;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetChebyVariant( void *data,
HYPRE_Int cheby_variant)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataChebyVariant(amg_data) = cheby_variant;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetChebyScale( void *data,
HYPRE_Int cheby_scale)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataChebyScale(amg_data) = cheby_scale;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* hypre_BoomerAMGSetInterpVectors
* -used for post-interpolation fitting of smooth vectors
*--------------------------------------------------------------------------*/
HYPRE_Int hypre_BoomerAMGSetInterpVectors(void *solver,
HYPRE_Int num_vectors,
hypre_ParVector **interp_vectors)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) solver;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGInterpVectors(amg_data) = interp_vectors;
hypre_ParAMGNumInterpVectors(amg_data) = num_vectors;
return hypre_error_flag;
}
/*--------------------------------------------------------------------------
* hypre_BoomerAMGSetInterpVectorValues
* -used for post-interpolation fitting of smooth vectors
*--------------------------------------------------------------------------*/
/*HYPRE_Int hypre_BoomerAMGSetInterpVectorValues(void *solver,
HYPRE_Int num_vectors,
HYPRE_Complex *interp_vector_values)
{
hypre_ParAMGData *amg_data = solver;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGInterpVectors(amg_data) = interp_vectors;
hypre_ParAMGNumInterpVectors(amg_data) = num_vectors;
return hypre_error_flag;
}*/
HYPRE_Int hypre_BoomerAMGSetInterpVecVariant(void *solver,
HYPRE_Int var)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) solver;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (var < 1)
var = 0;
if (var > 3)
var = 3;
hypre_ParAMGInterpVecVariant(amg_data) = var;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetInterpVecQMax( void *data,
HYPRE_Int q_max)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGInterpVecQMax(amg_data) = q_max;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetInterpVecAbsQTrunc( void *data,
HYPRE_Real q_trunc)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGInterpVecAbsQTrunc(amg_data) = q_trunc;
return hypre_error_flag;
}
HYPRE_Int hypre_BoomerAMGSetSmoothInterpVectors(void *solver,
HYPRE_Int smooth_interp_vectors)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) solver;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGSmoothInterpVectors(amg_data) = smooth_interp_vectors;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetInterpRefine( void *data,
HYPRE_Int num_refine )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGInterpRefine(amg_data) = num_refine;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetInterpVecFirstLevel( void *data,
HYPRE_Int level )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGInterpVecFirstLevel(amg_data) = level;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetAdditive( void *data,
HYPRE_Int additive )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataAdditive(amg_data) = additive;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetAdditive( void *data,
HYPRE_Int * additive )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*additive = hypre_ParAMGDataAdditive(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetMultAdditive( void *data,
HYPRE_Int mult_additive )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataMultAdditive(amg_data) = mult_additive;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetMultAdditive( void *data,
HYPRE_Int * mult_additive )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*mult_additive = hypre_ParAMGDataMultAdditive(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetSimple( void *data,
HYPRE_Int simple )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataSimple(amg_data) = simple;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGGetSimple( void *data,
HYPRE_Int * simple )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
*simple = hypre_ParAMGDataSimple(amg_data);
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetAddLastLvl( void *data,
HYPRE_Int add_last_lvl )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
hypre_ParAMGDataAddLastLvl(amg_data) = add_last_lvl;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetNonGalerkinTol( void *data,
HYPRE_Real nongalerkin_tol)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
HYPRE_Int i, max_num_levels;
HYPRE_Real *nongal_tol_array;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (nongalerkin_tol < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
max_num_levels = hypre_ParAMGDataMaxLevels(amg_data);
nongal_tol_array = hypre_ParAMGDataNonGalTolArray(amg_data);
if (nongal_tol_array == NULL)
{
nongal_tol_array = hypre_CTAlloc(HYPRE_Real, max_num_levels, HYPRE_MEMORY_HOST);
hypre_ParAMGDataNonGalTolArray(amg_data) = nongal_tol_array;
}
hypre_ParAMGDataNonGalerkinTol(amg_data) = nongalerkin_tol;
for (i=0; i < max_num_levels; i++)
nongal_tol_array[i] = nongalerkin_tol;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetLevelNonGalerkinTol( void *data,
HYPRE_Real nongalerkin_tol,
HYPRE_Int level)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
HYPRE_Real *nongal_tol_array;
HYPRE_Int max_num_levels;
if (!amg_data)
{
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (nongalerkin_tol < 0)
{
hypre_error_in_arg(2);
return hypre_error_flag;
}
nongal_tol_array = hypre_ParAMGDataNonGalTolArray(amg_data);
max_num_levels = hypre_ParAMGDataMaxLevels(amg_data);
if (nongal_tol_array == NULL)
{
nongal_tol_array = hypre_CTAlloc(HYPRE_Real, max_num_levels, HYPRE_MEMORY_HOST);
hypre_ParAMGDataNonGalTolArray(amg_data) = nongal_tol_array;
}
if (level+1 > max_num_levels)
{
hypre_error_in_arg(3);
return hypre_error_flag;
}
nongal_tol_array[level] = nongalerkin_tol;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetNonGalerkTol( void *data,
HYPRE_Int nongalerk_num_tol,
HYPRE_Real *nongalerk_tol)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
hypre_ParAMGDataNonGalerkNumTol(amg_data) = nongalerk_num_tol;
hypre_ParAMGDataNonGalerkTol(amg_data) = nongalerk_tol;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetRAP2( void *data,
HYPRE_Int rap2 )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
hypre_ParAMGDataRAP2(amg_data) = rap2;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetModuleRAP2( void *data,
HYPRE_Int mod_rap2 )
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
hypre_ParAMGDataModularizedMatMat(amg_data) = mod_rap2;
return hypre_error_flag;
}
HYPRE_Int
hypre_BoomerAMGSetKeepTranspose( void *data,
HYPRE_Int keepTranspose)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
hypre_ParAMGDataKeepTranspose(amg_data) = keepTranspose;
return hypre_error_flag;
}
#ifdef HYPRE_USING_DSUPERLU
HYPRE_Int
hypre_BoomerAMGSetDSLUThreshold( void *data,
HYPRE_Int dslu_threshold)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
hypre_ParAMGDataDSLUThreshold(amg_data) = dslu_threshold;
return hypre_error_flag;
}
#endif
HYPRE_Int
hypre_BoomerAMGSetCpointsToKeep(void *data,
HYPRE_Int cpt_coarse_level,
HYPRE_Int num_cpt_coarse,
HYPRE_Int *cpt_coarse_index)
{
hypre_ParAMGData *amg_data = (hypre_ParAMGData*) data;
HYPRE_Int **C_point_marker_array = NULL;
HYPRE_Int *C_point_marker = NULL;
HYPRE_Int cpt_level;
HYPRE_Int i;
if (!amg_data)
{
hypre_printf("Warning! AMG object empty!\n");
hypre_error_in_arg(1);
return hypre_error_flag;
}
if (cpt_coarse_level < 0)
{
hypre_printf("Warning! cpt_coarse_level < 0 !\n");
hypre_error_in_arg(2);
return hypre_error_flag;
}
if (num_cpt_coarse < 0)
{
hypre_printf("Warning! num_cpt_coarse < 0 !\n");
hypre_error_in_arg(2);
return hypre_error_flag;
}
/* free data not previously destroyed */
if (hypre_ParAMGDataCPointKeepLevel(amg_data))
{
for (i=0; i<hypre_ParAMGDataCPointKeepLevel(amg_data); i++)
{
if (hypre_ParAMGDataCPointKeepMarkerArray(amg_data)[i])
{
hypre_TFree(hypre_ParAMGDataCPointKeepMarkerArray(amg_data)[i], HYPRE_MEMORY_HOST);
hypre_ParAMGDataCPointKeepMarkerArray(amg_data)[i] = NULL;
}
}
hypre_TFree(hypre_ParAMGDataCPointKeepMarkerArray(amg_data), HYPRE_MEMORY_HOST);
hypre_ParAMGDataCPointKeepMarkerArray(amg_data) = NULL;
}
/* set Cpoint_keep data */
if (hypre_ParAMGDataMaxLevels(amg_data) < cpt_coarse_level)
{
cpt_level = hypre_ParAMGDataNumLevels(amg_data);
}
else
{
cpt_level = cpt_coarse_level;
}
if (cpt_level)
{
C_point_marker_array = hypre_CTAlloc(HYPRE_Int*, cpt_level, HYPRE_MEMORY_HOST);
C_point_marker = hypre_CTAlloc(HYPRE_Int, num_cpt_coarse, HYPRE_MEMORY_HOST);
/* copy Cpoint indexes */
for (i=0; i<num_cpt_coarse; i++)
{
C_point_marker[i] = cpt_coarse_index[i];
}
C_point_marker_array[0] = C_point_marker;
}
hypre_ParAMGDataCPointKeepMarkerArray(amg_data) = C_point_marker_array;
hypre_ParAMGDataNumCPointKeep(amg_data) = num_cpt_coarse;
hypre_ParAMGDataCPointKeepLevel(amg_data) = cpt_level;
return hypre_error_flag;
}
| 25.62746 | 110 | 0.644189 | [
"object"
] |
43aac8e3ccc680123880d69715ba3eae500a8758 | 5,651 | h | C | Source/Plugins/bsfD3D11RenderAPI/BsD3D11RenderWindow.h | bmsq/bsf | 55a73e14040844961cb4b1a2f3fa68328fcf1a87 | [
"MIT"
] | 1 | 2018-04-16T12:14:52.000Z | 2018-04-16T12:14:52.000Z | Source/Plugins/bsfD3D11RenderAPI/BsD3D11RenderWindow.h | bmsq/bsf | 55a73e14040844961cb4b1a2f3fa68328fcf1a87 | [
"MIT"
] | null | null | null | Source/Plugins/bsfD3D11RenderAPI/BsD3D11RenderWindow.h | bmsq/bsf | 55a73e14040844961cb4b1a2f3fa68328fcf1a87 | [
"MIT"
] | null | null | null | //************************************ bs::framework - Copyright 2018 Marko Pintera **************************************//
//*********** Licensed under the MIT license. See LICENSE.md for full terms. This notice is not to be removed. ***********//
#pragma once
#include "BsD3D11Prerequisites.h"
#include "RenderAPI/BsRenderWindow.h"
namespace bs {
/** @addtogroup D3D11
* @{
*/
/**
* Render window implementation for Windows and DirectX 11.
*
* @note Sim thread only.
*/
class D3D11RenderWindow : public RenderWindow
{
public:
~D3D11RenderWindow() { }
/** @copydoc RenderWindow::screenToWindowPos */
void getCustomAttribute(const String& name, void* pData) const override;
/** @copydoc RenderWindow::screenToWindowPos */
Vector2I screenToWindowPos(const Vector2I& screenPos) const override;
/** @copydoc RenderWindow::windowToScreenPos */
Vector2I windowToScreenPos(const Vector2I& windowPos) const override;
/** @copydoc RenderWindow::getCore */
SPtr<ct::D3D11RenderWindow> getCore() const;
protected:
friend class D3D11RenderWindowManager;
friend class ct::D3D11RenderWindow;
D3D11RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId,
ct::D3D11Device& device, IDXGIFactory* DXGIFactory);
/** @copydoc RenderWindow::getProperties */
const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
/** @copydoc RenderWindow::syncProperties */
void syncProperties() override;
/** @copydoc RenderWindow::createCore */
SPtr<ct::CoreObject> createCore() const override;
/** Retrieves internal window handle. */
HWND getHWnd() const;
private:
ct::D3D11Device& mDevice;
IDXGIFactory* mDXGIFactory;
RenderWindowProperties mProperties;
};
namespace ct
{
/**
* Render window implementation for Windows and DirectX 11.
*
* @note Core thread only.
*/
class D3D11RenderWindow : public RenderWindow
{
public:
D3D11RenderWindow(const RENDER_WINDOW_DESC& desc, UINT32 windowId,
D3D11Device& device, IDXGIFactory* DXGIFactory);
~D3D11RenderWindow();
/** @copydoc RenderWindow::move */
void move(INT32 left, INT32 top) override;
/** @copydoc RenderWindow::resize */
void resize(UINT32 width, UINT32 height) override;
/** @copydoc RenderWindow::setHidden */
void setHidden(bool hidden) override;
/** @copydoc RenderWindow::setActive */
void setActive(bool state) override;
/** @copydoc RenderWindow::minimize */
void minimize() override;
/** @copydoc RenderWindow::maximize */
void maximize() override;
/** @copydoc RenderWindow::restore */
void restore() override;
/** @copydoc RenderWindow::setFullscreen(UINT32, UINT32, float, UINT32) */
void setFullscreen(UINT32 width, UINT32 height, float refreshRate = 60.0f, UINT32 monitorIdx = 0) override;
/** @copydoc RenderWindow::setFullscreen(const VideoMode&) */
void setFullscreen(const VideoMode& videoMode) override;
/** @copydoc RenderWindow::setWindowed */
void setWindowed(UINT32 width, UINT32 height) override;
/** @copydoc RenderWindow::setVSync */
void setVSync(bool enabled, UINT32 interval = 1) override;
/**
* Copies the contents of a frame buffer into the pre-allocated buffer.
*
* @param[out] dst Previously allocated buffer to read the contents into. Must be of valid size.
* @param[in] buffer Frame buffer to read the contents from.
*/
void copyToMemory(PixelData &dst, FrameBuffer buffer);
/** @copydoc RenderWindow::swapBuffers */
void swapBuffers(UINT32 syncMask = 0xFFFFFFFF) override;
/** @copydoc RenderWindow::getCustomAttribute */
void getCustomAttribute(const String& name, void* pData) const override;
/** @copydoc RenderWindow::_windowMovedOrResized */
void _windowMovedOrResized() override;
/** Returns presentation parameters used for creating the window swap chain. */
DXGI_SWAP_CHAIN_DESC* _getPresentationParameters() { return &mSwapChainDesc; }
/** Returns internal window handle. */
HWND _getWindowHandle() const;
protected:
friend class bs::D3D11RenderWindow;
/** @copydoc CoreObject::initialize */
void initialize() override;
/** Creates internal resources dependent on window size. */
void createSizeDependedD3DResources();
/** Destroys internal resources dependent on window size. */
void destroySizeDependedD3DResources();
/** Queries the current DXGI device. Make sure to release the returned object when done with it. */
IDXGIDevice* queryDxgiDevice();
/** Creates a swap chain for the window. */
void createSwapChain();
/** Resizes all buffers attached to the swap chain to the specified size. */
void resizeSwapChainBuffers(UINT32 width, UINT32 height);
/** @copydoc RenderWindow::getProperties */
const RenderTargetProperties& getPropertiesInternal() const override { return mProperties; }
/** @copydoc RenderWindow::getSyncedProperties */
RenderWindowProperties& getSyncedProperties() override { return mSyncedProperties; }
/** @copydoc RenderWindow::syncProperties */
void syncProperties() override;
protected:
D3D11Device& mDevice;
IDXGIFactory* mDXGIFactory;
bool mSizing;
bool mIsChild;
bool mShowOnSwap;
DXGI_SAMPLE_DESC mMultisampleType;
UINT32 mRefreshRateNumerator;
UINT32 mRefreshRateDenominator;
ID3D11Texture2D* mBackBuffer;
ID3D11RenderTargetView* mRenderTargetView;
SPtr<TextureView> mDepthStencilView;
SPtr<Texture> mDepthStencilBuffer;
IDXGISwapChain* mSwapChain;
DXGI_SWAP_CHAIN_DESC mSwapChainDesc;
Win32Window* mWindow;
RenderWindowProperties mProperties;
RenderWindowProperties mSyncedProperties;
};
/** @} */
}} | 30.38172 | 124 | 0.725889 | [
"render",
"object"
] |
43aec568ba7ca366ba52f4cadc0074617eb44faa | 14,091 | h | C | kernel/linux-5.4/include/linux/rtc/ds1685.h | josehu07/SplitFS | d7442fa67a17de7057664f91defbfdbf10dd7f4a | [
"Apache-2.0"
] | 27 | 2021-10-04T18:56:52.000Z | 2022-03-28T08:23:06.000Z | kernel/linux-5.4/include/linux/rtc/ds1685.h | josehu07/SplitFS | d7442fa67a17de7057664f91defbfdbf10dd7f4a | [
"Apache-2.0"
] | 1 | 2022-01-12T04:05:36.000Z | 2022-01-16T15:48:42.000Z | kernel/linux-5.4/include/linux/rtc/ds1685.h | josehu07/SplitFS | d7442fa67a17de7057664f91defbfdbf10dd7f4a | [
"Apache-2.0"
] | 6 | 2021-11-02T10:56:19.000Z | 2022-03-06T11:58:20.000Z | /* SPDX-License-Identifier: GPL-2.0-only */
/*
* Definitions for the registers, addresses, and platform data of the
* DS1685/DS1687-series RTC chips.
*
* This Driver also works for the DS17X85/DS17X87 RTC chips. Functionally
* similar to the DS1685/DS1687, they support a few extra features which
* include larger, battery-backed NV-SRAM, burst-mode access, and an RTC
* write counter.
*
* Copyright (C) 2011-2014 Joshua Kinard <kumba@gentoo.org>.
* Copyright (C) 2009 Matthias Fuchs <matthias.fuchs@esd-electronics.com>.
*
* References:
* DS1685/DS1687 3V/5V Real-Time Clocks, 19-5215, Rev 4/10.
* DS17x85/DS17x87 3V/5V Real-Time Clocks, 19-5222, Rev 4/10.
* DS1689/DS1693 3V/5V Serialized Real-Time Clocks, Rev 112105.
* Application Note 90, Using the Multiplex Bus RTC Extended Features.
*/
#ifndef _LINUX_RTC_DS1685_H_
#define _LINUX_RTC_DS1685_H_
#include <linux/rtc.h>
#include <linux/platform_device.h>
#include <linux/workqueue.h>
/**
* struct ds1685_priv - DS1685 private data structure.
* @dev: pointer to the rtc_device structure.
* @regs: iomapped base address pointer of the RTC registers.
* @regstep: padding/step size between registers (optional).
* @baseaddr: base address of the RTC device.
* @size: resource size.
* @lock: private lock variable for spin locking/unlocking.
* @work: private workqueue.
* @irq: IRQ number assigned to the RTC device.
* @prepare_poweroff: pointer to platform pre-poweroff function.
* @wake_alarm: pointer to platform wake alarm function.
* @post_ram_clear: pointer to platform post ram-clear function.
*/
struct ds1685_priv {
struct rtc_device *dev;
void __iomem *regs;
u32 regstep;
resource_size_t baseaddr;
size_t size;
int irq_num;
bool bcd_mode;
bool no_irq;
bool uie_unsupported;
bool alloc_io_resources;
u8 (*read)(struct ds1685_priv *, int);
void (*write)(struct ds1685_priv *, int, u8);
void (*prepare_poweroff)(void);
void (*wake_alarm)(void);
void (*post_ram_clear)(void);
};
/**
* struct ds1685_rtc_platform_data - platform data structure.
* @plat_prepare_poweroff: platform-specific pre-poweroff function.
* @plat_wake_alarm: platform-specific wake alarm function.
* @plat_post_ram_clear: platform-specific post ram-clear function.
*
* If your platform needs to use a custom padding/step size between
* registers, or uses one or more of the extended interrupts and needs special
* handling, then include this header file in your platform definition and
* set regstep and the plat_* pointers as appropriate.
*/
struct ds1685_rtc_platform_data {
const u32 regstep;
const bool bcd_mode;
const bool no_irq;
const bool uie_unsupported;
const bool alloc_io_resources;
u8 (*plat_read)(struct ds1685_priv *, int);
void (*plat_write)(struct ds1685_priv *, int, u8);
void (*plat_prepare_poweroff)(void);
void (*plat_wake_alarm)(void);
void (*plat_post_ram_clear)(void);
};
/*
* Time Registers.
*/
#define RTC_SECS 0x00 /* Seconds 00-59 */
#define RTC_SECS_ALARM 0x01 /* Alarm Seconds 00-59 */
#define RTC_MINS 0x02 /* Minutes 00-59 */
#define RTC_MINS_ALARM 0x03 /* Alarm Minutes 00-59 */
#define RTC_HRS 0x04 /* Hours 01-12 AM/PM || 00-23 */
#define RTC_HRS_ALARM 0x05 /* Alarm Hours 01-12 AM/PM || 00-23 */
#define RTC_WDAY 0x06 /* Day of Week 01-07 */
#define RTC_MDAY 0x07 /* Day of Month 01-31 */
#define RTC_MONTH 0x08 /* Month 01-12 */
#define RTC_YEAR 0x09 /* Year 00-99 */
#define RTC_CENTURY 0x48 /* Century 00-99 */
#define RTC_MDAY_ALARM 0x49 /* Alarm Day of Month 01-31 */
/*
* Bit masks for the Time registers in BCD Mode (DM = 0).
*/
#define RTC_SECS_BCD_MASK 0x7f /* - x x x x x x x */
#define RTC_MINS_BCD_MASK 0x7f /* - x x x x x x x */
#define RTC_HRS_12_BCD_MASK 0x1f /* - - - x x x x x */
#define RTC_HRS_24_BCD_MASK 0x3f /* - - x x x x x x */
#define RTC_MDAY_BCD_MASK 0x3f /* - - x x x x x x */
#define RTC_MONTH_BCD_MASK 0x1f /* - - - x x x x x */
#define RTC_YEAR_BCD_MASK 0xff /* x x x x x x x x */
/*
* Bit masks for the Time registers in BIN Mode (DM = 1).
*/
#define RTC_SECS_BIN_MASK 0x3f /* - - x x x x x x */
#define RTC_MINS_BIN_MASK 0x3f /* - - x x x x x x */
#define RTC_HRS_12_BIN_MASK 0x0f /* - - - - x x x x */
#define RTC_HRS_24_BIN_MASK 0x1f /* - - - x x x x x */
#define RTC_MDAY_BIN_MASK 0x1f /* - - - x x x x x */
#define RTC_MONTH_BIN_MASK 0x0f /* - - - - x x x x */
#define RTC_YEAR_BIN_MASK 0x7f /* - x x x x x x x */
/*
* Bit masks common for the Time registers in BCD or BIN Mode.
*/
#define RTC_WDAY_MASK 0x07 /* - - - - - x x x */
#define RTC_CENTURY_MASK 0xff /* x x x x x x x x */
#define RTC_MDAY_ALARM_MASK 0xff /* x x x x x x x x */
#define RTC_HRS_AMPM_MASK BIT(7) /* Mask for the AM/PM bit */
/*
* Control Registers.
*/
#define RTC_CTRL_A 0x0a /* Control Register A */
#define RTC_CTRL_B 0x0b /* Control Register B */
#define RTC_CTRL_C 0x0c /* Control Register C */
#define RTC_CTRL_D 0x0d /* Control Register D */
#define RTC_EXT_CTRL_4A 0x4a /* Extended Control Register 4A */
#define RTC_EXT_CTRL_4B 0x4b /* Extended Control Register 4B */
/*
* Bit names in Control Register A.
*/
#define RTC_CTRL_A_UIP BIT(7) /* Update In Progress */
#define RTC_CTRL_A_DV2 BIT(6) /* Countdown Chain */
#define RTC_CTRL_A_DV1 BIT(5) /* Oscillator Enable */
#define RTC_CTRL_A_DV0 BIT(4) /* Bank Select */
#define RTC_CTRL_A_RS2 BIT(2) /* Rate-Selection Bit 2 */
#define RTC_CTRL_A_RS3 BIT(3) /* Rate-Selection Bit 3 */
#define RTC_CTRL_A_RS1 BIT(1) /* Rate-Selection Bit 1 */
#define RTC_CTRL_A_RS0 BIT(0) /* Rate-Selection Bit 0 */
#define RTC_CTRL_A_RS_MASK 0x0f /* RS3 + RS2 + RS1 + RS0 */
/*
* Bit names in Control Register B.
*/
#define RTC_CTRL_B_SET BIT(7) /* SET Bit */
#define RTC_CTRL_B_PIE BIT(6) /* Periodic-Interrupt Enable */
#define RTC_CTRL_B_AIE BIT(5) /* Alarm-Interrupt Enable */
#define RTC_CTRL_B_UIE BIT(4) /* Update-Ended Interrupt-Enable */
#define RTC_CTRL_B_SQWE BIT(3) /* Square-Wave Enable */
#define RTC_CTRL_B_DM BIT(2) /* Data Mode */
#define RTC_CTRL_B_2412 BIT(1) /* 12-Hr/24-Hr Mode */
#define RTC_CTRL_B_DSE BIT(0) /* Daylight Savings Enable */
#define RTC_CTRL_B_PAU_MASK 0x70 /* PIE + AIE + UIE */
/*
* Bit names in Control Register C.
*
* BIT(0), BIT(1), BIT(2), & BIT(3) are unused, always return 0, and cannot
* be written to.
*/
#define RTC_CTRL_C_IRQF BIT(7) /* Interrupt-Request Flag */
#define RTC_CTRL_C_PF BIT(6) /* Periodic-Interrupt Flag */
#define RTC_CTRL_C_AF BIT(5) /* Alarm-Interrupt Flag */
#define RTC_CTRL_C_UF BIT(4) /* Update-Ended Interrupt Flag */
#define RTC_CTRL_C_PAU_MASK 0x70 /* PF + AF + UF */
/*
* Bit names in Control Register D.
*
* BIT(0) through BIT(6) are unused, always return 0, and cannot
* be written to.
*/
#define RTC_CTRL_D_VRT BIT(7) /* Valid RAM and Time */
/*
* Bit names in Extended Control Register 4A.
*
* On the DS1685/DS1687/DS1689/DS1693, BIT(4) and BIT(5) are reserved for
* future use. They can be read from and written to, but have no effect
* on the RTC's operation.
*
* On the DS17x85/DS17x87, BIT(5) is Burst-Mode Enable (BME), and allows
* access to the extended NV-SRAM by automatically incrementing the address
* register when they are read from or written to.
*/
#define RTC_CTRL_4A_VRT2 BIT(7) /* Auxillary Battery Status */
#define RTC_CTRL_4A_INCR BIT(6) /* Increment-in-Progress Status */
#define RTC_CTRL_4A_PAB BIT(3) /* Power-Active Bar Control */
#define RTC_CTRL_4A_RF BIT(2) /* RAM-Clear Flag */
#define RTC_CTRL_4A_WF BIT(1) /* Wake-Up Alarm Flag */
#define RTC_CTRL_4A_KF BIT(0) /* Kickstart Flag */
#if !defined(CONFIG_RTC_DRV_DS1685) && !defined(CONFIG_RTC_DRV_DS1689)
#define RTC_CTRL_4A_BME BIT(5) /* Burst-Mode Enable */
#endif
#define RTC_CTRL_4A_RWK_MASK 0x07 /* RF + WF + KF */
/*
* Bit names in Extended Control Register 4B.
*/
#define RTC_CTRL_4B_ABE BIT(7) /* Auxillary Battery Enable */
#define RTC_CTRL_4B_E32K BIT(6) /* Enable 32.768Hz on SQW Pin */
#define RTC_CTRL_4B_CS BIT(5) /* Crystal Select */
#define RTC_CTRL_4B_RCE BIT(4) /* RAM Clear-Enable */
#define RTC_CTRL_4B_PRS BIT(3) /* PAB Reset-Select */
#define RTC_CTRL_4B_RIE BIT(2) /* RAM Clear-Interrupt Enable */
#define RTC_CTRL_4B_WIE BIT(1) /* Wake-Up Alarm-Interrupt Enable */
#define RTC_CTRL_4B_KSE BIT(0) /* Kickstart Interrupt-Enable */
#define RTC_CTRL_4B_RWK_MASK 0x07 /* RIE + WIE + KSE */
/*
* Misc register names in Bank 1.
*
* The DV0 bit in Control Register A must be set to 1 for these registers
* to become available, including Extended Control Registers 4A & 4B.
*/
#define RTC_BANK1_SSN_MODEL 0x40 /* Model Number */
#define RTC_BANK1_SSN_BYTE_1 0x41 /* 1st Byte of Serial Number */
#define RTC_BANK1_SSN_BYTE_2 0x42 /* 2nd Byte of Serial Number */
#define RTC_BANK1_SSN_BYTE_3 0x43 /* 3rd Byte of Serial Number */
#define RTC_BANK1_SSN_BYTE_4 0x44 /* 4th Byte of Serial Number */
#define RTC_BANK1_SSN_BYTE_5 0x45 /* 5th Byte of Serial Number */
#define RTC_BANK1_SSN_BYTE_6 0x46 /* 6th Byte of Serial Number */
#define RTC_BANK1_SSN_CRC 0x47 /* Serial CRC Byte */
#define RTC_BANK1_RAM_DATA_PORT 0x53 /* Extended RAM Data Port */
/*
* Model-specific registers in Bank 1.
*
* The addresses below differ depending on the model of the RTC chip
* selected in the kernel configuration. Not all of these features are
* supported in the main driver at present.
*
* DS1685/DS1687 - Extended NV-SRAM address (LSB only).
* DS1689/DS1693 - Vcc, Vbat, Pwr Cycle Counters & Customer-specific S/N.
* DS17x85/DS17x87 - Extended NV-SRAM addresses (MSB & LSB) & Write counter.
*/
#if defined(CONFIG_RTC_DRV_DS1685)
#define RTC_BANK1_RAM_ADDR 0x50 /* NV-SRAM Addr */
#elif defined(CONFIG_RTC_DRV_DS1689)
#define RTC_BANK1_VCC_CTR_LSB 0x54 /* Vcc Counter Addr (LSB) */
#define RTC_BANK1_VCC_CTR_MSB 0x57 /* Vcc Counter Addr (MSB) */
#define RTC_BANK1_VBAT_CTR_LSB 0x58 /* Vbat Counter Addr (LSB) */
#define RTC_BANK1_VBAT_CTR_MSB 0x5b /* Vbat Counter Addr (MSB) */
#define RTC_BANK1_PWR_CTR_LSB 0x5c /* Pwr Cycle Counter Addr (LSB) */
#define RTC_BANK1_PWR_CTR_MSB 0x5d /* Pwr Cycle Counter Addr (MSB) */
#define RTC_BANK1_UNIQ_SN 0x60 /* Customer-specific S/N */
#else /* DS17x85/DS17x87 */
#define RTC_BANK1_RAM_ADDR_LSB 0x50 /* NV-SRAM Addr (LSB) */
#define RTC_BANK1_RAM_ADDR_MSB 0x51 /* NV-SRAM Addr (MSB) */
#define RTC_BANK1_WRITE_CTR 0x5e /* RTC Write Counter */
#endif
/*
* Model numbers.
*
* The DS1688/DS1691 and DS1689/DS1693 chips share the same model number
* and the manual doesn't indicate any major differences. As such, they
* are regarded as the same chip in this driver.
*/
#define RTC_MODEL_DS1685 0x71 /* DS1685/DS1687 */
#define RTC_MODEL_DS17285 0x72 /* DS17285/DS17287 */
#define RTC_MODEL_DS1689 0x73 /* DS1688/DS1691/DS1689/DS1693 */
#define RTC_MODEL_DS17485 0x74 /* DS17485/DS17487 */
#define RTC_MODEL_DS17885 0x78 /* DS17885/DS17887 */
/*
* Periodic Interrupt Rates / Square-Wave Output Frequency
*
* Periodic rates are selected by setting the RS3-RS0 bits in Control
* Register A and enabled via either the E32K bit in Extended Control
* Register 4B or the SQWE bit in Control Register B.
*
* E32K overrides the settings of RS3-RS0 and outputs a frequency of 32768Hz
* on the SQW pin of the RTC chip. While there are 16 possible selections,
* the 1-of-16 decoder is only able to divide the base 32768Hz signal into 13
* smaller frequencies. The values 0x01 and 0x02 are not used and are
* synonymous with 0x08 and 0x09, respectively.
*
* When E32K is set to a logic 1, periodic interrupts are disabled and reading
* /dev/rtc will return -EINVAL. This also applies if the periodic interrupt
* frequency is set to 0Hz.
*
* Not currently used by the rtc-ds1685 driver because the RTC core removed
* support for hardware-generated periodic-interrupts in favour of
* hrtimer-generated interrupts. But these defines are kept around for use
* in userland, as documentation to the hardware, and possible future use if
* hardware-generated periodic interrupts are ever added back.
*/
/* E32K RS3 RS2 RS1 RS0 */
#define RTC_SQW_8192HZ 0x03 /* 0 0 0 1 1 */
#define RTC_SQW_4096HZ 0x04 /* 0 0 1 0 0 */
#define RTC_SQW_2048HZ 0x05 /* 0 0 1 0 1 */
#define RTC_SQW_1024HZ 0x06 /* 0 0 1 1 0 */
#define RTC_SQW_512HZ 0x07 /* 0 0 1 1 1 */
#define RTC_SQW_256HZ 0x08 /* 0 1 0 0 0 */
#define RTC_SQW_128HZ 0x09 /* 0 1 0 0 1 */
#define RTC_SQW_64HZ 0x0a /* 0 1 0 1 0 */
#define RTC_SQW_32HZ 0x0b /* 0 1 0 1 1 */
#define RTC_SQW_16HZ 0x0c /* 0 1 1 0 0 */
#define RTC_SQW_8HZ 0x0d /* 0 1 1 0 1 */
#define RTC_SQW_4HZ 0x0e /* 0 1 1 1 0 */
#define RTC_SQW_2HZ 0x0f /* 0 1 1 1 1 */
#define RTC_SQW_0HZ 0x00 /* 0 0 0 0 0 */
#define RTC_SQW_32768HZ 32768 /* 1 - - - - */
#define RTC_MAX_USER_FREQ 8192
/*
* NVRAM data & addresses:
* - 50 bytes of NVRAM are available just past the clock registers.
* - 64 additional bytes are available in Bank0.
*
* Extended, battery-backed NV-SRAM:
* - DS1685/DS1687 - 128 bytes.
* - DS1689/DS1693 - 0 bytes.
* - DS17285/DS17287 - 2048 bytes.
* - DS17485/DS17487 - 4096 bytes.
* - DS17885/DS17887 - 8192 bytes.
*/
#define NVRAM_TIME_BASE 0x0e /* NVRAM Addr in Time regs */
#define NVRAM_BANK0_BASE 0x40 /* NVRAM Addr in Bank0 regs */
#define NVRAM_SZ_TIME 50
#define NVRAM_SZ_BANK0 64
#if defined(CONFIG_RTC_DRV_DS1685)
# define NVRAM_SZ_EXTND 128
#elif defined(CONFIG_RTC_DRV_DS1689)
# define NVRAM_SZ_EXTND 0
#elif defined(CONFIG_RTC_DRV_DS17285)
# define NVRAM_SZ_EXTND 2048
#elif defined(CONFIG_RTC_DRV_DS17485)
# define NVRAM_SZ_EXTND 4096
#elif defined(CONFIG_RTC_DRV_DS17885)
# define NVRAM_SZ_EXTND 8192
#endif
#define NVRAM_TOTAL_SZ_BANK0 (NVRAM_SZ_TIME + NVRAM_SZ_BANK0)
#define NVRAM_TOTAL_SZ (NVRAM_TOTAL_SZ_BANK0 + NVRAM_SZ_EXTND)
/*
* Function Prototypes.
*/
extern void __noreturn
ds1685_rtc_poweroff(struct platform_device *pdev);
#endif /* _LINUX_RTC_DS1685_H_ */
| 37.981132 | 78 | 0.709247 | [
"model"
] |
43b41c7d1cb15f010bcf606b0c2f56dfa9e1778a | 13,312 | c | C | apps/riscv-tests/isa/rv64uv/vmfle.c | PolyMTL-Gr2m/ara | da92dee72b615c95e561b3836012cb27036203a1 | [
"Apache-2.0"
] | 112 | 2021-03-12T06:16:53.000Z | 2022-03-30T07:56:05.000Z | apps/riscv-tests/isa/rv64uv/vmfle.c | PolyMTL-Gr2m/ara | da92dee72b615c95e561b3836012cb27036203a1 | [
"Apache-2.0"
] | 82 | 2021-03-12T10:07:07.000Z | 2022-03-27T15:51:50.000Z | apps/riscv-tests/isa/rv64uv/vmfle.c | PolyMTL-Gr2m/ara | da92dee72b615c95e561b3836012cb27036203a1 | [
"Apache-2.0"
] | 36 | 2021-03-13T03:39:47.000Z | 2022-03-28T07:09:11.000Z | // Copyright 2021 ETH Zurich and University of Bologna.
// Solderpad Hardware License, Version 0.51, see LICENSE for details.
// SPDX-License-Identifier: SHL-0.51
//
// Author: Matheus Cavalcante <matheusd@iis.ee.ethz.ch>
// Basile Bougenot <bbougenot@student.ethz.ch>
// Matteo Perotti <mperotti@iis.ee.ethz.ch>
#include "float_macros.h"
#include "vector_macros.h"
// This instruction writes a mask to a register, with a layout of elements as
// described in section "Mask Register Layout"
void TEST_CASE1(void) {
VSET(16, e16, m1);
// 0.2434, 0.7285, 0.7241, -0.2678, 0.0027, -0.7114, 0.2622,
// 0.8701, -0.5786, -0.4229, 0.5981, 0.6968, 0.7217, -0.2842,
// 0.1328, 0.1659
VLOAD_16(v2, 0x33ca, 0x39d4, 0x39cb, 0xb449, 0x1975, 0xb9b1, 0x3432, 0x3af6,
0xb8a1, 0xb6c4, 0x38c9, 0x3993, 0x39c6, 0xb48c, 0x3040, 0x314f);
// 0.7319, 0.0590, 0.7593, -0.6606, -0.4758, 0.8530, 0.0453,
// 0.0987, 0.1777, 0.3047, 0.2330, -0.3467, -0.4153, 0.7080,
// 0.3142, -0.9492
VLOAD_16(v3, 0x39db, 0x2b8c, 0x3a13, 0xb949, 0xb79d, 0x3ad3, 0x29cc, 0x2e51,
0x31b0, 0x34e0, 0x3375, 0xb58c, 0xb6a5, 0x39aa, 0x3041, 0xbb98);
asm volatile("vmfle.vv v1, v2, v3");
VSET(1, e16, m1);
VCMP_U16(1, v1, 0x6325);
VSET(16, e32, m1);
// +0, sNaN, -0.34645590, -0.06222415,
// 0.96037650, -0.81018746, -0.69337404, 0.70466602,
// -0.30920035, -0.31596854, -0.92116749, 0.51336122,
// 0.22002794, 0.48599416, 0.69166088, 0.85755372
VLOAD_32(v2, 0x00000000, 0xffffffff, 0xbeb162ab, 0xbd7edebf, 0x3f75db3c,
0xbf4f6872, 0xbf3180f6, 0x3f3464fe, 0xbe9e4f82, 0xbea1c6a1,
0xbf6bd1a2, 0x3f036ba4, 0x3e614f01, 0x3ef8d43a, 0x3f3110b0,
0x3f5b88a4);
// -0, sNaN, 0.39402914, -0.81853813,
// 0.24656086, -0.71423489, -0.44735566, -0.25510681,
// -0.94378990, -0.30138883, 0.19188073, -0.29310879,
// -0.22981364, -0.58626360, -0.80913633, -0.00670803
VLOAD_32(v3, 0x80000000, 0xffffffff, 0x3ec9be30, 0xbf518bb7, 0x3e7c7a73,
0xbf36d819, 0xbee50bcd, 0xbe829d5c, 0xbf719c37, 0xbe9a4fa3,
0x3e447c62, 0xbe96125b, 0xbe6b5444, 0xbf16155f, 0xbf4f238f,
0xbbdbcefe);
asm volatile("vmfle.vv v1, v2, v3");
VSET(1, e16, m1);
VCMP_U16(2, v1, 0x0665);
VSET(16, e64, m1);
VLOAD_64(v2, 0x3feba8d9296c7e74, 0x3fdefda0947f3460, 0x3fed8915c5665532,
0xbfee55c27d3d743e, 0xbfc0c0dbc6990b38, 0xbfd84eacd38c6ca4,
0x3fc41b3c98507fe0, 0xbfe8877fabcbce12, 0xbfd7e9bb5b0beaf8,
0x3fdfa988fd8b0a24, 0xbfd367cf3ee9af68, 0x3feccb416af162fc,
0x3fe41bcdc20ecd40, 0x3fbafaebeb19acf0, 0xbfd2cb447b63f610,
0x3fdbb633afa4e520);
// -0.3562510538138417, -0.0135629748736219, 0.6176167733891369,
// 0.9703747829163081, -0.0909539316920625, -0.1057326828885887,
// -0.8792039527057112, -0.1745056251010144, 0.3110320594479206,
// 0.3238986651420683, -0.9079294226891812, -0.9490909352855985,
// 0.6962970677624296, 0.7585780695949504, -0.5927175227484118,
// -0.7793965434104730
VLOAD_64(v3, 0xbfd6ccd13852f170, 0xbf8bc6e7ac263f80, 0x3fed8915c5665532,
0x3fef0d4f6aafa2f6, 0xbfb748c1c20f5de0, 0xbfbb114c0f1ff4b0,
0xbfec227053ec5198, 0xbfc6563348637140, 0x3fd3e7f302d586b4,
0x3fd4bac177803510, 0xbfed0dc20130d694, 0xbfee5ef3f3ff6a12,
0x3fe64810c9cae3fe, 0x3fe84645840bf0a2, 0xbfe2f78abcff0ede,
0xbfe8f0d105120796);
asm volatile("vmfle.vv v1, v2, v3");
VSET(1, e16, m1);
VCMP_U16(3, v1, 0x31bc);
};
// Simple random test with similar values + 1 subnormal (masked)
void TEST_CASE2(void) {
VSET(16, e16, m1);
// 0.2434, 0.7285, 0.7241, -0.2678, 0.0027, -0.7114, 0.2622,
// 0.8701, -0.5786, -0.4229, 0.5981, 0.6968, 0.7217, -0.2842,
// 0.1328, 0.1659
VLOAD_16(v2, 0x33ca, 0x39d4, 0x39cb, 0xb449, 0x1975, 0xb9b1, 0x3432, 0x3af6,
0xb8a1, 0xb6c4, 0x38c9, 0x3993, 0x39c6, 0xb48c, 0x3040, 0x314f);
// 0.7319, 0.7285, 0.7593, -0.6606, -0.4758, 0.8530, 0.0453,
// 0.0987, 0.1777, 0.3047, 0.2330, -0.3467, -0.4153, 0.7080,
// 0.3142, -0.9492
VLOAD_16(v3, 0x39db, 0x39d4, 0x3a13, 0xb949, 0xb79d, 0x3ad3, 0x29cc, 0x2e51,
0x31b0, 0x34e0, 0x3375, 0xb58c, 0xb6a5, 0x39aa, 0x3507, 0xbb98);
VLOAD_8(v0, 0xAA, 0xAA);
VCLEAR(v1);
asm volatile("vmfle.vv v1, v2, v3, v0.t");
VSET(1, e16, m1);
VCMP_U16(4, v1, 0x2222);
VSET(16, e32, m1);
// 0x00000000, 0.09933749, -0.34645590, -0.06222415,
// 0.96037650, -0.81018746, -0.69337404, 0.70466602,
// -0.30920035, -0.31596854, -0.92116749, 0.51336122,
// 0.22002794, 0.48599416, 0.69166088, 0.85755372
VLOAD_32(v2, 0x00000000, 0x3dcb7174, 0xbeb162ab, 0xbd7edebf, 0x3f75db3c,
0xbf4f6872, 0xbf3180f6, 0x3f3464fe, 0xbe9e4f82, 0xbea1c6a1,
0xbf6bd1a2, 0x3f036ba4, 0x3e614f01, 0x3ef8d43a, 0x3f3110b0,
0x3f5d88a4);
// 0x00000000, -0.64782482, 0.39402914, -0.81853813,
// 0.24656086, -0.71423489, -0.44735566, -0.25510681,
// -0.94378990, -0.30138883, 0.19188073, -0.29310879,
// -0.22981364, -0.58626360, -0.80913633, 0.85755372
VLOAD_32(v3, 0x00000000, 0xbf25d7d9, 0x3ec9be30, 0xbf518bb7, 0x3e7c7a73,
0xbf36d819, 0xbee50bcd, 0xbe829d5c, 0xbf719c37, 0xbe9a4fa3,
0x3e447c62, 0xbe96125b, 0xbe6b5444, 0xbf16155f, 0xbf4f238f,
0x3f5d88a4);
VLOAD_8(v0, 0xAA, 0xAA);
VCLEAR(v1);
asm volatile("vmfle.vv v1, v2, v3, v0.t");
VSET(1, e16, m1);
VCMP_U16(5, v1, 0x8220);
VSET(16, e64, m1);
// 0.8643613633211786, 0.4842301798024149, 0.9229840140784857,
// -0.9479687162489723, -0.1308855743137316,
// -0.3798019472030296, 0.1570811980936915,
// -0.7665403705017886, -0.3736408604742532, 0.4947226024634424,
// -0.3032110323317654, 0.8998114670494881, 0.6283940115157876,
// 0.1053912590957002, -0.2936564640984622, -0.7793965434104730
VLOAD_64(v2, 0x3feba8d9296c7e74, 0x3fdefda0947f3460, 0x3fed8915c5665532,
0xbfee55c27d3d743e, 0xbfc0c0dbc6990b38, 0xbfd84eacd38c6ca4,
0x3fc41b3c98507fe0, 0xbfe8877fabcbce12, 0xbfd7e9bb5b0beaf8,
0x3fdfa988fd8b0a24, 0xbfd367cf3ee9af68, 0x3feccb416af162fc,
0x3fe41bcdc20ecd40, 0x3fbafaebeb19acf0, 0xbfd2cb447b63f610,
0xbfe8f0d105120796);
// 0.8643613633211786, 0.4842301798024149, 0.6176167733891369,
// 0.9703747829163081, -0.0909539316920625, -0.1057326828885887,
// -0.8792039527057112, -0.1745056251010144, 0.3110320594479206,
// 0.3238986651420683, -0.9079294226891812, -0.9490909352855985,
// 0.6962970677624296, 0.7585780695949504, -0.5927175227484118,
// -0.7793965434104730
VLOAD_64(v3, 0x3feba8d9296c7e74, 0x3fdefda0947f3460, 0x3fed8915c5665532,
0xbfee55c27d3d743e, 0xbfb748c1c20f5de0, 0xbfbb114c0f1ff4b0,
0xbfec227053ec5198, 0xbfc6563348637140, 0x3fd3e7f302d586b4,
0x3fd4bac177803510, 0xbfed0dc20130d694, 0xbfee5ef3f3ff6a12,
0x3fe64810c9cae3fe, 0x3fe84645840bf0a2, 0xbfe2f78abcff0ede,
0xbfe8f0d105120796);
VLOAD_8(v0, 0xAA, 0xAA);
VCLEAR(v1);
asm volatile("vmfle.vv v1, v2, v3, v0.t");
VSET(1, e16, m1);
VCMP_U16(6, v1, 0xa0aa);
};
// Simple random test with similar values (vector-scalar)
void TEST_CASE3(void) {
VSET(16, e16, m1);
double dscalar_16;
// -0.2649
BOX_HALF_IN_DOUBLE(dscalar_16, 0xb43d);
// -0.0651, 0.5806, 0.2563, -0.4783, 0.7393, -0.2649, -0.4590,
// 0.5469, -0.9082, 0.6235, -0.8276, -0.7939, -0.0236, -0.1166,
// 0.4026, 0.0022
VLOAD_16(v2, 0xac2a, 0x38a5, 0x341a, 0xb7a7, 0x39ea, 0xb43d, 0xb758, 0x3860,
0xbb44, 0x38fd, 0xba9f, 0xba5a, 0xa60b, 0xaf76, 0x3671, 0x1896);
asm volatile("vmfle.vf v1, v2, %[A]" ::[A] "f"(dscalar_16));
VSET(1, e16, m1);
VCMP_U16(7, v1, 0x0d68);
VSET(16, e32, m1);
double dscalar_32;
// 0.80517912
BOX_FLOAT_IN_DOUBLE(dscalar_32, 0x3f4e2038);
// -0.15601152, -0.92020410, -0.29387674, 0.98594254,
// 0.88163614, -0.44641387, 0.88191622, 0.15161350,
// -0.79952192, -0.03668820, -0.38464722, -0.54745716,
// 0.09956384, 0.21655059, -0.37557366, -0.79342169
VLOAD_32(v2, 0xbe1fc17c, 0x3f4e2038, 0x3f4e2038, 0x3f4e2038, 0x3f4e2038,
0x3f4e2038, 0x3f4e2038, 0x3f4e2038, 0x3f4e2038, 0x3f4e2038,
0x3f4e2038, 0x3f4e2038, 0x3f4e2038, 0x3f4e2038, 0x3f4e2038,
0xbf4b1daf);
asm volatile("vmfle.vf v1, v2, %[A]" ::[A] "f"(dscalar_32));
VSET(1, e16, m1);
VCMP_U16(8, v1, 0xffff);
VSET(16, e64, m1);
double dscalar_64;
// -0.3394093097660049
BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfd5b8e1d359c984);
// 0.8852775142880511, -0.1502080091211320,
// -0.7804423569145378, 0.4585094341291300,
// 0.8417440789882031, -0.1215927835809432, 0.9442717441528423,
// -0.3993868853091622, 0.5719771249018739,
// 0.0497853851400327, 0.6627817945481365, 0.2150621318612425,
// -0.8506676370622683, -0.4531982633526939,
// 0.5943189287417812, -0.5034380636605356
VLOAD_64(v2, 0x3fec543182780b14, 0xbfc33a041b62e250, 0xbfe8f9623feb8e20,
0xbfd5b8e1d359c984, 0x3feaef91475b6422, 0xbfbf20b464e8e5d0,
0x3fee377960758bfa, 0xbfd98f8e02b6aa78, 0x3fe24da2f8b06fde,
0x3fa97d7851fd8b80, 0x3fe535822a7efd70, 0x3fcb8727eb79dda0,
0xbfeb38ab561e5658, 0xbfdd013349ed0b50, 0x3fe304a9214adedc,
0xbfe01c2a245f7960);
asm volatile("vmfle.vf v1, v2, %[A]" ::[A] "f"(dscalar_64));
VSET(1, e16, m1);
VCMP_U16(9, v1, 0xb08c);
};
// Simple random test with similar values (vector-scalar) (masked)
void TEST_CASE4(void) {
VSET(16, e16, m1);
double dscalar_16;
// -0.2649
BOX_HALF_IN_DOUBLE(dscalar_16, 0xb43d);
// -0.2649, 0.5806, -0.2649, -0.4783, -0.2649, -0.2649,
// -0.2649, -0.2649, -0.2649, -0.2649, -0.2649, -0.2649,
// -0.2649, -0.2649, -0.2649, -0.2649,
VLOAD_16(v2, 0xb43d, 0x7653, 0xad3d, 0x033d, 0xb43d, 0xb43d, 0xb43d, 0xb43d,
0xb43d, 0xb43d, 0xb43d, 0xb43d, 0xb43d, 0xb43d, 0xb43d, 0xb43d);
VLOAD_8(v0, 0xAA, 0xAA);
VCLEAR(v1);
asm volatile("vmfle.vf v1, v2, %[A], v0.t" ::[A] "f"(dscalar_16));
VSET(1, e16, m1);
VCMP_U16(10, v1, 0xaaa0);
VSET(16, e32, m1);
double dscalar_32;
// 0.80517912
BOX_FLOAT_IN_DOUBLE(dscalar_32, 0x3f4e2038);
// 0.80517912, 0.80517912, -0.29387674, 0.98594254,
// 0.88163614, -0.44641387, 0.88191622, 0.15161350,
// -0.79952192, -0.03668820, -0.38464722, -0.54745716,
// 0.09956384, 0.21655059, -0.37557366, -0.79342169
VLOAD_32(v2, 0x3f4e2038, 0x3f4e2038, 0xbe967703, 0x3f7c66bb, 0x3f61b2e8,
0xbee4905c, 0x3f61c543, 0x3e1b4092, 0xbf4cad78, 0xbd16465d,
0xbec4f07b, 0xbf0c2627, 0x3dcbe820, 0x3e5dbf70, 0xbec04b31,
0xbf4b1daf);
VLOAD_8(v0, 0xAA, 0xAA);
VCLEAR(v1);
asm volatile("vmfle.vf v1, v2, %[A], v0.t" ::[A] "f"(dscalar_32));
VSET(1, e16, m1);
VCMP_U16(11, v1, 0xaaa2);
VSET(16, e64, m1);
double dscalar_64;
// -0.3394093097660049
BOX_DOUBLE_IN_DOUBLE(dscalar_64, 0xbfd5b8e1d359c984);
// 0.8852775142880511, -0.1502080091211320,
// -0.7804423569145378, -0.3394093097660049,
// 0.8417440789882031, -0.1215927835809432,
// 0.9442717441528423, -0.3993868853091622,
// 0.5719771249018739, 0.0497853851400327,
// 0.6627817945481365, 0.2150621318612425,
// -0.8506676370622683, -0.4531982633526939,
// 0.5943189287417812, -0.5034380636605356
VLOAD_64(v2, 0x3fec543182780b14, 0xbfc33a041b62e250, 0xbfe8f9623feb8e20,
0xbfd5b8e1d359c984, 0x3feaef91475b6422, 0xbfbf20b464e8e5d0,
0x3fee377960758bfa, 0xbfd98f8e02b6aa78, 0x3fe24da2f8b06fde,
0x3fa97d7851fd8b80, 0x3fe535822a7efd70, 0x3fcb8727eb79dda0,
0xbfeb38ab561e5658, 0xbfdd013349ed0b50, 0x3fe304a9214adedc,
0xbfe01c2a245f7960);
VLOAD_8(v0, 0xAA, 0xAA);
VCLEAR(v1);
asm volatile("vmfle.vf v1, v2, %[A], v0.t" ::[A] "f"(dscalar_64));
VSET(1, e16, m1);
VCMP_U16(12, v1, 0xa088);
};
int main(void) {
INIT_CHECK();
enable_vec();
enable_fp();
TEST_CASE1();
TEST_CASE2();
TEST_CASE3();
TEST_CASE4();
EXIT_CHECK();
}
| 48.583942 | 80 | 0.614784 | [
"vector"
] |
43b9e65d2d5f8d8af294e885e918914fc893ee3e | 9,202 | h | C | dbms/include/DB/Interpreters/Join.h | rudneff/ClickHouse | 3cb59b92bccbeb888d136f7c6e14b622382c0434 | [
"Apache-2.0"
] | 3 | 2016-12-30T14:19:47.000Z | 2021-11-13T06:58:32.000Z | dbms/include/DB/Interpreters/Join.h | rudneff/ClickHouse | 3cb59b92bccbeb888d136f7c6e14b622382c0434 | [
"Apache-2.0"
] | 1 | 2017-01-13T21:29:36.000Z | 2017-01-16T18:29:08.000Z | dbms/include/DB/Interpreters/Join.h | jbfavre/clickhouse-debian | 3806e3370decb40066f15627a3bca4063b992bfb | [
"Apache-2.0"
] | 1 | 2021-02-07T16:00:54.000Z | 2021-02-07T16:00:54.000Z | #pragma once
#include <common/logger_useful.h>
#include <DB/Parsers/ASTTablesInSelectQuery.h>
#include <DB/Interpreters/AggregationCommon.h>
#include <DB/Common/Arena.h>
#include <DB/Common/HashTable/HashMap.h>
#include <DB/DataStreams/IBlockInputStream.h>
namespace DB
{
/** Структура данных для реализации JOIN-а.
* По сути, хэш-таблица: ключи -> строки присоединяемой таблицы.
* Исключение - CROSS JOIN, где вместо хэш-таблицы просто набор блоков без ключей.
*
* JOIN-ы бывают девяти типов: ANY/ALL × LEFT/INNER/RIGHT/FULL, а также CROSS.
*
* Если указано ANY - выбрать из "правой" таблицы только одну, первую попавшуюся строку, даже если там более одной соответствующей строки.
* Если указано ALL - обычный вариант JOIN-а, при котором строки могут размножаться по числу соответствующих строк "правой" таблицы.
* Вариант ANY работает более оптимально.
*
* Если указано INNER - оставить только строки, для которых есть хотя бы одна строка "правой" таблицы.
* Если указано LEFT - в случае, если в "правой" таблице нет соответствующей строки, заполнить её значениями "по-умолчанию".
* Если указано RIGHT - выполнить так же, как INNER, запоминая те строки из правой таблицы, которые были присоединены,
* в конце добавить строки из правой таблицы, которые не были присоединены, подставив в качестве значений для левой таблицы, значения "по-умолчанию".
* Если указано FULL - выполнить так же, как LEFT, запоминая те строки из правой таблицы, которые были присоединены,
* в конце добавить строки из правой таблицы, которые не были присоединены, подставив в качестве значений для левой таблицы, значения "по-умолчанию".
*
* То есть, LEFT и RIGHT JOIN-ы не являются симметричными с точки зрения реализации.
*
* Все соединения делаются по равенству кортежа столбцов "ключей" (эквисоединение).
* Неравенства и прочие условия не поддерживаются.
*
* Реализация такая:
*
* 1. "Правая" таблица засовывается в хэш-таблицу в оперативке.
* Она имеет вид keys -> row в случае ANY или keys -> [rows...] в случае ALL.
* Это делается в функции insertFromBlock.
*
* 2. При обработке "левой" таблицы, присоединяем к ней данные из сформированной хэш-таблицы.
* Это делается в функции joinBlock.
*
* В случае ANY LEFT JOIN - формируем новые столбцы с найденной строкой или значениями по-умолчанию.
* Самый простой вариант. Количество строк при JOIN-е не меняется.
*
* В случае ANY INNER JOIN - формируем новые столбцы с найденной строкой;
* а также заполняем фильтр - для каких строк значения не нашлось.
* После чего, фильтруем столбцы "левой" таблицы.
*
* В случае ALL ... JOIN - формируем новые столбцы со всеми найденными строками;
* а также заполняем массив offsets, описывающий, во сколько раз надо размножить строки "левой" таблицы.
* После чего, размножаем столбцы "левой" таблицы.
*/
class Join
{
public:
Join(const Names & key_names_left_, const Names & key_names_right_,
const Limits & limits, ASTTableJoin::Kind kind_, ASTTableJoin::Strictness strictness_)
: kind(kind_), strictness(strictness_),
key_names_left(key_names_left_),
key_names_right(key_names_right_),
log(&Logger::get("Join")),
max_rows(limits.max_rows_in_join),
max_bytes(limits.max_bytes_in_join),
overflow_mode(limits.join_overflow_mode)
{
}
bool empty() { return type == Type::EMPTY; }
/** Передать информацию о структуре блока.
* Следует обязательно вызвать до вызовов insertFromBlock.
*/
void setSampleBlock(const Block & block);
/** Добавить в отображение для соединения блок "правой" таблицы.
* Возвращает false, если превышено какое-нибудь ограничение, и больше не нужно вставлять.
*/
bool insertFromBlock(const Block & block);
/** Присоединить к блоку "левой" таблицы новые столбцы из сформированного отображения.
*/
void joinBlock(Block & block) const;
/** Запомнить тотальные значения для последующего использования.
*/
void setTotals(const Block & block) { totals = block; }
bool hasTotals() const { return totals; };
void joinTotals(Block & block) const;
/** Для RIGHT и FULL JOIN-ов.
* Поток, в котором значения по-умолчанию из левой таблицы соединены с неприсоединёнными ранее строками из правой таблицы.
* Использовать только после того, как были сделаны все вызовы joinBlock.
*/
BlockInputStreamPtr createStreamWithNonJoinedRows(Block & left_sample_block, size_t max_block_size) const;
/// Считает суммарное число ключей во всех Join'ах
size_t getTotalRowCount() const;
/// Считает суммарный размер в байтах буфферов всех Join'ов + размер string_pool'а
size_t getTotalByteCount() const;
ASTTableJoin::Kind getKind() const { return kind; }
/// Ссылка на строку в блоке.
struct RowRef
{
const Block * block;
size_t row_num;
RowRef() {}
RowRef(const Block * block_, size_t row_num_) : block(block_), row_num(row_num_) {}
};
/// Односвязный список ссылок на строки.
struct RowRefList : RowRef
{
RowRefList * next = nullptr;
RowRefList() {}
RowRefList(const Block * block_, size_t row_num_) : RowRef(block_, row_num_) {}
};
/** Добавляет или не добавляет флаг - был ли элемент использован.
* Для реализации RIGHT и FULL JOIN-ов.
* NOTE: Можно сохранять флаг в один из бит указателя block или номера row_num.
*/
template <bool enable, typename Base>
struct WithUsedFlag;
template <typename Base>
struct WithUsedFlag<true, Base> : Base
{
mutable bool used = false;
using Base::Base;
using Base_t = Base;
void setUsed() const { used = true; } /// Может выполняться из разных потоков.
bool getUsed() const { return used; }
};
template <typename Base>
struct WithUsedFlag<false, Base> : Base
{
using Base::Base;
using Base_t = Base;
void setUsed() const {}
bool getUsed() const { return true; }
};
/** Разные структуры данных, которые могут использоваться для соединения.
*/
template <typename Mapped>
struct MapsTemplate
{
/// Специализация для случая, когда есть один числовой ключ.
using MapUInt64 = HashMap<UInt64, Mapped, HashCRC32<UInt64>>;
/// Специализация для случая, когда есть один строковый ключ.
using MapString = HashMapWithSavedHash<StringRef, Mapped>;
/** Сравнивает 128 битные хэши.
* Если все ключи фиксированной длины, влезающие целиком в 128 бит, то укладывает их без изменений в 128 бит.
* Иначе - вычисляет SipHash от набора из всех ключей.
* (При этом, строки, содержащие нули посередине, могут склеиться.)
*/
using MapHashed = HashMap<UInt128, Mapped, UInt128HashCRC32>;
std::unique_ptr<MapUInt64> key64;
std::unique_ptr<MapString> key_string;
std::unique_ptr<MapHashed> hashed;
};
using MapsAny = MapsTemplate<WithUsedFlag<false, RowRef>>;
using MapsAll = MapsTemplate<WithUsedFlag<false, RowRefList>>;
using MapsAnyFull = MapsTemplate<WithUsedFlag<true, RowRef>>;
using MapsAllFull = MapsTemplate<WithUsedFlag<true, RowRefList>>;
private:
friend class NonJoinedBlockInputStream;
ASTTableJoin::Kind kind;
ASTTableJoin::Strictness strictness;
/// Имена ключевых столбцов (по которым производится соединение) в "левой" таблице.
const Names key_names_left;
/// Имена ключевых столбцов (по которым производится соединение) в "правой" таблице.
const Names key_names_right;
/** Блоки данных таблицы, с которой идёт соединение.
*/
BlocksList blocks;
MapsAny maps_any; /// Для ANY LEFT|INNER JOIN
MapsAll maps_all; /// Для ALL LEFT|INNER JOIN
MapsAnyFull maps_any_full; /// Для ANY RIGHT|FULL JOIN
MapsAllFull maps_all_full; /// Для ALL RIGHT|FULL JOIN
/// Дополнительные данные - строки, а также продолжения односвязных списков строк.
Arena pool;
public:
enum class Type
{
EMPTY,
KEY_64,
KEY_STRING,
HASHED,
CROSS,
};
private:
Type type = Type::EMPTY;
static Type chooseMethod(const ConstColumnPlainPtrs & key_columns, bool & keys_fit_128_bits, Sizes & key_sizes);
bool keys_fit_128_bits;
Sizes key_sizes;
Block sample_block_with_columns_to_add;
Block sample_block_with_keys;
Logger * log;
/// Ограничения на максимальный размер множества
size_t max_rows;
size_t max_bytes;
OverflowMode overflow_mode;
Block totals;
/** Защищает работу с состоянием в функциях insertFromBlock и joinBlock.
* Эти функции могут вызываться одновременно из разных потоков только при использовании StorageJoin,
* и StorageJoin вызывает только эти две функции.
* Поэтому остальные функции не защинены.
*/
mutable Poco::RWLock rwlock;
void init(Type type_);
template <ASTTableJoin::Strictness STRICTNESS, typename Maps>
void insertFromBlockImpl(Maps & maps, size_t rows, const ConstColumnPlainPtrs & key_columns, size_t keys_size, Block * stored_block);
template <ASTTableJoin::Kind KIND, ASTTableJoin::Strictness STRICTNESS, typename Maps>
void joinBlockImpl(Block & block, const Maps & maps) const;
void joinBlockImplCross(Block & block) const;
/// Проверить не превышены ли допустимые размеры множества
bool checkSizeLimits() const;
/// Кинуть исключение, если в блоках не совпадают типы ключей.
void checkTypesOfKeys(const Block & block_left, const Block & block_right) const;
};
using JoinPtr = std::shared_ptr<Join>;
using Joins = std::vector<JoinPtr>;
}
| 34.081481 | 151 | 0.745381 | [
"vector"
] |
43bd98510ceb7bc6f382b5b678ae7c98b12701dc | 2,146 | h | C | Classes/Core/Performing/FLCallback_t.h | fishlamp-released/FishLamp3 | 216293cc4d08945853ac271affff0968f8137655 | [
"MIT"
] | 1 | 2015-12-30T13:15:11.000Z | 2015-12-30T13:15:11.000Z | Classes/Core/Performing/FLCallback_t.h | fishlamp-released/FishLamp3 | 216293cc4d08945853ac271affff0968f8137655 | [
"MIT"
] | null | null | null | Classes/Core/Performing/FLCallback_t.h | fishlamp-released/FishLamp3 | 216293cc4d08945853ac271affff0968f8137655 | [
"MIT"
] | null | null | null | //
// FLCallback.h
// FishLamp
//
// Created by Mike Fullerton on 9/14/12.
// Copyright (c) 2013 GreenTongue Software LLC, Mike Fullerton.
// The FishLamp Framework is released under the MIT License: http://fishlamp.com/license
//
#import "FishLampRequired.h"
#import "FLSelectorPerforming.h"
//
// simple callback struct
//
typedef struct {
__unsafe_unretained id target;
SEL action;
} FLCallback_t;
extern const FLCallback_t FLCallbackZero;
NS_INLINE
FLCallback_t FLCallbackMake(id target, SEL action) {
FLCallback_t cb = { target, action };
return cb;
}
NS_INLINE
BOOL FLCallbackIsNotNil(FLCallback_t cb) {
return cb.target && cb.action;
}
NS_INLINE
BOOL FLCallbackIsNil(FLCallback_t cb) {
return !cb.target || !cb.action;
}
NS_INLINE
BOOL FLCallbackPerform(FLCallback_t callback, id withObject) {
return FLPerformSelector0(callback.target, callback.action);
}
NS_INLINE
BOOL FLCallbackPerform1(FLCallback_t callback, id withObject) {
return FLPerformSelector1(callback.target, callback.action, withObject);
}
NS_INLINE
BOOL FLCallbackPerform2(FLCallback_t callback, id withObject1, id withObject2) {
return FLPerformSelector2(callback.target, callback.action, withObject1, withObject2);
}
NS_INLINE
BOOL FLCallbackPerform3(FLCallback_t callback, id withObject1, id withObject2, id withObject3) {
return FLPerformSelector3(callback.target, callback.action, withObject1, withObject2, withObject3);
}
//
// callback objects
//
@interface FLCallback : NSObject {
@private
}
- (id) initWithTarget:(id) target action:(SEL) action;
+ (id) callbackWithTarget:(id) target action:(SEL) action;
- (id) target;
- (void) setTarget:(id) target;
- (SEL) action;
- (void) setAction:(SEL) action;
- (BOOL) perform;
- (BOOL) performWithObject:(id) object;
- (BOOL) performWithObject:(id) object1 withObject:(id) object2;
- (BOOL) performWithObject:(id) object1 withObject:(id) object2 withObject:(id) object3;
@end
@interface FLCallbackWithUnretainedTarget : FLCallback {
@private
FL_WEAK id _target;
SEL _action;
}
@property (readwrite, assign) id target;
@property (readwrite, assign) SEL action;
@end
| 22.123711 | 100 | 0.753029 | [
"object"
] |
43beab45e101fa63d299e3af1672184da29ca300 | 1,436 | h | C | analytics/include/navmesh/nav_structs.h | David-Durst/csknow | 5b31585c6be63cee117ce5910545c8cc34627fd4 | [
"MIT"
] | 8 | 2021-03-08T21:24:42.000Z | 2022-03-20T23:18:09.000Z | analytics/include/navmesh/nav_structs.h | David-Durst/csknow | 5b31585c6be63cee117ce5910545c8cc34627fd4 | [
"MIT"
] | 2 | 2021-12-27T01:26:12.000Z | 2022-02-24T19:51:48.000Z | analytics/include/navmesh/nav_structs.h | David-Durst/csknow | 5b31585c6be63cee117ce5910545c8cc34627fd4 | [
"MIT"
] | null | null | null | #pragma once
#define LO_32(x) (*( (uint32_t *) &x))
namespace nav_mesh {
class vec3_t {
public:
vec3_t operator+( const vec3_t other ) { return { x + other.x, y + other.y, z + other.z }; }
vec3_t operator-( const vec3_t other ) { return { x - other.x, y - other.y, z - other.z }; }
vec3_t operator*( const float m ) { return { x * m, y * m, z* m }; }
float x = 0.f, y = 0.f, z = 0.f;
};
struct nav_area_bind_info_t {
union {
std::uint32_t id;
void* area = nullptr;
};
std::uint8_t attributes = 0;
};
class nav_area_critical_data {
public:
vec3_t m_nw_corner = { },
m_se_corner = { },
m_center = { };
float m_inv_dx_corners = 0.f,
m_inv_dy_corners = 0.f,
m_ne_z = 0.f,
m_sw_z = 0.f;
};
struct nav_connect_t {
nav_connect_t( ) { }
nav_connect_t( std::uint32_t connect_id ) {
id = connect_id;
}
union {
std::uint32_t id;
void* area = nullptr;
};
};
struct nav_ladder_connect_t {
nav_ladder_connect_t( ) { }
nav_ladder_connect_t( std::uint32_t connect_id ) {
id = connect_id;
}
union {
std::uint32_t id;
void* ladder = nullptr;
};
};
struct nav_spot_order_t {
float t = 0.f;
union {
std::uint32_t id;
void* hiding_spot = nullptr;
};
};
struct nav_spot_encounter_t {
nav_connect_t from = { }, to = { };
std::uint8_t from_direction = 0, to_direction = 0;
std::vector< nav_spot_order_t > spot_order = { };
};
} | 19.405405 | 94 | 0.605153 | [
"vector"
] |
43bf3646adde9066877ee1a36155f518602c3de0 | 2,035 | c | C | kungfu/skill/luohan-fumogong/fireice.c | zhangyifei/mud | b2090bbd2a8d3d82b86148d794a7ca59cd2429f3 | [
"MIT"
] | 69 | 2018-03-08T18:24:44.000Z | 2022-02-24T13:43:53.000Z | kungfu/skill/luohan-fumogong/fireice.c | zhangyifei/mud | b2090bbd2a8d3d82b86148d794a7ca59cd2429f3 | [
"MIT"
] | 3 | 2019-04-24T12:21:19.000Z | 2021-03-28T23:34:58.000Z | kungfu/skill/luohan-fumogong/fireice.c | zhangyifei/mud | b2090bbd2a8d3d82b86148d794a7ca59cd2429f3 | [
"MIT"
] | 33 | 2017-12-23T05:06:58.000Z | 2021-08-16T02:42:59.000Z | #include <ansi.h>
inherit F_CLEAN_UP;
#define FIREICE "「" HIW "冰" HIR "火" HIW "九重天" NOR "」"
void remove_effect(object me, int amount);
int exert(object me, object target)
{
int skill;
string fam;
fam = me->query("family/family_name");
if (userp(me) && ! me->query("skybook/item/xuanbingjiu"))
return notify_fail("你所学的内功中没有这种功能。\n");
if (target != me)
return notify_fail("你只能用" FIREICE "来提升自己的战斗力。\n");
if ((int)me->query_temp("fireice"))
return notify_fail("你现在正在施展" FIREICE "。\n");
if ((int)me->query_skill("luohan-fumogong", 1) < 180)
return notify_fail("你罗汉伏魔功火候不足，难以施展" FIREICE "。\n");
if ((int)me->query("max_neili") < 4000)
return notify_fail("你的内力修为不足，难以施展" FIREICE "。\n");
if ((int)me->query("neili") < 500)
return notify_fail("你现在的内力不足，难以施展" FIREICE "。\n");
skill = me->query_skill("luohan-fumogong", 1);
me->add("neili", -300);
me->receive_damage("qi", 0);
message_combatd(HIC "$N" HIC "纵声长啸，运转「" HIW "冰"
HIR "火" HIW "九重天" HIC "」真气，聚力"
"于掌间，光华流动，煞为壮观。\n" NOR, me);
me->add_temp("apply/unarmed_damage", skill / 5);
me->add_temp("apply/damage", skill / 5);
me->add_temp("apply/armor", skill * 2 / 5);
me->set_temp("fireice", 1);
me->start_call_out((: call_other, __FILE__, "remove_effect",
me, skill / 5 :), skill);
if (me->is_fighting())
me->start_busy(3);
return 1;
}
void remove_effect(object me, int amount)
{
if (me->query_temp("fireice"))
{
me->add_temp("apply/unarmed_damage", -amount);
me->add_temp("apply/damage", -amount);
me->add_temp("apply/armor", -amount * 2);
me->delete_temp("fireice");
tell_object(me, "你的" FIREICE "运行完毕，将内力收回丹田。\n");
}
}
| 30.833333 | 68 | 0.522359 | [
"object"
] |
43c0757aa86bcdee8a42b4a180bab319be513dec | 12,771 | c | C | original/lib/fftw-2.1.3/rfftw/rplanner.c | albertsgrc/ftdock-opt | 3361d1f18bf529958b78231fdcf139b1c1c1f232 | [
"MIT"
] | 9 | 2018-10-03T19:57:47.000Z | 2022-01-08T14:37:24.000Z | original/lib/fftw-2.1.3/rfftw/rplanner.c | albertsgrc/ftdock-opt | 3361d1f18bf529958b78231fdcf139b1c1c1f232 | [
"MIT"
] | null | null | null | original/lib/fftw-2.1.3/rfftw/rplanner.c | albertsgrc/ftdock-opt | 3361d1f18bf529958b78231fdcf139b1c1c1f232 | [
"MIT"
] | 8 | 2017-11-20T07:52:01.000Z | 2022-03-29T02:59:10.000Z | /*
* Copyright (c) 1997-1999 Massachusetts Institute of Technology
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/*
* planner.c -- find the optimal plan
*/
/* $Id: rplanner.c,v 1.23 1999/10/26 04:54:29 stevenj Exp $ */
#ifdef FFTW_USING_CILK
#include <cilk.h>
#include <cilk-compat.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <fftw-int.h>
#include <rfftw.h>
extern fftw_codelet_desc *rfftw_config[]; /* global from rconfig.c */
extern fftw_rgeneric_codelet fftw_hc2hc_forward_generic;
extern fftw_rgeneric_codelet fftw_hc2hc_backward_generic;
fftw_plan_hook_ptr rfftw_plan_hook = (fftw_plan_hook_ptr) NULL;
/* timing rfftw plans: */
static double rfftw_measure_runtime(fftw_plan plan,
fftw_real *in, int istride,
fftw_real *out, int ostride)
{
fftw_time begin, end, start;
double t, tmin;
int i, iter;
int n;
int repeat;
int howmany = plan->vector_size;
n = plan->n;
iter = 1;
for (;;) {
tmin = 1.0E10;
for (i = 0; i < n * howmany; ++i)
in[istride * i] = 0.0;
start = fftw_get_time();
/* repeat the measurement FFTW_TIME_REPEAT times */
for (repeat = 0; repeat < FFTW_TIME_REPEAT; ++repeat) {
begin = fftw_get_time();
for (i = 0; i < iter; ++i)
rfftw(plan, howmany, in, istride, istride,
out, ostride, ostride);
end = fftw_get_time();
t = fftw_time_to_sec(fftw_time_diff(end, begin));
if (t < tmin)
tmin = t;
/* do not run for too long */
t = fftw_time_to_sec(fftw_time_diff(end, start));
if (t > FFTW_TIME_LIMIT)
break;
}
if (tmin >= FFTW_TIME_MIN)
break;
iter *= 2;
}
tmin /= (double) iter;
return tmin;
}
/* auxiliary functions */
static void rcompute_cost(fftw_plan plan,
fftw_real *in, int istride,
fftw_real *out, int ostride)
{
if (plan->flags & FFTW_MEASURE)
plan->cost = rfftw_measure_runtime(plan, in, istride, out, ostride);
else {
double c;
c = plan->n * fftw_estimate_node(plan->root) * plan->vector_size;
plan->cost = c;
}
}
static void run_plan_hooks(fftw_plan p)
{
if (rfftw_plan_hook && p) {
fftw_complete_twiddle(p->root, p->n);
rfftw_plan_hook(p);
}
}
/* macrology */
#define FOR_ALL_RCODELETS(p) \
fftw_codelet_desc **__q, *p; \
for (__q = &rfftw_config[0]; (p = (*__q)); ++__q)
/******************************************
* Recursive planner *
******************************************/
static fftw_plan rplanner(fftw_plan *table, int n,
fftw_direction dir, int flags, int vector_size,
fftw_real *, int, fftw_real *, int);
/*
* the planner consists of two parts: one that tries to
* use accumulated wisdom, and one that does not.
* A small driver invokes both parts in sequence
*/
/* planner with wisdom: look up the codelet suggested by the wisdom */
static fftw_plan rplanner_wisdom(fftw_plan *table, int n,
fftw_direction dir, int flags,
int vector_size,
fftw_real *in, int istride,
fftw_real *out, int ostride)
{
fftw_plan best = (fftw_plan) 0;
fftw_plan_node *node;
int have_wisdom;
enum fftw_node_type wisdom_type;
int wisdom_signature;
fftw_recurse_kind wisdom_recurse_kind;
/* see if we remember any wisdom for this case */
have_wisdom = fftw_wisdom_lookup(n, flags, dir, RFFTW_WISDOM,
istride, ostride,
&wisdom_type, &wisdom_signature,
&wisdom_recurse_kind, 0);
if (!have_wisdom)
return best;
if (wisdom_type == FFTW_REAL2HC || wisdom_type == FFTW_HC2REAL) {
FOR_ALL_RCODELETS(p) {
if (p->dir == dir && p->type == wisdom_type) {
/* see if wisdom applies */
if (wisdom_signature == p->signature &&
p->size == n) {
if (wisdom_type == FFTW_REAL2HC)
node = fftw_make_node_real2hc(n, p);
else
node = fftw_make_node_hc2real(n, p);
best = fftw_make_plan(n, dir, node, flags,
p->type, p->signature,
FFTW_NORMAL_RECURSE,
vector_size);
fftw_use_plan(best);
run_plan_hooks(best);
return best;
}
}
}
}
if (wisdom_type == FFTW_HC2HC) {
FOR_ALL_RCODELETS(p) {
if (p->dir == dir && p->type == wisdom_type) {
/* see if wisdom applies */
if (wisdom_signature == p->signature &&
p->size > 1 &&
(n % p->size) == 0) {
fftw_plan r = rplanner(table, n / p->size, dir,
flags | FFTW_NO_VECTOR_RECURSE,
wisdom_recurse_kind ==
FFTW_VECTOR_RECURSE ?
p->size : vector_size,
in, istride, out,
ostride);
if (!r)
continue;
node = fftw_make_node_hc2hc(n, dir, p,
r->root, flags);
best = fftw_make_plan(n, dir, node, flags,
p->type, p->signature,
wisdom_recurse_kind,
vector_size);
fftw_use_plan(best);
run_plan_hooks(best);
fftw_destroy_plan_internal(r);
return best;
}
}
}
}
/*
* BUG (or: TODO) Can we have generic wisdom? This is probably
* an academic question
*/
return best;
}
/*
* planner with no wisdom: try all combinations and pick
* the best
*/
static fftw_plan rplanner_normal(fftw_plan *table, int n, fftw_direction dir,
int flags, int vector_size,
fftw_real *in, int istride,
fftw_real *out, int ostride)
{
fftw_plan best = (fftw_plan) 0;
fftw_plan newplan;
fftw_plan_node *node;
/* see if we have any codelet that solves the problem */
{
FOR_ALL_RCODELETS(p) {
if (p->dir == dir &&
(p->type == FFTW_REAL2HC || p->type == FFTW_HC2REAL)) {
if (p->size == n) {
if (p->type == FFTW_REAL2HC)
node = fftw_make_node_real2hc(n, p);
else
node = fftw_make_node_hc2real(n, p);
newplan = fftw_make_plan(n, dir, node, flags,
p->type, p->signature,
FFTW_NORMAL_RECURSE,
vector_size);
fftw_use_plan(newplan);
run_plan_hooks(newplan);
rcompute_cost(newplan, in, istride, out, ostride);
best = fftw_pick_better(newplan, best);
}
}
}
}
/* Then, try all available twiddle codelets */
{
FOR_ALL_RCODELETS(p) {
if (p->dir == dir && p->type == FFTW_HC2HC) {
if ((n % p->size) == 0 &&
p->size > 1 &&
(!best || n != p->size)) {
fftw_plan r = rplanner(table, n / p->size, dir,
flags | FFTW_NO_VECTOR_RECURSE,
vector_size,
in, istride, out, ostride);
if (!r)
continue;
node = fftw_make_node_hc2hc(n, dir, p,
r->root, flags);
newplan = fftw_make_plan(n, dir, node, flags,
p->type, p->signature,
FFTW_NORMAL_RECURSE,
vector_size);
fftw_use_plan(newplan);
run_plan_hooks(newplan);
fftw_destroy_plan_internal(r);
rcompute_cost(newplan, in, istride, out, ostride);
best = fftw_pick_better(newplan, best);
}
}
}
}
/* try vector recursion unless prohibited by the flags: */
if (! (flags & FFTW_NO_VECTOR_RECURSE)) {
FOR_ALL_RCODELETS(p) {
if (p->dir == dir && p->type == FFTW_HC2HC) {
if ((n % p->size) == 0 &&
p->size > 1 &&
(!best || n != p->size)) {
fftw_plan r = rplanner(table, n / p->size, dir,
flags | FFTW_NO_VECTOR_RECURSE,
p->size,
in, istride, out, ostride);
if (!r)
continue;
node = fftw_make_node_hc2hc(n, dir, p,
r->root, flags);
newplan = fftw_make_plan(n, dir, node, flags,
p->type, p->signature,
FFTW_VECTOR_RECURSE,
vector_size);
fftw_use_plan(newplan);
run_plan_hooks(newplan);
fftw_destroy_plan_internal(r);
rcompute_cost(newplan, in, istride, out, ostride);
best = fftw_pick_better(newplan, best);
}
}
}
}
/*
* Resort to generic codelets for unknown factors, but only if
* n is odd--the rgeneric codelets can't handle even n's.
*/
if (n % 2 != 0) {
fftw_rgeneric_codelet *codelet = (dir == FFTW_FORWARD ?
fftw_hc2hc_forward_generic :
fftw_hc2hc_backward_generic);
int size, prev_size = 0, remaining_factors = n;
fftw_plan r;
while (remaining_factors > 1) {
size = fftw_factor(remaining_factors);
remaining_factors /= size;
/* don't try the same factor more than once */
if (size == prev_size)
continue;
prev_size = size;
/* Look for codelets corresponding to this factor. */
{
FOR_ALL_RCODELETS(p) {
if (p->dir == dir && p->type == FFTW_HC2HC
&& p->size == size) {
size = 0;
break;
}
}
}
/*
* only try a generic/rader codelet if there were no
* twiddle codelets for this factor
*/
if (!size)
continue;
r = rplanner(table, n / size, dir,
flags | FFTW_NO_VECTOR_RECURSE,
vector_size,
in, istride, out, ostride);
node = fftw_make_node_rgeneric(n, size, dir, codelet,
r->root, flags);
newplan = fftw_make_plan(n, dir, node, flags, FFTW_RGENERIC, 0,
FFTW_NORMAL_RECURSE, vector_size);
fftw_use_plan(newplan);
run_plan_hooks(newplan);
fftw_destroy_plan_internal(r);
rcompute_cost(newplan, in, istride, out, ostride);
best = fftw_pick_better(newplan, best);
}
}
return best;
}
static fftw_plan rplanner(fftw_plan *table, int n, fftw_direction dir,
int flags, int vector_size,
fftw_real *in, int istride,
fftw_real *out, int ostride)
{
fftw_plan best = (fftw_plan) 0;
if (vector_size > 1)
flags |= FFTW_NO_VECTOR_RECURSE;
/* see if plan has already been computed */
best = fftw_lookup(table, n, flags, vector_size);
if (best) {
fftw_use_plan(best);
return best;
}
/* try a wise plan */
best = rplanner_wisdom(table, n, dir, flags, vector_size,
in, istride, out, ostride);
if (!best) {
/* No wisdom. Plan normally. */
best = rplanner_normal(table, n, dir, flags,
vector_size,
in, istride, out, ostride);
}
if (best) {
fftw_insert(table, best);
/* remember the wisdom */
fftw_wisdom_add(n, flags, dir, RFFTW_WISDOM,
istride, ostride,
best->wisdom_type,
best->wisdom_signature,
best->recurse_kind);
}
return best;
}
fftw_plan rfftw_create_plan_specific(int n, fftw_direction dir, int flags,
fftw_real *in, int istride,
fftw_real *out, int ostride)
{
fftw_plan table;
fftw_plan p1;
/* validate parameters */
if (n <= 0)
return (fftw_plan) 0;
#ifndef FFTW_ENABLE_VECTOR_RECURSE
/* TEMPORARY: disable vector recursion until it is more tested. */
flags |= FFTW_NO_VECTOR_RECURSE;
#endif
if ((dir != FFTW_FORWARD) && (dir != FFTW_BACKWARD))
return (fftw_plan) 0;
fftw_make_empty_table(&table);
p1 = rplanner(&table, n, dir, flags, 1,
in, istride, out, ostride);
fftw_destroy_table(&table);
if (p1)
fftw_complete_twiddle(p1->root, n);
return p1;
}
fftw_plan rfftw_create_plan(int n, fftw_direction dir, int flags)
{
fftw_real *tmp_in;
fftw_real *tmp_out;
fftw_plan p;
if (flags & FFTW_MEASURE) {
tmp_in = (fftw_real *) fftw_malloc(2 * n * sizeof(fftw_real));
if (!tmp_in)
return 0;
tmp_out = tmp_in + n;
p = rfftw_create_plan_specific(n, dir, flags,
tmp_in, 1, tmp_out, 1);
fftw_free(tmp_in);
} else
p = rfftw_create_plan_specific(n, dir, flags,
(fftw_real *) 0, 1, (fftw_real *) 0, 1);
return p;
}
void rfftw_destroy_plan(fftw_plan plan)
{
fftw_destroy_plan_internal(plan);
}
void rfftw_fprint_plan(FILE *f, fftw_plan p)
{
fftw_fprint_plan(f, p);
}
void rfftw_print_plan(fftw_plan p)
{
rfftw_fprint_plan(stdout, p);
}
| 27.057203 | 77 | 0.599796 | [
"vector"
] |
43c1fe9f49e9e33c260a368190049ff52dbb1bed | 13,531 | h | C | lugre/lib/paged_geometry/include/ImpostorPage.h | ghoulsblade/vegaogre | 2ece3b799f9bd667f081d47c1a0f3ef5e78d3e0f | [
"MIT"
] | 1 | 2020-10-18T14:33:05.000Z | 2020-10-18T14:33:05.000Z | lugre/lib/paged_geometry/include/ImpostorPage.h | ghoulsblade/vegaogre | 2ece3b799f9bd667f081d47c1a0f3ef5e78d3e0f | [
"MIT"
] | null | null | null | lugre/lib/paged_geometry/include/ImpostorPage.h | ghoulsblade/vegaogre | 2ece3b799f9bd667f081d47c1a0f3ef5e78d3e0f | [
"MIT"
] | null | null | null | /*-------------------------------------------------------------------------------------
Copyright (c) 2006 John Judnich
Modified 2008 by Erik Hjortsberg (erik.hjortsberg@iteam.se)
This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
-------------------------------------------------------------------------------------*/
//ImpostorPage.h
//ImposterPage is an extension to PagedGeometry which displays entities as imposters.
//-------------------------------------------------------------------------------------
#ifndef __ImpostorPage_H__
#define __ImpostorPage_H__
#include "PagedGeometry.h"
#include "StaticBillboardSet.h"
#include <OgrePrerequisites.h>
#include <OgreTextureManager.h>
#include <OgreRenderTexture.h>
#define IMPOSTOR_YAW_ANGLES 8
#define IMPOSTOR_PITCH_ANGLES 4
//If set to 1, imposter textures will be read and saved to disc; if set to 0 they will stay in memory and need to be regenerated each time the application is run.
#define IMPOSTOR_FILE_SAVE 1
namespace Forests {
class ImpostorBatch;
class ImpostorTexture;
//Blend modes used by ImpostorPage::setBlendMode()
typedef enum ImpostorBlendMode {
ALPHA_REJECT_IMPOSTOR,
ALPHA_BLEND_IMPOSTOR
};
//-------------------------------------------------------------------------------------
/**
\brief The ImpostorPage class renders entities as impostors (billboard images that look just like the real entity).
This is one of the geometry page types included in the StaticGeometry engine. These
page types should be added to a PagedGeometry object with PagedGeometry::addDetailLevel()
so the PagedGeometry will know how you want your geometry displayed.
To use this page type, use:
\code
PagedGeometry::addDetailLevel<ImpostorPage>(farRange);
\endcode TexturePtr renderTexture;
Of all the page types included in the PagedGeometry engine, this one is the fastest. It
uses impostors (billboards that look just like the real entity) to represent entities.
This way, your video card only has to render a bunch of 2D images, instead of a full 3D
mesh. Imposters are generally used off in the distance slightly, since they don't always
look exactly like the real thing, especially up close (since they are flat, and sometimes
slightly pixelated).
\note Impostors are generated only once for each entity. If you make any changes to your
entities, you'll have to force impostor regeneration by deleting the prerender files
located in your executable's working directory (named "Impostor.[ResourceGroup].[Entity].png")
*/
class ImpostorPage: public GeometryPage
{
friend class ImpostorBatch;
friend class ImpostorTexture;
public:
void init(PagedGeometry *geom, const Ogre::Any &data);
~ImpostorPage();
void setRegion(Ogre::Real left, Ogre::Real top, Ogre::Real right, Ogre::Real bottom);
void addEntity(Ogre::Entity *ent, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, const Ogre::Vector3 &scale, const Ogre::ColourValue &color);
void build();
void removeEntities();
void setVisible(bool visible);
void setFade(bool enabled, Ogre::Real visibleDist, Ogre::Real invisibleDist);
void update();
/**
\brief Sets the resolution for single impostor images.
\param pixels The width/height of one square impostor render
The default impostor resolution is 128x128. Note that 32 impostor images
will be stored in a single texture (8 x 4), so a impostor resolution of 128,
for example, results in final texture size of 1024 x 512.
\warning Calling this function will have no effect unless it is done before
any entities are added to any page.
*/
static void setImpostorResolution(int pixels) { impostorResolution = pixels; }
/**
\brief Sets the background color used when rendering impostor images.
\param color The background color
Choosing an impostor color that closely matches the main color of your objects
is important to reduce mipmap artifacts. When distant objects are displayed as
impostors, hardware mipmapping can cause the color surrounding your object (the
background color) to "bleed" into the main image, which can result in incorrectly
tinted distant objects.
The default background color is ColourValue(0.0f, 0.3f, 0.0f, 0.0f), or dark green
(this color was chosen because the main use of ImpostorPage is for trees, bushes, etc.)
\warning Calling this function will have no effect unless it is done before
any entities are added to any page. Also remember that you may have to
delete the old impostor renders (located in your exe's directory) in
order for the new ones to be generated.
*/
static void setImpostorColor(const Ogre::ColourValue &color)
{
impostorBackgroundColor = color;
impostorBackgroundColor.a = 0.0f;
}
/**
\brief Sets the billboard pivot point used when rendering camera-facing impostors
This function can be used to set how impostors should rotate to face the camera. By default,
impostors are pointed towards the camera by rotating around the impostor billboard's center.
By choosing an alternate pivot point with this function, you can acheive better results under
certain conditions. For example, when looking up or down very steep hills, you'll probably want
to set BBO_BOTTOM_CENTER as the pivot point. For most other cases, however, the default pivot
point of BBO_CENTER works best.
\note Only BBO_CENTER and BBO_BOTTOM_CENTER is supported by this function currently.
\warning Calling this function will have no effect unless it is done before
any entities are added to any page.
*/
static void setImpostorPivot(Ogre::BillboardOrigin origin);
/**
\brief Regenerates the impostor texture for the specified entity
\param ent The entity which will have it's impostor texture regenerated
This function can be called to force the regeneration of a specific impostor.
Normally, impostors are generated once (saved to a file), and simply preloaded
from the file afterwards (unless you delete the file). Calling this will
instantly regenerate the impostor and update it's saved image file.
\note This function cannot regenerate an impostor unless it's already being used
in the scene.
\warning This is NOT a real-time operation - it may take a few seconds to complete.
*/
static void regenerate(Ogre::Entity *ent);
/**
\brief Regenerates all impostor textures currently being used in the scene
This function can be called to force the regeneration of all impostors currently being
used in your scene. Normally, impostors are generated once (saved to a file), and simply
preloaded from the files afterwards (unless you delete the files). Calling this will
instantly regenerate the impostors and update their saved image files.
\warning This is NOT a real-time operation - it may take a few seconds to complete.
*/
static void regenerateAll();
inline void setBlendMode(ImpostorBlendMode blendMode) { this->blendMode = blendMode; }
inline ImpostorBlendMode getBlendMode() { return blendMode; }
protected:
Ogre::SceneManager *sceneMgr;
PagedGeometry *geom;
ImpostorBlendMode blendMode;
static int impostorResolution;
static Ogre::ColourValue impostorBackgroundColor;
static Ogre::BillboardOrigin impostorPivot;
static Ogre::uint32 selfInstances;
static Ogre::uint32 updateInstanceID;
Ogre::uint32 instanceID;
Ogre::Timer updateTimer;
Ogre::Vector3 center;
int aveCount;
std::map<Ogre::String, ImpostorBatch *> impostorBatches;
};
//-------------------------------------------------------------------------------------
//This is used internally by ImpostorPage to store a "batch" of impostors. Similar
//impostors are all batched into ImpostorBatch'es, which contain a BillboardSet (where
//the actual billboards are), and a pointer to an existing ImpostorTexture.
class ImpostorBatch
{
public:
static ImpostorBatch *getBatch(ImpostorPage *group, Ogre::Entity *entity);
~ImpostorBatch();
inline void build()
{
bbset->build();
}
inline void clear()
{
bbset->clear();
}
inline void setVisible(bool visible)
{
bbset->setVisible(visible);
}
inline void setFade(bool enabled, Ogre::Real visibleDist, Ogre::Real invisibleDist)
{
bbset->setFade(enabled, visibleDist, invisibleDist);
}
void setBillboardOrigin(Ogre::BillboardOrigin origin);
inline void addBillboard(const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, const Ogre::Vector3 &scale, const Ogre::ColourValue &color = Ogre::ColourValue::White);
void setAngle(float pitchDeg, float yawDeg);
static Ogre::String generateEntityKey(Ogre::Entity *entity);
protected:
ImpostorBatch(ImpostorPage *group, Ogre::Entity *entity);
ImpostorTexture *tex;
StaticBillboardSet *bbset;
Ogre::Vector3 entityBBCenter;
ImpostorPage *igroup;
Ogre::uint16 pitchIndex, yawIndex;
static unsigned long GUID;
static inline Ogre::String getUniqueID(const Ogre::String &prefix)
{
return prefix + Ogre::StringConverter::toString(++GUID);
}
};
//-------------------------------------------------------------------------------------
//Responsible for making sure that the texture is rerendered when the texture resource needs to //be reloaded.
//
class ImpostorTextureResourceLoader : public Ogre::ManualResourceLoader
{
public:
/**
* Ctor.
* @param renderContext The ImpostorTexture to which this instance belongs.
*/
ImpostorTextureResourceLoader(ImpostorTexture& impostorTexture);
/**
* At load time the texture will be rerendered.
* @param resource
*/
virtual void loadResource (Ogre::Resource *resource);
protected:
ImpostorTexture& texture;
};
//-------------------------------------------------------------------------------------
//This is used internally by ImpostorPage. An ImpostorTexture is actually multiple
//images of an entity from various rotations. ImpostorTextures are applied
//to billboards to create the effect of 3D shapes, when in reality they are simply
//flat billboards.
class ImpostorTexture
{
friend class ImpostorBatch;
friend class ImpostorTextureResourceLoader;
public:
/** Returns a pointer to an ImpostorTexture for the specified entity. If one does not
already exist, one will automatically be created.
*/
static ImpostorTexture *getTexture(ImpostorPage *group, Ogre::Entity *entity);
/** remove created texture, note that all of the ImposterTextures
must be deleted at once, because there is no track if a texture is still
being used by something else
*/
static void removeTexture(ImpostorTexture* Texture);
void regenerate();
static void regenerateAll();
~ImpostorTexture();
protected:
ImpostorTexture(ImpostorPage *group, Ogre::Entity *entity);
void renderTextures(bool force); // Renders the impostor texture grid
void updateMaterials(); // Updates the materials to use the latest rendered impostor texture grid
Ogre::String removeInvalidCharacters(Ogre::String s);
static std::map<Ogre::String, ImpostorTexture *> selfList;
Ogre::SceneManager *sceneMgr;
Ogre::Entity *entity;
Ogre::String entityKey;
Ogre::MaterialPtr material[IMPOSTOR_PITCH_ANGLES][IMPOSTOR_YAW_ANGLES];
Ogre::TexturePtr texture;
Ogre::ResourceHandle sourceMesh;
Ogre::AxisAlignedBox boundingBox;
float entityDiameter, entityRadius;
Ogre::Vector3 entityCenter;
static unsigned long GUID;
static inline Ogre::String getUniqueID(const Ogre::String &prefix)
{
return prefix + Ogre::StringConverter::toString(++GUID);
}
//This will only be used when IMPOSTOR_FILE_SAVE is set to 0
std::auto_ptr<ImpostorTextureResourceLoader> loader;
};
//-------------------------------------------------------------------------------------
//This is an inline function from ImposterBatch that had to be defined down below the
//ImpostorTexture class, because it uses it.
void ImpostorBatch::addBillboard(const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, const Ogre::Vector3 &scale, const Ogre::ColourValue &color)
{
//float degrees = (Math::ACos(rotation.w)*2.0f).valueDegrees();
const Ogre::Vector3 zVector = rotation * Ogre::Vector3::UNIT_Z;
float degrees = Ogre::Math::ATan2(zVector.x, zVector.z).valueDegrees();
if (degrees < 0) degrees += 360;
int n = IMPOSTOR_YAW_ANGLES * (degrees / 360.0f) + 0.5f;
Ogre::uint16 texCoordIndx = (IMPOSTOR_YAW_ANGLES - n) % IMPOSTOR_YAW_ANGLES;
bbset->createBillboard(position + (rotation * entityBBCenter) * scale,
tex->entityDiameter * 0.5f * (scale.x + scale.z),
tex->entityDiameter * scale.y, color,
texCoordIndx);
}
}
#endif
| 38.440341 | 248 | 0.714877 | [
"mesh",
"geometry",
"render",
"object",
"3d"
] |
43c7f65e45d1a53449d852d22f6f6ae4c7b10774 | 3,105 | h | C | CCA/Components/MPM/Materials/ConstitutiveModel/Biswajit/Models/KinematicHardening_None.h | QuocAnh90/Uintah_Aalto | 802c236c331b7eb705d408c352969037e4c5b153 | [
"MIT"
] | 3 | 2020-06-10T08:21:31.000Z | 2020-06-23T18:33:16.000Z | CCA/Components/MPM/Materials/ConstitutiveModel/Biswajit/Models/KinematicHardening_None.h | QuocAnh90/Uintah_Aalto | 802c236c331b7eb705d408c352969037e4c5b153 | [
"MIT"
] | null | null | null | CCA/Components/MPM/Materials/ConstitutiveModel/Biswajit/Models/KinematicHardening_None.h | QuocAnh90/Uintah_Aalto | 802c236c331b7eb705d408c352969037e4c5b153 | [
"MIT"
] | 2 | 2019-12-30T05:48:30.000Z | 2020-02-12T16:24:16.000Z | /*
* The MIT License
*
* Copyright (c) 1997-2019 The University of Utah
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#ifndef __BB_NO_KINEMATIC_HARDENING_MODEL_H__
#define __BB_NO_KINEMATIC_HARDENING_MODEL_H__
#include "KinematicHardeningModel.h"
#include <Core/ProblemSpec/ProblemSpecP.h>
namespace UintahBB {
/////////////////////////////////////////////////////////////////////////////
/*!
\class KinematicHardening_None
\brief Default kinematic hardening model - no kinematic hardening
\author Biswajit Banerjee,
Department of Mechanical Engineering,
University of Utah
*/
/////////////////////////////////////////////////////////////////////////////
class KinematicHardening_None : public KinematicHardeningModel {
private:
// Prevent copying of this class
// copy constructor
//KinematicHardening_None(const KinematicHardening_None &cm);
KinematicHardening_None& operator=(const KinematicHardening_None &cm);
public:
// constructors
KinematicHardening_None();
KinematicHardening_None(Uintah::ProblemSpecP& ps);
KinematicHardening_None(const KinematicHardening_None* cm);
// destructor
virtual ~KinematicHardening_None();
virtual void outputProblemSpec(Uintah::ProblemSpecP& ps);
//////////
/*! \brief Calculate the back stress */
//////////
virtual void computeBackStress(const ModelState* state,
const double& delT,
const Uintah::particleIndex idx,
const double& delLambda,
const Uintah::Matrix3& df_dsigma_new,
const Uintah::Matrix3& backStress_old,
Uintah::Matrix3& backStress_new);
void eval_h_beta(const Uintah::Matrix3& df_dsigma,
const ModelState* state,
Uintah::Matrix3& h_beta);
};
} // End namespace Uintah
#endif // __BB_NO_KINEMATIC_HARDENING_MODEL_H__
| 36.964286 | 79 | 0.647343 | [
"model"
] |
43c8378cc73c1001ff1d84302a371725c3c8c393 | 26,460 | h | C | watch/watch_impl.h | kstepanmpmg/mldb | f78791cd34d01796705c0f173a14359ec1b2e021 | [
"Apache-2.0"
] | 1 | 2019-04-29T12:39:34.000Z | 2019-04-29T12:39:34.000Z | watch/watch_impl.h | tomzhang/mldb | a09cf2d9ca454d1966b9e49ae69f2fe6bf571494 | [
"Apache-2.0"
] | 2 | 2021-03-20T05:52:26.000Z | 2021-11-15T17:52:54.000Z | watch/watch_impl.h | matebestek/mldb | f78791cd34d01796705c0f173a14359ec1b2e021 | [
"Apache-2.0"
] | 1 | 2018-11-23T20:03:38.000Z | 2018-11-23T20:03:38.000Z | // This file is part of MLDB. Copyright 2015 mldb.ai inc. All rights reserved.
/* watch_impl.h -*- C++ -*-
Jeremy Barnes, 21 May 2014
Copyright (c) 2014 mldb.ai inc. All rights reserved.
Implementation of watch methods.
*/
#pragma once
#include "mldb/watch/watch.h"
#include "mldb/arch/futex.h"
#include <thread>
#include <atomic>
#include <list>
#include "mldb/types/value_description.h"
#include "mldb/types/tuple_description.h"
#include "mldb/types/any_impl.h"
#include "mldb/types/date.h" // TODO: shouldn't need this
namespace MLDB {
/*****************************************************************************/
/* WATCH DATA */
/*****************************************************************************/
/** Abstract class that implements the data being held for a watch. */
struct WatchData {
WatchData(Watches * owner,
const std::type_info * boundType = nullptr,
Any info = nullptr);
virtual ~WatchData();
virtual void setHolder(Watch & newHolder);
virtual void transferHolder(Watch && oldHolder, Watch & newHolder);
virtual void releaseHolder(Watch & holder);
virtual void releaseHolderForDestroy(Watch & holder);
virtual void bindGeneric(const std::function<void (const Any &) > & fn,
WatchErrorHandler errorFn) = 0;
virtual bool tryBindNonRecursiveGeneric(const std::function<void (const Any &) > & fn,
WatchErrorHandler errorFn) = 0;
virtual bool bound() const = 0;
virtual void unbind() = 0;
/** Trigger from a Any containing a std::tuple of the types
necessary to make the call.
*/
virtual void triggerGeneric(const Any & vals) = 0;
/** Trigger from a Any containing a std::tuple of the types
necessary to make the call.
This is used for re-entrant calls, where the object is already
locked.
*/
virtual void triggerGenericLocked(const Any & vals) = 0;
/** Trigger the watch. */
virtual void error(const WatchError & error) = 0;
/** Trigger the watch, with the lock already taken. */
virtual void errorLocked(const WatchError & error) = 0;
virtual bool any() const = 0;
virtual int count() const = 0;
/** Wait synchronously for an event, or throw an exception if none
found in that time.
*/
Any waitGeneric(double timeToWait = INFINITY);
/** Try to wait synchronously for the event. Returns true in the first
element and the returned value if successful, or false and a null
tuple if not successful.
*/
virtual std::pair<bool, Any>
tryWaitGeneric(double timeToWait = INFINITY) = 0;
/** Try to wait synchronously for the event.
Return values:
- If there was a timeout, return a null maybe (result.isNull() == true)
- If an error was received, return it in the maybe error
(result.isNull() == false, result == false, result.err() has result)
- If a value was received, return it in the maybe value
(result.isNull() == false, result == true, result.val() has value)
*/
virtual MaybeT<Any, WatchError>
tryWaitMaybeGeneric(double timeToWait = INFINITY) = 0;
/** Cause the other watch to send its events to this one. */
virtual void multiplex(Watch && other) = 0;
/** Return the type we're bound into. */
const std::type_info * boundType() const
{
return boundType_;
}
std::shared_ptr<const ValueDescription>
boundValueDescription() const;
void waitForInProgressEvents() const;
Watch * holder;
Watches * owner;
const std::type_info * boundType_;
Any info; ///< Information set by the watcher
int triggers; ///< Number of times triggered
int errors; ///< Number of errors
private:
/// Structure to track ownership of the lock object as sometimes
/// the WatchData can be destroyed with the lock held, and we need
/// to be able to clean up.
struct LockInfo {
std::recursive_mutex mutex;
};
/// Private to force derived classes to use lock()
std::shared_ptr<LockInfo> lockInfo;
protected:
/** Object that acts as a guard but also takes ownership of the LockInfo
so that if the object is destroyed when locked we don't have
invalid memory accesses when unlocking.
*/
struct Locker : public std::unique_lock<std::recursive_mutex> {
Locker(std::shared_ptr<LockInfo> w)
: std::unique_lock<std::recursive_mutex>(w->mutex),
w(w)
{
}
Locker(Locker && other)
: std::unique_lock<std::recursive_mutex>(std::move(other)),
w(std::move(other.w))
{
other.w = nullptr;
}
Locker & operator = (Locker && other)
{
swap(other);
return *this;
}
void swap(Locker & other)
{
std::unique_lock<std::recursive_mutex>::swap(other);
std::swap(w, other.w);
}
void unlock()
{
std::unique_lock<std::recursive_mutex>::unlock();
w = nullptr;
}
~Locker()
{
if (!w)
return;
unlock();
}
std::shared_ptr<LockInfo> w;
};
Locker lock() const
{
return Locker(lockInfo);
}
};
/*****************************************************************************/
/* UNKNOWN TYPE WATCH DATA */
/*****************************************************************************/
/** Watch data used when the type of the watch isn't known until it is
bound or used.
*/
struct UnknownTypeWatchData: public WatchData {
UnknownTypeWatchData(Watches * owner,
std::function<bool (const Any &)> filterFn,
Any info);
virtual void triggerGeneric(const Any & vals);
virtual void triggerGenericLocked(const Any & vals);
/** Trigger the watch. */
virtual void error(const WatchError & error);
/** Trigger the watch, with the lock already taken. */
virtual void errorLocked(const WatchError & error);
virtual bool any() const
{
auto l = lock();
return numSaved;
}
virtual int count() const
{
auto l = lock();
return numSaved;
}
virtual std::pair<bool, Any>
tryWaitGeneric(double timeToWait = INFINITY);
virtual MaybeT<Any, WatchError>
tryWaitMaybeGeneric(double timeToWait = INFINITY);
virtual void bindGeneric(const std::function<void (const Any &) > & fn,
WatchErrorHandler errorFn);
virtual bool tryBindNonRecursiveGeneric(const std::function<void (const Any &) > & fn,
WatchErrorHandler errorFn);
virtual bool bound() const;
virtual void unbind();
virtual void multiplex(Watch && other);
typedef MaybeT<Any, WatchError> Maybe;
/// Events that have occurred but not been consumed yet
std::list<Maybe> saved;
/// Number of saved events. Used as a futex.
std::atomic<int> numSaved;
/// Function that gets the triggers
std::function<void (const Any &)> boundFn;
/// Function that gets the errors
WatchErrorHandler errorFn;
/// Function that does the filtering
std::function<bool (const Any &)> filterFn;
/// Multiplexed watches
std::vector<Watch> multiplexed;
};
/*****************************************************************************/
/* TYPED WATCH DATA */
/*****************************************************************************/
template<typename... T>
struct WatchDataT: public WatchData {
WatchDataT(Watches * owner,
std::function<bool (const T &...)> filterFn,
Any info);
/** Bind an asynchronous callback. */
void bind(const std::function<void (const T &...)> & boundFn,
WatchErrorHandler errorFn);
bool tryBindNonRecursive(const std::function<void (const T &...)> & fn,
WatchErrorHandler errorFn);
virtual void bindGeneric(const std::function<void (const Any &) > & fn,
WatchErrorHandler errorFn);
virtual bool tryBindNonRecursiveGeneric(const std::function<void (const Any &) > & fn,
WatchErrorHandler errorFn);
virtual bool bound() const;
/** Unbind an asynchronous callback. */
virtual void unbind();
virtual void multiplex(Watch && other);
virtual bool any() const
{
auto l = lock();
return numSaved;
}
virtual int count() const
{
auto l = lock();
return numSaved;
}
/** Type returned from wait. For a single type, it's just that type.
For multiple types, it's a tuple.
*/
typedef typename std::decay<decltype(detuplize(std::declval<std::tuple<T...> >()))>::type WaitReturnType;
/** Wait synchronously for an event, or throw an exception if none
found in that time.
*/
WaitReturnType
wait(double timeToWait = INFINITY);
WaitReturnType
pop()
{
return wait(0.0);
}
std::tuple<T...>
waitTuple(double timeToWait = INFINITY);
/** Try to wait synchronously for the event. Returns true in the first
element and the returned value if successful, or false and a null
tuple if not successful.
*/
std::pair<bool, WaitReturnType>
tryWait(double timeToWait = INFINITY);
std::pair<bool, std::tuple<T...> >
tryWaitTuple(double timeToWait = INFINITY);
MaybeT<std::tuple<T...>, WatchError>
tryWaitMaybe(double timeToWait = INFINITY);
/** Trigger the watch. */
void trigger(const T &... args);
/** Trigger the watch. */
void triggerLocked(const T &... args);
/** Trigger the watch from a generic value */
virtual void triggerGeneric(const Any & vals);
/** Trigger the watch from a generic value */
virtual void triggerGenericLocked(const Any & vals);
/** Trigger the watch. */
virtual void error(const WatchError & error);
/** Trigger the watch, with the lock already taken. */
virtual void errorLocked(const WatchError & error);
/** Try to wait synchronously for the event. Returns true in the first
element and the returned value if successful, or false and a null
tuple if not successful.
*/
virtual std::pair<bool, Any>
tryWaitGeneric(double timeToWait = INFINITY);
virtual MaybeT<Any, WatchError>
tryWaitMaybeGeneric(double timeToWait = INFINITY);
typedef MaybeT<std::tuple<T...>, WatchError> Maybe;
/// Events that have occurred but not been consumed yet
std::list<Maybe> saved;
/// Number of saved events. Used as a futex.
std::atomic<int> numSaved;
/// Function that does the watching
std::function<void (const T &...)> boundFn;
/// Function that gets the errors
WatchErrorHandler errorFn;
/// Function that does filtering
std::function<bool (const T &...)> filterFn;
/// Set of multiplexed watches
std::vector<WatchT<T...> > multiplexed;
};
/*****************************************************************************/
/* WATCHT */
/*****************************************************************************/
template<typename... T>
WatchT<T...>::
WatchT(WatchDataT<T...> * data)
: Watch(data)
{
}
template<typename... T>
WatchT<T...> &
WatchT<T...>::
operator = (WatchT && other)
{
if (other.data)
other.data->transferHolder(std::move(other), *this);
else if (this->data) {
this->data->releaseHolder(*this);
}
this->piggyback = std::move(other.piggyback);
return *this;
}
template<typename... T>
WatchT<T...> &
WatchT<T...>::
operator = (Watch && other)
{
if (other.boundType()
&& other.boundType() != &typeid(std::tuple<T...>))
throwException(WATCH_ERR_TYPE,
"Attempt to bind watch of type '%s' from watch of type '%s'",
MLDB::type_name<std::tuple<T...> >().c_str(),
demangle(*other.boundType()).c_str());
if (other.data)
other.data->transferHolder(std::move(other), *this);
else if (this->data) {
this->data->releaseHolder(*this);
}
this->piggyback = std::move(other.piggyback);
return *this;
}
template<typename... T>
void
WatchT<T...>::
bind(const std::function<void (const T &...)> & fn,
WatchErrorHandler errorFn)
{
ExcAssert(data);
auto d = dataT();
if (d)
d->bind(fn, std::move(errorFn));
else {
// Generic watch; need to unpack it
auto bindFn = [=] (const Any & any)
{
auto tpl = any.as<std::tuple<T...> >();
callFromTuple(fn, tpl);
};
data->bindGeneric(bindFn, std::move(errorFn));
}
}
template<typename... T>
bool
WatchT<T...>::
tryBindNonRecursive(const std::function<void (const T &...)> & fn,
WatchErrorHandler errorFn)
{
ExcAssert(data);
auto d = dataT();
if (d)
return d->tryBindNonRecursive(fn, std::move(errorFn));
else {
// Generic watch; need to unpack it
auto bindFn = [=] (const Any & any)
{
auto tpl = any.as<std::tuple<T...> >();
callFromTuple(fn, tpl);
};
return data->tryBindNonRecursiveGeneric(bindFn, std::move(errorFn));
}
}
template<typename... T>
void
WatchT<T...>::
bindNonRecursive(const std::function<void (const T &...)> & fnToBind,
const std::function<void (const T &...)> & fnRecursive,
WatchErrorHandler errorFnToBind,
const WatchErrorHandler & errorFnRecursive)
{
while (!tryBindNonRecursive(fnToBind, errorFnToBind)) {
auto val = popMaybe();
if (val) {
callFromTuple(fnRecursive, val.val());
}
else errorFnRecursive(val.err());
}
}
/** Unbind an asynchronous callback function from the watch. */
template<typename... T>
void
WatchT<T...>::
unbind()
{
data->unbind();
}
template<typename... T>
typename WatchT<T...>::WaitReturnType
WatchT<T...>::
wait(double timeToWait)
{
return detuplize(waitTuple(timeToWait));
}
template<typename... T>
std::tuple<T...>
WatchT<T...>::
waitTuple(double timeToWait)
{
ExcAssert(data);
auto d = dataT();
if (d)
return d->waitTuple(timeToWait);
auto a = data->waitGeneric(timeToWait);
if (&a.type() != &typeid(std::tuple<T...>))
throwException(WATCH_ERR_TYPE,
"waiting for %s but got %s",
MLDB::type_name<std::tuple<T...> >().c_str(),
demangle(a.type().name()).c_str());
return a.as<std::tuple<T...> >();
}
template<typename... T>
std::pair<bool, typename WatchT<T...>::WaitReturnType>
WatchT<T...>::
tryWait(double timeToWait)
{
auto res = tryWaitTuple(timeToWait);
return std::make_pair(res.first, detuplize(res.second));
}
template<typename... T>
std::pair<bool, std::tuple<T...> >
WatchT<T...>::
tryWaitTuple(double timeToWait)
{
auto d = dataT();
if (d)
return d->tryWaitTuple(timeToWait);
else {
auto res = data->tryWaitGeneric(timeToWait);
if (!res.first)
return std::make_pair(false, std::tuple<T...>());
return std::make_pair(true, res.second.as<std::tuple<T...> >());
}
}
template<typename... T>
std::pair<bool, std::tuple<T...> >
WatchT<T...>::
doTryWaitTuple(WatchData * data, double timeToWait)
{
// Try to do it directly
auto * cast = dynamic_cast<WatchDataT<T...> *>(data);
//ExcAssertEqual(&typeid(*data), &typeid(WatchDataT<T...>));
if (cast)
return cast->tryWaitTuple(timeToWait);
// Do it generically and cast the result back
auto res = data->tryWaitGeneric(timeToWait);
if (!res.first)
return std::make_pair(false, std::tuple<T...>());
return std::make_pair(true, res.second.as<std::tuple<T...> >());
}
template<typename... T>
typename WatchT<T...>::Maybe
WatchT<T...>::
waitMaybe(double timeToWait)
{
Maybe result = tryWaitMaybe(timeToWait);
if (result.isNull())
throwException(WATCH_ERR_TIMEOUT, "Watch timed out");
return result;
}
template<typename... T>
typename WatchT<T...>::Maybe
WatchT<T...>::
tryWaitMaybe(double timeToWait)
{
// Try to do it directly
auto * cast = dynamic_cast<WatchDataT<T...> *>(data);
if (cast)
return cast->tryWaitMaybe(timeToWait);
// Do it generically and cast the result back
auto res = data->tryWaitMaybeGeneric(timeToWait);
if (!res)
return res.err();
// Convert the returned any to the right type
return res.val().as<std::tuple<T...> >();
}
template<typename... T>
void
WatchT<T...>::
trigger(T... args)
{
auto d = dataT();
if (d)
d->trigger(std::forward<T>(args)...);
else data->triggerGeneric(std::tuple<T...>(args...));
}
template<typename... T>
WatchDataT<T...> *
WatchT<T...>::
dataT()
{
ExcAssert(data);
return dynamic_cast<WatchDataT<T...> *>(this->data);
}
template<typename... T>
const WatchDataT<T...> *
WatchT<T...>::
dataT() const
{
ExcAssert(data);
return dynamic_cast<const WatchDataT<T...> *>(this->data);
}
/*****************************************************************************/
/* WATCHEST */
/*****************************************************************************/
template<typename... T>
WatchesT<T...>::
WatchesT()
: Watches(&typeid(std::tuple<T...>),
maybeGetDefaultDescriptionShared<std::tuple<T...> >())
{
}
template<typename... T>
WatchT<T...>
WatchesT<T...>::
add(Any info,
std::function<bool (const T &...)> filterFn)
{
std::unique_lock<std::mutex> guard(mutex);
watches.emplace_back(new WatchDataT<T...>(this, filterFn, std::move(info)));
return WatchT<T...>(watches.back().get());
}
template<typename... T>
void
WatchesT<T...>::
trigger(const T &... args)
{
std::unique_lock<std::mutex> guard(mutex);
triggerThread = std::this_thread::get_id();
++triggers;
for (auto & w: watches) {
static_cast<WatchDataT<T...> *>(w.get())
->trigger(args...);
}
triggerThread = std::thread::id();
}
/*****************************************************************************/
/* WATCH DATA T */
/*****************************************************************************/
template<typename... T>
WatchDataT<T...>::
WatchDataT(Watches * owner,
std::function<bool (const T &...)> filterFn,
Any info)
: WatchData(owner, &typeid(std::tuple<T...>), std::move(info)),
numSaved(0),
filterFn(std::move(filterFn))
{
}
template<typename... T>
void
WatchDataT<T...>::
bind(const std::function<void (const T &...)> & boundFn,
WatchErrorHandler errorFn)
{
// TODO: errorFn...
auto guard(this->lock());
ExcAssert(!this->boundFn);
this->boundFn = boundFn;
this->errorFn = errorFn;
for (auto & s: saved) {
if (s)
callFromTuple(boundFn, std::move(s.val()));
else {
errorFn(s.err());
}
}
saved.clear();
numSaved = 0;
}
template<typename... T>
bool
WatchDataT<T...>::
tryBindNonRecursive(const std::function<void (const T &...)> & boundFn,
WatchErrorHandler errorFn)
{
auto guard(this->lock());
ExcAssert(!this->boundFn);
if (!saved.empty())
return false;
this->boundFn = boundFn;
this->errorFn = errorFn;
for (auto & s: saved) {
if (s)
callFromTuple(boundFn, std::move(s.val()));
else {
errorFn(s.err());
}
}
saved.clear();
numSaved = 0;
return true;
}
template<typename... T>
void
WatchDataT<T...>::
bindGeneric(const std::function<void (const Any &) > & fn,
WatchErrorHandler errorFn)
{
auto realBoundFn = [=] (const T &... args)
{
fn(Any(std::tuple<T...>(args...)));
};
bind(realBoundFn, std::move(errorFn));
}
template<typename... T>
bool
WatchDataT<T...>::
tryBindNonRecursiveGeneric(const std::function<void (const Any &) > & fn,
WatchErrorHandler errorFn)
{
auto realBoundFn = [=] (const T &... args)
{
fn(Any(std::tuple<T...>(args...)));
};
return tryBindNonRecursive(realBoundFn, std::move(errorFn));
}
template<typename... T>
bool
WatchDataT<T...>::
bound() const
{
auto guard(this->lock());
return this->boundFn.operator bool();
}
/** Unbind an asynchronous callback. */
template<typename... T>
void
WatchDataT<T...>::
unbind()
{
auto guard(this->lock());
this->boundFn = nullptr;
this->errorFn = nullptr;
}
template<typename... T>
void
WatchDataT<T...>::
multiplex(Watch && other)
{
auto guard(this->lock());
multiplexed.emplace_back(std::move(other));
// Bind it in so that we get the events
auto recursiveTrigger = std::make_shared<bool>(true);
auto onEvent = [=] (const T &... args)
{
if (*recursiveTrigger)
this->triggerLocked(args...);
else this->trigger(args...);
};
auto errorFn = [=] (const WatchError & error)
{
if (*recursiveTrigger)
this->errorLocked(error);
else this->error(error);
};
multiplexed.back().bind(onEvent, errorFn);
*recursiveTrigger = false;
}
template<typename... T>
typename WatchDataT<T...>::WaitReturnType
WatchDataT<T...>::
wait(double timeToWait)
{
return detuplize(waitTuple(timeToWait));
}
template<typename... T>
std::tuple<T...>
WatchDataT<T...>::
waitTuple(double timeToWait)
{
bool found;
std::tuple<T...> res;
std::tie(found, res) = tryWaitTuple(timeToWait);
if (!found)
owner->throwException(WATCH_ERR_TIMEOUT,
"No event found before timeout");
return std::move(res);
}
template<typename... T>
std::pair<bool, typename WatchDataT<T...>::WaitReturnType>
WatchDataT<T...>::
tryWait(double timeToWait)
{
auto res = tryWaitTuple(timeToWait);
return std::make_pair(res.first, detuplize(res.second));
}
template<typename... T>
std::pair<bool, std::tuple<T...> >
WatchDataT<T...>::
tryWaitTuple(double timeToWait)
{
auto val = tryWaitMaybe(timeToWait);
if (val.isNull())
return std::make_pair(false, std::tuple<T...>());
else if (!val)
throw WatchException(std::move(val.err()));
else return std::make_pair(true, std::move(val.val()));
}
template<typename... T>
MaybeT<std::tuple<T...>, WatchError>
WatchDataT<T...>::
tryWaitMaybe(double timeToWait)
{
if (boundFn)
owner->throwException(WATCH_ERR_WAIT_BOUND,
"cannot wait on a bound watch");
Date limit = Date::now().plusSeconds(timeToWait);
for (;;) {
double secondsToWait
= std::max(0.0, Date::now().secondsUntil(limit));
if (secondsToWait > 0) {
MLDB::futex_wait(numSaved, 0, secondsToWait);
if (!numSaved)
continue;
}
else {
if (!numSaved)
return MaybeT<std::tuple<T...>, WatchError>();
}
auto guard(this->lock());
if (numSaved == 0) {
if (secondsToWait > 0.0)
continue;
else
return MaybeT<std::tuple<T...>, WatchError>();
}
ExcAssert(!saved.empty());
auto el = std::move(saved.front());
saved.pop_front();
--numSaved;
return el;
}
}
template<typename... T>
void
WatchDataT<T...>::
trigger(const T &... args)
{
auto guard = this->lock();
triggerLocked(args...);
}
template<typename... T>
void
WatchDataT<T...>::
triggerLocked(const T &... args)
{
++this->triggers;
if (filterFn && !filterFn(args...))
return;
// No lock, assume it's already taken
if (boundFn && saved.empty())
boundFn(args...);
else {
saved.emplace_back(std::tuple<T...>(args...));
++numSaved;
MLDB::futex_wake(numSaved);
}
}
template<typename... T>
void
WatchDataT<T...>::
triggerGeneric(const Any & vals)
{
auto tupl = vals.as<std::tuple<T...> >();
callFromTuple(std::mem_fn(&WatchDataT::trigger), tupl, this);
}
template<typename... T>
void
WatchDataT<T...>::
triggerGenericLocked(const Any & vals)
{
auto tupl = vals.as<std::tuple<T...> >();
callFromTuple(std::mem_fn(&WatchDataT::triggerLocked), tupl, this);
}
template<typename... T>
void
WatchDataT<T...>::
error(const WatchError & error)
{
auto guard = this->lock();
errorLocked(error);
}
template<typename... T>
void
WatchDataT<T...>::
errorLocked(const WatchError & error)
{
++this->errors;
if (errorFn) {
ExcAssert(saved.empty());
errorFn(error);
}
else {
saved.emplace_back(error);
++numSaved;
MLDB::futex_wake(numSaved);
}
}
template<typename... T>
std::pair<bool, Any>
WatchDataT<T...>::
tryWaitGeneric(double timeToWait)
{
std::pair<bool, std::tuple<T...> > res = tryWaitTuple(timeToWait);
if (!res.first)
return std::make_pair(false, Any());
return std::make_pair(true, Any(res.second));
}
template<typename... T>
MaybeT<Any, WatchError>
WatchDataT<T...>::
tryWaitMaybeGeneric(double timeToWait)
{
MaybeT<std::tuple<T...>, WatchError> res
= this->tryWaitMaybe(timeToWait);
if (res.isNull())
return MaybeT<Any, WatchError>(); // timeout
else if (!res)
return MaybeT<Any, WatchError>(std::move(res.err())); // error
else return MaybeT<Any, WatchError>(std::move(res.val()));
}
} // namespace MLDB
| 25.966634 | 109 | 0.561678 | [
"object",
"vector"
] |
43cc2316f84a515da83d7ca06cb4fb8c7792172a | 2,701 | h | C | src/mod.h | mattvenn/sled | 680a3fa782fa999afdfd8773de390290f4c57104 | [
"ISC"
] | null | null | null | src/mod.h | mattvenn/sled | 680a3fa782fa999afdfd8773de390290f4c57104 | [
"ISC"
] | null | null | null | src/mod.h | mattvenn/sled | 680a3fa782fa999afdfd8773de390290f4c57104 | [
"ISC"
] | null | null | null | // Module manager
#ifndef __INCLUDED_MOD__
#define __INCLUDED_MOD__
#include "asl.h"
#include "types.h"
// As of the refactor, 'module' is one struct.
// This is because otherwise we end up with way too much module-type-specific-code
// in k2link and other module-related handlers.
#undef RGB
typedef struct module module;
struct module {
// These two are initialized in mod_new
// "gfx\0"
char type[4];
// "gfx_example\0"
char name[256];
// For flt, this is the next module in the output chain. This is set on load.
int chain_link;
// This is the second list of function declarations.
// It must be in the order given in plugin.h,
// and it must be kept in sync with k2link, and mod_dl.c
// [FUNCTION_DECLARATION_WEBRING]
// See: plugin.h, mod.h, k2link, mod_dl.c
int (*init)(int moduleno, char* argstr);
void (*reset)(int moduleno);
int (*draw)(int moduleno, int argc, char* argv[]);
int (*set)(int moduleno, int x, int y, RGB color);
RGB (*get)(int moduleno, int x, int y);
int (*clear)(int moduleno);
int (*render)(int moduleno);
int (*getx)(int moduleno);
int (*gety)(int moduleno);
ulong (*wait_until)(int moduleno, ulong desired_usec);
void (*wait_until_break)(int moduleno);
void (*setdir)(int moduleno, const char* dir);
int (*load)(int moduleno, module* mod, const char * name);
void (*unload)(int moduleno, void* modloader_user);
void (*findmods)(int moduleno, asl_av_t* result);
void (*deinit)(int moduleno);
// Responsible modloader. (Note: The k2link bootstrap modloader uses an index of -1.)
int responsible_modloader;
// Userdata owned by the mod_ module that loaded this.
void* modloader_user;
// Userdata owned by the module.
void* user;
// Is this module a valid drawable? (GFX/BGM that is initialized)
// This is a boolean, and it's really just a safety in case someone abuses fish.
int is_valid_drawable;
};
#define RGB(r, g, b) RGB_C(r, g, b)
// Here's a description of the current module system.
// The lifecycle of SLED's module system is:
// Load & Init MOD (at the same time)
// Load & Init OUT/FLT
// Load GFX/BGM
// -- THREAD SAFETY STARTS HERE (modules are not loaded or unloaded in this block) --
// Init GFX/BGM
// (run...)
// Deinit GFX/BGM
// -- THREAD SAFETY ENDS HERE --
// Unload GFX/BGM
// Deinit & Unload OUT/FLT
// Deinit & Unload MOD
// Module IDs are essentially a 'stack'; gaps are NOT ALLOWED.
// DO NOT; REPEAT, DO NOT; CALL MODULE MANAGEMENT FUNCTIONS OUTSIDE OF MODLOADER.C!!!
// Actually, I'm moving the prototypes for *those* into modloader.c so you can't get at them.
// --
module* mod_find(const char* name);
int mod_getid(module* mod);
int mod_count();
module* mod_get(int moduleno);
#endif
| 32.939024 | 93 | 0.701592 | [
"render"
] |
43ceb65e231c0cb0e41143b19a385e9387f7bc1c | 33,940 | h | C | include/diplib/microscopy.h | KDAB/diplib | e55d56fab4982dfaeb0cc080d68e199973fec0e1 | [
"Apache-2.0"
] | 1 | 2021-07-07T01:02:57.000Z | 2021-07-07T01:02:57.000Z | include/diplib/microscopy.h | KDAB/diplib | e55d56fab4982dfaeb0cc080d68e199973fec0e1 | [
"Apache-2.0"
] | null | null | null | include/diplib/microscopy.h | KDAB/diplib | e55d56fab4982dfaeb0cc080d68e199973fec0e1 | [
"Apache-2.0"
] | null | null | null | /*
* DIPlib 3.0
* This file contains declarations for microscopy-related functionality
*
* (c)2017, Cris Luengo.
* Based on original DIPlib code: (c)1995-2014, Delft University of Technology.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DIP_MICROSCOPY_H
#define DIP_MICROSCOPY_H
#include "diplib.h"
/// \file
/// \brief Microscopy-related functionality.
/// See \ref microscopy.
namespace dip {
/// \group microscopy Microscopy
/// \brief Assorted tools useful in microscopy, some presumably also in astronomy and other applications.
/// \addtogroup
/// \brief Applies a logarithmic mapping to a transmittance image to obtain an absorbance image
///
/// The Beer-Lambert law describes how light is attenuated as it travels through an absorbing medium.
/// In brightfield microscopy, this law describes the relationship between the intensity of the transmitted
/// light and the absorbance of the stains on the slide, which provide contrast. The absorbance is influenced
/// by different factors, but for a given dye molecule, the concentration is directly proportional to the
/// absorbance. Thus, estimating absorbance yields an estimate of the relative dye concentration at each image
/// pixel.
///
/// This function applies the mapping $A$ to the intensities $I$ in image `in`.
///
/// $$ A = -log_{10}(I/I_0) \; , $$
///
/// with $I_0$ the intensity of the illumination (`background`), and $A$ the absorbance written to `out`).
///
/// `background` can be a single value or one value per tensor element (channel) in `in`. `out` will have the same
/// number of tensor elements. It should be estimated from a background region in the image, or from a
/// calibration image taken without a slide in the optical path.
///
/// `in` must be real-valued. Values outside of the range [0,`background`] will be clipped.
/// `out` will be a floating-point type (do not force it to be an integer type, as the rounding will destroy
/// all data).
DIP_EXPORT void BeerLambertMapping(
Image const& in,
Image& out,
Image::Pixel const& background
);
inline Image BeerLambertMapping(
Image const& in,
Image::Pixel const& background
) {
Image out;
BeerLambertMapping( in, out, background );
return out;
}
/// \brief Applies an exponential mapping to an absorbance image to obtain a transmittance image
///
/// Applies the inverse mapping of \ref dip::BeerLambertMapping, simulating the image obtained under a brightfield
/// microscope given the stain densities in the image `in`. `background` is the illumination intensity, values of
/// 0 in the input will be mapped to the value of `background`, whereas larger input values will be mapped to darker
/// values. Input values should be relatively small, such that `background * dip::Exp10(-input)` can be represented
/// in the output data type. Best results are obtained when the input is in the range [0,1], but larger values are
/// allowed.
///
/// `in` must be real-valued, negative values will be clipped to 0. `out` will be a floating-point type, unless
/// it was protected before calling this function (see \ref dip::Image::Protect).
DIP_EXPORT void InverseBeerLambertMapping(
Image const& in,
Image& out,
Image::Pixel const& background = { 255 }
);
inline Image InverseBeerLambertMapping(
Image const& in,
Image::Pixel const& background = { 255 }
) {
Image out;
InverseBeerLambertMapping( in, out, background );
return out;
}
/// \brief Unmixes stains in a brightfield absorbance image or a fluorescence emission image.
///
/// \section unmixstains_brightfield Brightfield
///
/// A color image, obtained from a brightfield microscope, and converted to an absorbance image by
/// \ref dip::BeerLambertMapping, can be separated into individual stains as long as there are no more
/// stains than channels. For an RGB image, up to three stains can be separated. For a multi-spectral
/// image, this number is larger.
///
/// The stain unmixing process requires knowledge of the absorption spectrum of each of the dyes on the slide.
/// These are usually determined using slides especially prepared with a single dye. Alternatively, find small
/// regions in the image where each stain is on its own (not mixed with other dyes). Below is a table
/// with values for some common dyes, which can be used as a first approximation. However, these
/// absorbance values depend on the tissue, tissue preparation and staining protocols, and imaging equipment.
/// Consequently, best results are always obtained with project-specific values.
///
/// The absorption of the dyes in each channel combine linearly with the density of each of the dyes,
///
/// $$ A_R = S_{R,1} d_1 + S_{R,2} d_2 + S_{R,3} d_3 + ... $$
///
/// with $S_{R,n}$ the absorbance of dye $n$ in the red channel, $d_n$ the density (concentration) of
/// dye $n$, and $A_R$ the total absorbance in the red channel. In matrix notation this leads to
///
/// $$ A = \mathbf{S} d \; . $$
///
/// Here, $A$ is a pixel in the multi-channel absorbance image (`in`), $\mathbf{S}$ is a matrix that
/// combines absorbance for each dye and each channel, and $d$ is a vector with the density for each
/// dye (a pixel in `out`). To find $d$, this linear set of equations needs to be solved. This process
/// is described by Ruifrok (2001). This function computes a Moore-Penrose pseudo-inverse of $\mathbf{S}$,
/// and applies a per-pixel matrix multiplication with `in` to obtain `out`.
///
/// `stains` is a `std::vector` that contains each of the columns of matrix $\mathbf{S}$. That is, each element
/// of `stains` is the values of one column of $\mathbf{S}$, which we refer to as a *stain vector*. These
/// stain vectors are represented by a \ref dip::Image::Pixel with the same number of tensor elements as `in`.
/// `stains` cannot have more elements than channels (tensor elements) are in `in`.
/// `out` will contain one channel for each stain. For example, assuming an RGB image with 3 channels, `stains` can
/// have one, two or three elements, each element being a \ref dip::Image::Pixel with exactly 3 elements (corresponding
/// to the 3 RGB channels).
///
/// Best results are obtained when each element of `stains` is normalized (i.e. the norm of each stain vector is 1);
/// this function does not normalize these stain vectors. The standard brightfield stain vectors given below are
/// normalized.
///
/// Example:
///
/// ```cpp
/// dip::Image img = dip::ImageReadTIFF( "brightfield.tif" );
/// img = dip::BeerLambertMapping( img, { 255 } );
/// img = dip::UnmixStains( img, {{ 0.644, 0.717, 0.267 }, { 0.268, 0.570, 0.776 }} );
/// dip::Image nuclei = img[ 0 ];
/// dip::Image dab = img[ 1 ];
/// ```
///
/// \section unmixstains_fluorescence Fluorescence
///
/// The explanation above translates to fluorescence imaging, replacing 'absorbance' with 'emission'. In the case
/// of fluorescence, \ref dip::BeerLambertMapping should not be used.
/// Typically, fluorescence imaging systems are set up such that each channel collects light only from a single dye,
/// but in practice it is not always possible to use dyes with perfectly separated emission spectra. Therefore, there
/// will be cross-talk, i.e. light from one dye is partially recorded in a channel set up for a different dye.
///
/// Again, it is possible to measure the emission intensity in each channel (or channel cross-talk ratios) using
/// slides prepared for the purpose, with a single dye.
///
/// In multi-spectral fluorescence imaging, channels are not set up specifically for each dye. Instead, the spectrum
/// is divided up into a set of channels. Each dye will be visible in a subset of these channels. Measuring the
/// emission strength for each dye in each channel again leads to the data to be written in `stains` to estimate
/// dye densities using this function.
///
/// \section unmixstains_standard_vectors Standard brightfield stain vectors
///
/// Stain name | RGB absorbance triplet
/// ----------------- | ----------------------
/// AEC | 0.274, 0.679, 0.680
/// Alican blue | 0.875, 0.458, 0.158
/// Aniline blue | 0.853, 0.509, 0.113
/// Azocarmine | 0.071, 0.977, 0.198
/// DAB | 0.268, 0.570, 0.776
/// Eosin | 0.093, 0.954, 0.283
/// Fast blue | 0.749, 0.606, 0.267
/// Fast red | 0.214, 0.851, 0.478
/// Feulgen | 0.464, 0.830, 0.308
/// Hematoxylin | 0.644, 0.717, 0.267
/// Hematoxylin + PAS | 0.553, 0.754, 0.354
/// Methyl blue | 0.799, 0.591, 0.105
/// Methyl green | 0.799, 0.591, 0.105
/// Methylene blue | 0.553, 0.754, 0.354
/// Orange-G | 0.107, 0.368, 0.923
/// PAS | 0.175, 0.972, 0.155
/// Ponceau-Fuchsin | 0.107, 0.368, 0.923
///
/// !!! literature
/// - A.C. Ruifrok and D.A. Johnston, "Quantification of histochemical staining by color deconvolution",
/// Analytical and Quantitative Cytology and Histology 23(4):291-299, 2001.
/// - Stain color triplets taken from CellProfiler,
/// [`unmixcolors.py`](https://github.com/CellProfiler/CellProfiler/blob/master/cellprofiler/modules/unmixcolors.py) module.
DIP_EXPORT void UnmixStains(
Image const& in,
Image& out,
std::vector< Image::Pixel > const& stains
);
inline Image UnmixStains(
Image const& in,
std::vector< Image::Pixel > const& stains
) {
Image out;
UnmixStains( in, out, stains );
return out;
}
/// \brief Composes a color image given stain densities and stain absorbance values (brightfield) or stain emission
/// values (fluorescence)
///
/// This function does the opposite of what \ref dip::UnmixStains does: it applies the per-pixel
/// matrix multiplication $A = \mathbf{S} d$ to obtain $A$ (`out`) from $d$ (`in`) and
/// $\mathbf{S}$ (composed from the values in `stains`).
///
/// `stains` is a vector with these absorbance/emission values, and should have the same number of
/// elements as channels (tensor elements) in the image `in`. Each element of the vector should have the
/// same number of channels, and these dictate the number of channels in the output image `out`. If `out`
/// has three channels, it will be tagged as an RGB image. Call \ref dip::InverseBeerLambertMapping with `out`
/// to create an image as seen through a brightfield microscope:
///
/// Example:
///
/// ```cpp
/// dip::Image img( { 1024, 1024 }, 2 );
/// dip::DrawBandlimitedBall( img, 300, { 400, 500 }, { 1.0, 0.0 } );
/// dip::DrawBandlimitedBall( img, 200, { 500, 600 }, { 0.0, 1.0 } );
/// img = dip::MixStains( img, {{ 0.644, 0.717, 0.267 }, { 0.268, 0.570, 0.776 }} );
/// img = dip::InverseBeerLambertMapping( img, { 255 } );
/// ```
///
/// If there are more stains than channels, this process is irreversible (that is, it will not be possible
/// to unmix the stains again).
DIP_EXPORT void MixStains(
Image const& in,
Image& out,
std::vector< Image::Pixel > const& stains
);
inline Image MixStains(
Image const& in,
std::vector< Image::Pixel > const& stains
) {
Image out;
MixStains( in, out, stains );
return out;
}
/// \brief Computes the Manders Overlap Coefficient.
///
/// The Manders Overlap Coefficient is defined similarly to the Pearson Correlation Coefficient, but without
/// subtracting the means from each of the variables,
///
/// $$ r = \frac{\sum{C_1(p) C_2(p)}}{\sqrt{\sum{C_1(p)^2}\sum{C_2(p)^2}}} \; , $$
///
/// with $C_1$ and $C_2$ the two channels.
/// Thus, it returns a value proportional to the fraction of pixels where both channels have a large value.
/// Do note the arguments against this method by Adler and Parmryd (2010).
///
/// The images must be scalar and real-valued.
///
/// If `mask` is not forged, all input pixels are considered. For this measure, it is very important to select
/// only relevant pixels, and exclude any background pixels with background staining. Furthermore, the zero
/// level is important, any offset should be subtracted first.
///
/// To compute the Manders Overlap Coefficient between two channels in a multi-channel image (a tensor image):
///
/// ```cpp
/// MandersOverlapCoefficient( in[ 0 ], in[ 1 ], mask );
/// ```
///
/// \see dip::PearsonCorrelation, dip::SpearmanRankCorrelation, dip::IntensityCorrelationQuotient, dip::MandersColocalizationCoefficients, dip::CostesColocalizationCoefficients
///
/// !!! literature
/// - E.M.M. Manders, F.J. Verbeek, and J.A. Aten, "Measurement of co-localization of objects in dual-color confocal images",
/// Journal of Microscopy 169(3):375-382, 1993.
/// - J. Adler, and I. Parmryd, "Quantifying colocalization by correlation: the Pearson correlation coefficient is superior
/// to the Mander's overlap coefficient", Cytometry A 77(8):733-42, 2010.
DIP_EXPORT dfloat MandersOverlapCoefficient(
Image const& channel1,
Image const& channel2,
Image const& mask = {}
);
/// \brief Computes Li's Intensity Correlation Quotient.
///
/// Li's Intensity Correlation Quotient is proportional to the fraction of pixels where the two channels vary in a
/// dependent manner. For each pixel, $c = (C_1 - \overline{C_1})(C_2 - \overline{C_2})$ is computed. Then the ICQ is
/// $\frac{|c>0|}{|c|} - 0.5$, with $|\cdot|$ the count operator.
///
/// The images must be scalar and real-valued. If `mask` is not forged, all input pixels are considered.
///
/// To compute Li's Intensity Correlation Quotient between two channels in a multi-channel image (a tensor image):
///
/// ```cpp
/// IntensityCorrelationQuotient( in[ 0 ], in[ 1 ], mask );
/// ```
///
/// \see dip::PearsonCorrelation, dip::SpearmanRankCorrelation, dip::MandersOverlapCoefficient
///
/// !!! literature
/// - Q. Li, A. Lau, T.J. Morris, L. Guo, C.B. Fordyce, and E.F. Stanley, "A Syntaxin 1, Gα^o^, and N-Type
/// Calcium Channel Complex at a Presynaptic Nerve Terminal: Analysis by Quantitative Immunocolocalization",
/// Journal of Neuroscience 24(16):4070-4081, 2004.
DIP_EXPORT dfloat IntensityCorrelationQuotient(
Image const& channel1,
Image const& channel2,
Image const& mask = {}
);
/// \brief Holds Colocalization Coefficients as described by Manders, see \ref dip::MandersColocalizationCoefficients.
struct ColocalizationCoefficients {
dfloat M1; ///< Proportional to the fraction of fluorescence in channel 1 that colocalizes.
dfloat M2; ///< Proportional to the fraction of fluorescence in channel 2 that colocalizes.
};
/// \brief Computes Manders' Colocalization Coefficients.
///
/// Manders' Colocalization Coefficients separate out the contributions in Manders Overlap Coefficient of the two
/// channels $C_1$ and $C_2$, defining two coefficients as the fraction of staining in one channel that
/// appears where the other channel has some staining,
///
/// $$ M_1 = \frac{\sum_{p|C_2(p) > 0}{C_1(p)}}{\sum_p{C_1(p)}} \; , \qquad
/// M_2 = \frac{\sum_{p|C_1(p) > 0}{C_2(p)}}{\sum_p{C_2(p)}} \; . $$
///
/// Note that if the two input images are binary, this is equivalent to computing the precision and sensitivity using
/// \ref dip::Precision and \ref dip::Sensitivity.
///
/// Here, instead of thresholding at 0, we apply `threshold1` for `channel1`, and `threshold2` for `channel2`. These
/// thresholds default to 0 to match the method proposed by Manders.
///
/// The images must be scalar and real-valued. Any negative values in the input images will cause wrong output,
/// make sure to clamp the input to 0 before calling this function.
/// If `mask` is not forged, all input pixels are considered.
///
/// To compute Manders' Colocalization Coefficients between two channels in a multi-channel image (a tensor image):
///
/// ```cpp
/// MandersColocalizationCoefficients( in[ 0 ], in[ 1 ], mask );
/// ```
///
/// \see dip::MandersOverlapCoefficient, dip::CostesColocalizationCoefficients
///
/// !!! literature
/// - E.M.M. Manders, F.J. Verbeek, and J.A. Aten, "Measurement of co-localization of objects in dual-color confocal images",
/// Journal of Microscopy 169(3):375-382, 1993.
DIP_EXPORT ColocalizationCoefficients MandersColocalizationCoefficients(
Image const& channel1,
Image const& channel2,
Image const& mask = {},
dfloat threshold1 = 0,
dfloat threshold2 = 0
);
/// \brief Computes Costes' colocalization coefficients.
///
/// Costes' Colocalization Coefficients are similar to Manders' colocalization coefficients, but uses a threshold
/// for each channel under which the correlation is zero. This threshold cuts out the background signal. Staining
/// is colocalized at those pixels where both channels are above their respective threshold.
/// The two coefficients are defined as the fraction of total staining that is colocalized,
///
/// $$ M_j = \frac{\sum_{p \in T}{C_j(p)}}{\sum_p{C_j(p)}} \;, j \in \{1,2\} \; , \qquad
/// T = C_1 > t_1 \wedge C_2 > t_2 $$
///
/// with $C_j$ the two input channels.
/// $t_j$ are the thresholds for each channel, with $t_2 = a t_1 + b$, and
/// $a$ and $b$ the slope and intercept of the regression line of the two-dimensional histogram. The thresholds
/// are successively lowered until the pixels that are not in $T$ exhibit no correlation between the two channels.
///
/// The images must be scalar and real-valued. Any negative values in the input images will cause wrong output,
/// make sure to clamp the input to 0 before calling this function.
/// If `mask` is not forged, all input pixels are considered.
///
/// To compute Costes' Colocalization Coefficients between two channels in a multi-channel image (a tensor image):
///
/// ```cpp
/// CostesColocalizationCoefficients( in[ 0 ], in[ 1 ], mask );
/// ```
///
/// \see dip::MandersColocalizationCoefficients
///
/// !!! literature
/// - S.V. Costes, D. Daelemans, E.H. Cho, Z. Dobbin, G. Pavlakis, and S. Lockett,
/// "Automatic and Quantitative Measurement of Protein-Protein Colocalization in Live Cells",
/// Biophysical Journal 86:3993-4003, 2004.
DIP_EXPORT ColocalizationCoefficients CostesColocalizationCoefficients(
Image const& channel1,
Image const& channel2,
Image const& mask = {}
);
/// \brief Computes Costes' test of significance of true colocalization
///
/// This test verifies whether there is colocalization in the image pair by comparing the correlation
/// between the two channels to that of a randomly shuffled version of the channels. When randomly
/// shuffling one of the channels, there no longer exists correlation. This test gives a significance
/// value to colocalization estimates, but does not quantify the amount of colocalization. Use one of
/// the methods listed below to quantify colocalization.
///
/// The algorithm shuffles one of the channels by dividing it into blocks of `blockSizes` pixels,
/// and randomly permuting these blocks. This is repeated `repetitions` times. The correlation
/// between the shuffled channel and the other channel is computed for each of these repetitions,
/// and a normal distribution is fitted to the obtained values. From this distribution, we compute
/// the probability that a correlation not larger than the correlation between the two channels is
/// obtained randomly. This probability (a P-value) is returned, and can be compared to, for example,
/// 0.95 to determine with a 5% confidence whether there exists true colocalization in the image
/// pair.
///
/// `blockSizes` should be set to the size of the point-spread function or the size of the texture
/// in the image. An appropriate value can be estimated as the smaller of the widths of the
/// autocorrelation functions for the two channels. If the block size is too small, the method
/// will overestimate the significance of the colocalization.
///
/// The images must be scalar and real-valued. If `mask` is not forged, all input pixels are considered.
/// If `mask` is forged, only blocks that overlap the masked area by at least 3/4 are used.
/// However, the full block is used, including the portion that falls outside the mask.
///
/// \see dip::PearsonCorrelation, dip::SpearmanRankCorrelation, dip::IntensityCorrelationQuotient, dip::MandersColocalizationCoefficients, dip::CostesColocalizationCoefficients
///
/// !!! literature
/// - S.V. Costes, D. Daelemans, E.H. Cho, Z. Dobbin, G. Pavlakis, and S. Lockett,
/// "Automatic and Quantitative Measurement of Protein-Protein Colocalization in Live Cells",
/// Biophysical Journal 86:3993-4003, 2004.
DIP_EXPORT dfloat CostesSignificanceTest(
Image const& channel1,
Image const& channel2,
Image const& mask = {},
UnsignedArray blockSizes = { 3 },
dip::uint repetitions = 200
);
/// \brief Generates an incoherent OTF (optical transfer function)
///
/// This function implements the formulae for a (defocused) incoherent OTF as described by Castleman.
///
/// The `defocus` is defined as the maximum defocus path length error divided by the wave length
/// (See Castleman for details).
/// When `defocus` is unequal to zero, either the Stokseth approximation or the Hopkins approximation
/// is used, depending on the value of `method` (which can be either `"Stokseth"` or `"Hopkins"`).
/// The summation over the Bessel functions in the Hopkins formulation is stopped when the change is
/// smaller than 0.0001 (this is a compile-time constant).
///
/// `oversampling` is the oversampling rate. If set to 1, the OTF is sampled at the Nyquist rate. Increase
/// the value to sample more densely.
///
/// `amplitude` is the value of the OTF at the origin, and thus equivalent to the integral over the PSF.
///
/// `out` will be scalar and of type \ref dip::DT_SFLOAT. It should have 1 or 2 dimensions, its sizes will be preserved.
/// If `out` has no sizes, a 256x256 image will be generated.
///
/// !!! literature
/// - K.R. Castleman, "Digital image processing", Second Edition, Prentice Hall, Englewood Cliffs, 1996.
DIP_EXPORT void IncoherentOTF(
Image& out,
dfloat defocus = 0,
dfloat oversampling = 1,
dfloat amplitude = 1,
String const& method = "Stokseth"
);
inline Image IncoherentOTF(
dfloat defocus = 0,
dfloat oversampling = 1,
dfloat amplitude = 1,
String const& method = "Stokseth"
) {
Image out;
IncoherentOTF( out, defocus, oversampling, amplitude, method );
return out;
}
/// \brief Generates an incoherent PSF (point spread function)
///
/// This function generates an incoherent in-focus point spread function of a diffraction limited objective.
///
/// `oversampling` is the oversampling rate. If set to 1, the OTF is sampled at the Nyquist rate. Increase
/// the value to sample more densely.
///
/// `amplitude` is the integral over the PSF.
///
/// `out` will be scalar and of type \ref dip::DT_SFLOAT. It should have 1 or 2 dimensions, its sizes will be preserved.
/// For 1D images, the PSF returned is a single line through the middle of a 2D PSF.
/// If `out` has no sizes, a square image of size `ceil(19*oversampling)` will be generated.
///
/// !!! literature
/// - K.R. Castleman, "Digital image processing", Second Edition, Prentice Hall, Englewood Cliffs, 1996.
DIP_EXPORT void IncoherentPSF(
Image& out,
dfloat oversampling = 1,
dfloat amplitude = 1
);
inline Image IncoherentPSF(
dfloat oversampling = 1,
dfloat amplitude = 1
) {
Image out;
IncoherentPSF( out, oversampling, amplitude );
return out;
}
/// \brief Wiener Deconvolution using estimates of signal and noise power
///
/// If $G$ is the Fourier transform of `in`, $H$ is the Fourier transform of `psf`,
/// and $F$ is the Fourier transform of `out`, then this function estimates the $F$ that optimally
/// (in the least squares sense) satisfies $G = FH$ (that is, `in` is the result of the convolution of
/// `out` with `psf`).
///
/// Finding `out` requires knowledge of the power spectrum of the signal and the noise. The Wiener deconvolution
/// filter is defined in the frequency domain as
///
/// $$ H_\text{inv} = \frac{H^* S}{ H^* H S + N } \; , $$
///
/// where $S$ is `signalPower`, and $N$ is `noisePower`. These functions are typically not known, but:
///
/// - `signalPower` can be estimated as the Fourier transform of the autocorrelation of `in`. If a raw image
/// is passed for this argument (`dip::Image{}`), then it will be computed as such.
///
/// - `noisePower` can be estimated as a flat function. A 0D image can be given here, it will be expanded to
/// the size of the other images. `noisePower` should not be zero anywhere, as that might lead to division
/// by zero and consequently meaningless results.
///
/// The other syntax for \ref dip::WienerDeconvolution takes an estimate of the noise-to-signal
/// ratio instead of the signal and noise power spectra. Note that $H_\text{inv}$ can be rewritten as
///
/// $$ H_\text{inv} = \frac{H^*}{ H^* H + \frac{N}{S} } = \frac{H^*}{ H^* H + K } \; , $$
///
/// where $K$ is the noise-to-signal ratio.
///
/// `psf` is given in the spatial domain, and will be zero-padded to the size of `in` and Fourier transformed.
/// The PSF (point spread function) should sum to one in order to preserve the mean image intensity.
/// If the OTF (optical transfer function, the Fourier transform of the PSF) is known, it is possible to pass
/// that as `psf`; add the string `"OTF"` to `options`.
///
/// All input images must be real-valued and scalar, except if the OFT is given instead of the PSF, in which
/// case `psf` could be complex-valued.
DIP_EXPORT void WienerDeconvolution(
Image const& in,
Image const& psf,
Image const& signalPower,
Image const& noisePower,
Image& out,
StringSet const& options = {}
);
inline Image WienerDeconvolution(
Image const& in,
Image const& psf,
Image const& signalPower,
Image const& noisePower,
StringSet const& options = {}
) {
Image out;
WienerDeconvolution( in, psf, signalPower, noisePower, out, options );
return out;
}
/// \brief Wiener Deconvolution using an estimate of noise-to-signal ratio
///
/// See the description of the function with the same name above. The difference here is that a single number,
/// `regularization`, is given instead of the signal and noise power spectra. We then set $K$ (the
/// noise-to-signal ratio) to `regularization * dip::Maximum(P)`, with `P` equal to $H^* H$.
DIP_EXPORT void WienerDeconvolution(
Image const& in,
Image const& psf,
Image& out,
dfloat regularization = 1e-4,
StringSet const& options = {}
);
inline Image WienerDeconvolution(
Image const& in,
Image const& psf,
dfloat regularization = 1e-4,
StringSet const& options = {}
) {
Image out;
WienerDeconvolution( in, psf, out, regularization, options );
return out;
}
/// \brief 3D fluorescence attenuation correction using an exponential fit
///
/// This routine implements a simple correction of absorption, reflection and bleaching in 3D fluorescence
/// imaging based upon the assumption that the sum of these effects result in a exponential extinction of
/// the signal as a function of depth. Only pixels within `mask`, if given, are taken into account to determine
/// this attenuation, but the whole image is corrected.
///
/// The attenuation is estimated based on the mean of the non-masked pixels as a function of depth. If
/// `percentile` is in the valid range [0, 100], the corresponding percentile is used instead of the mean.
/// An exponential function is fitted to these values. The starting point of the fit is determined by `fromWhere`,
/// which can be `"first plane"`, `"first max"`, or `"global max"`. In the case of `"first max"`, the first maximum
/// is found with `point[z+1] > hysteresis * point[z]`.
///
/// If the mean variant is chosen, one can choose to apply a variance weighting to the fit by setting `weighting`
/// to `"variance"`.
///
/// `in` must be a 3D, scalar and real-valued image. For images with fewer than 3 dimensions, the input is returned
/// unchanged.
///
/// !!! literature
/// - K.C. Strasters, H.T.M. van der Voort, J.M. Geusebroek, and A.W.M. Smeulders,
/// "Fast attenuation correction in fluorescence confocal imaging: a recursive approach", BioImaging 2(2):78-92, 1994.
DIP_EXPORT void ExponentialFitCorrection(
Image const& in,
Image const& mask,
Image& out,
dfloat percentile = -1.0,
String const& fromWhere = "first plane",
dfloat hysteresis = 1.0,
String const& weighting = "none"
);
inline Image ExponentialFitCorrection(
Image const& in,
Image const& mask,
dfloat percentile = -1.0,
String const& fromWhere = "first plane",
dfloat hysteresis = 1.0,
String const& weighting = "none"
) {
Image out;
ExponentialFitCorrection( in, mask, out, percentile, fromWhere, hysteresis, weighting );
return out;
}
/// \brief 3D fluorescence attenuation correction using one of three iterative algorithms
///
/// This function implements an attenuation correction using three different recursive attenuation correction
/// algorithms. The method is selected with the `method` parameter, which must be one of `"DET"`, `"LT2"` or `"LT1"`.
/// DET stands for Directional Extinction Tracking. LT2 is the Two Light Cone convolutions method, and LT1 is the
/// One Light Cone convolution.
///
/// The DET algorithm is the most accurate one, since it takes both forward and backward attenuation
/// into account (specified through the `fAttenuation` and `bAttenuation` parameters). It is however considerably
/// slower that the LT2 and LT1 algorithms, which take only forward attenuation into account (`fAttenuation`).
/// These last two algorithms assume a constant attenuation (`background`) for pixels with an intensity lower
/// than the `threshold`.
///
/// The system is characterized by parameters `NA` (numerical aperture) and `refIndex` (refractive index of the
/// medium), as well as the pixel size information in `in` (the x and y pixel size must be the same, the z size
/// must be have the same units, but can be different).
///
/// `in` must be a 3D, scalar and real-valued image. For images with fewer than 3 dimensions, the input is returned
/// unchanged.
///
/// !!! literature
/// - K.C. Strasters, H.T.M. van der Voort, J.M. Geusebroek, and A.W.M. Smeulders,
/// "Fast attenuation correction in fluorescence confocal imaging: a recursive approach", BioImaging 2(2):78-92, 1994.
DIP_EXPORT void AttenuationCorrection(
Image const& in,
Image& out,
dfloat fAttenuation = 0.01,
dfloat bAttenuation = 0.01,
dfloat background = 0.0,
dfloat threshold = 0.0,
dfloat NA = 1.4, // typical 63x oil immersion lens
dfloat refIndex = 1.518, // ideal immersion oil
String const& method = "DET"
);
inline Image AttenuationCorrection(
Image const& in,
dfloat fAttenuation = 0.01,
dfloat bAttenuation = 0.01,
dfloat background = 0.0,
dfloat threshold = 0.0,
dfloat NA = 1.4, // typical 63x oil immersion lens
dfloat refIndex = 1.518, // ideal immersion oil
String const& method = "DET"
) {
Image out;
AttenuationCorrection( in, out, fAttenuation, bAttenuation, background, threshold, NA, refIndex, method );
return out;
}
/// \brief 3D fluorescence attenuation simulation
///
/// Simulates an attenuation based on the model of a CSLM, using a ray tracing method.
///
/// !!! warning
/// This function is extremely slow, and its running time grows exponentially with the number of slices.
///
/// The system is characterized by parameters `NA` (numerical aperture) and `refIndex` (refractive index of the
/// medium), as well as the pixel size information in `in` (the x and y pixel size must be the same, the z size
/// must be have the same units, but can be different).
///
/// `fAttenuation` and `bAttenuation` are the forward and backward attenuation factors, respectively.
///
/// The ray tracing method uses a step size of `rayStep`, and a ray casting oversampling of `oversample`.
///
/// `in` must be a 3D, scalar and real-valued image. For images with fewer than 3 dimensions, the input is returned
/// unchanged.
///
/// !!! literature
/// - K.C. Strasters, H.T.M. van der Voort, J.M. Geusebroek, and A.W.M. Smeulders,
/// "Fast attenuation correction in fluorescence confocal imaging: a recursive approach", BioImaging 2(2):78-92, 1994.
DIP_EXPORT void SimulatedAttenuation(
Image const& in,
Image& out,
dfloat fAttenuation = 0.01,
dfloat bAttenuation = 0.01,
dfloat NA = 1.4, // typical 63x oil immersion lens
dfloat refIndex = 1.518, // ideal immersion oil
dip::uint oversample = 1,
dfloat rayStep = 1
);
inline Image SimulatedAttenuation(
Image const& in,
dfloat fAttenuation = 0.01,
dfloat bAttenuation = 0.01,
dfloat NA = 1.4, // typical 63x oil immersion lens
dfloat refIndex = 1.518, // ideal immersion oil
dip::uint oversample = 1,
dfloat rayStep = 1
) {
Image out;
SimulatedAttenuation( in, out, fAttenuation, bAttenuation, NA, refIndex, oversample, rayStep );
return out;
}
/// \endgroup
} // namespace dip
#endif // DIP_MICROSCOPY_H
| 46.813793 | 176 | 0.697437 | [
"vector",
"model",
"transform",
"3d"
] |
43d3a9f7c4f6df49141ac233bd959b7f71381132 | 76,931 | c | C | Reloaded/trunk/src/mame/video/konamigx.c | lofunz/mieme | 4226c2960b46121ec44fa8eab9717d2d644bff04 | [
"Unlicense"
] | 51 | 2015-11-22T14:53:28.000Z | 2021-12-14T07:17:42.000Z | Reloaded/trunk/src/mame/video/konamigx.c | lofunz/mieme | 4226c2960b46121ec44fa8eab9717d2d644bff04 | [
"Unlicense"
] | 8 | 2018-01-14T07:19:06.000Z | 2021-08-22T15:29:59.000Z | Reloaded/trunk/src/mame/video/konamigx.c | lofunz/mieme | 4226c2960b46121ec44fa8eab9717d2d644bff04 | [
"Unlicense"
] | 35 | 2017-02-15T09:39:00.000Z | 2021-12-14T07:17:43.000Z | /*
* video/konamigx.c - Konami GX video hardware (here there be dragons, and achocode)
*
*/
#include "emu.h"
#include "video/konamiic.h"
#include "includes/konamigx.h"
#define GX_DEBUG 0
#define VERBOSE 0
/***************************************************************************/
/* */
/* 2nd-Tier GX/MW Graphics Functions */
/* */
/***************************************************************************/
#if GX_DEBUG
#define GX_ZBUFW 512
#define GX_ZBUFH 384
#define GX_ZPAGESIZE 0x300000
#define GX_ZBUFSIZE 0x600000
#else
#define GX_ZBUFW 576
#define GX_ZBUFH 224
#define GX_ZPAGESIZE (GX_ZBUFW*GX_ZBUFH)
#define GX_ZBUFSIZE ((GX_ZBUFW*GX_ZBUFH)*2)
#endif
static UINT8 *gx_objzbuf, *gx_shdzbuf;
static int layer_colorbase[4];
static INT32 gx_tilebanks[8], gx_oldbanks[8];
static int gx_tilemode, gx_rozenable, psac_colorbase, last_psac_colorbase;
static int gx_specialrozenable; // type 1 roz, with voxel height-map, rendered from 2 source tilemaps (which include height data) to temp bitmap for further processing
static int gx_rushingheroes_hack;
static int gx_le2_textcolour_hack;
static tilemap_t *gx_psac_tilemap, *gx_psac_tilemap2;
extern UINT32 *gx_psacram, *gx_subpaletteram32;
static bitmap_t* type3_roz_temp_bitmap;
static tilemap_t* gx_psac_tilemap_alt;
static int konamigx_has_dual_screen;
int konamigx_current_frame;
INLINE void set_color_555(running_machine *machine, pen_t color, int rshift, int gshift, int bshift, UINT16 data);
static int konamigx_palformat;
static bitmap_t* dualscreen_left_tempbitmap;
static bitmap_t* dualscreen_right_tempbitmap;
/* On Type-1 the K053936 output is rendered to these temporary bitmaps as raw data
the 'voxel' effect to give the pixels height is a post-process operation on the
output of the K053936 (this can clearly be seen in videos as large chunks of
scenary flicker when in the distance due to single pixels in the K053936 output
becoming visible / invisible due to drawing precision.
-- however, progress on this has stalled as our K053936 doesn't seem to give
the right output for post processing, I suspect the game is using some
unsupported flipping modes (probably due to the way it's hooked up to the
rest of the chips) which is causing entirely the wrong output.
-- furthermore machine/konamigx.c (!) contains it's own implementation of
the K053936_zoom_draw named K053936GP_zoom_draw ... It really shouldn't do,
epsecially not in 'machine', which isn't meant to be video related.
*/
static bitmap_t *gxtype1_roz_dstbitmap;
static bitmap_t *gxtype1_roz_dstbitmap2;
static rectangle gxtype1_roz_dstbitmapclip;
static void (*game_tile_callback)(int layer, int *code, int *color, int *flags);
// Localized K053936/ROZ+
#define K053936_MAX_CHIPS 2
static rectangle K053936_cliprect[K053936_MAX_CHIPS] = {{0,0,0,0},{0,0,0,0}};
static int K053936_offset[K053936_MAX_CHIPS][2] = {{0,0},{0,0}};
static int K053936_clip_enabled[K053936_MAX_CHIPS] = {0,0};
void K053936GP_set_offset(int chip, int xoffs, int yoffs) { K053936_offset[chip][0] = xoffs; K053936_offset[chip][1] = yoffs; }
void K053936GP_clip_enable(int chip, int status) { K053936_clip_enabled[chip] = status; }
void K053936GP_set_cliprect(int chip, int minx, int maxx, int miny, int maxy)
{
rectangle *cliprect = &K053936_cliprect[chip];
cliprect->min_x = minx;
cliprect->max_x = maxx;
cliprect->min_y = miny;
cliprect->max_y = maxy;
}
INLINE void K053936GP_copyroz32clip( running_machine *machine,
bitmap_t *dst_bitmap, bitmap_t *src_bitmap,
const rectangle *dst_cliprect, const rectangle *src_cliprect,
UINT32 _startx,UINT32 _starty,int _incxx,int _incxy,int _incyx,int _incyy,
int tilebpp, int blend, int alpha, int clip, int pixeldouble_output )
{
static const int colormask[8]={1,3,7,0xf,0x1f,0x3f,0x7f,0xff};
int cy, cx;
int ecx;
int src_pitch, incxy, incxx;
int src_minx, src_maxx, src_miny, src_maxy, cmask;
UINT16 *src_base;
size_t src_size;
const pen_t *pal_base;
int dst_ptr;
int dst_size;
int dst_base2;
int tx, dst_pitch;
UINT32 *dst_base;
int starty, incyy, startx, incyx, ty, sx, sy;
incxy = _incxy; incxx = _incxx; incyy = _incyy; incyx = _incyx;
starty = _starty; startx = _startx;
if (src_cliprect && clip) // set source clip range to some extreme values when disabled
{
src_minx = src_cliprect->min_x;
src_maxx = src_cliprect->max_x;
src_miny = src_cliprect->min_y;
src_maxy = src_cliprect->max_y;
}
// this simply isn't safe to do!
else { src_minx = src_miny = -0x10000; src_maxx = src_maxy = 0x10000; }
if (dst_cliprect) // set target clip range
{
sx = dst_cliprect->min_x;
tx = dst_cliprect->max_x - sx + 1;
sy = dst_cliprect->min_y;
ty = dst_cliprect->max_y - sy + 1;
startx += sx * incxx + sy * incyx;
starty += sx * incxy + sy * incyy;
}
else { sx = sy = 0; tx = dst_bitmap->width; ty = dst_bitmap->height; }
// adjust entry points and other loop constants
dst_pitch = dst_bitmap->rowpixels;
dst_base = (UINT32*)dst_bitmap->base;
dst_base2 = sy * dst_pitch + sx + tx;
ecx = tx = -tx;
tilebpp = (tilebpp-1) & 7;
pal_base = machine->pens;
cmask = colormask[tilebpp];
src_pitch = src_bitmap->rowpixels;
src_base = (UINT16 *)src_bitmap->base;
src_size = src_bitmap->width * src_bitmap->height;
dst_size = dst_bitmap->width * dst_bitmap->height;
dst_ptr = 0;//dst_base;
cy = starty;
cx = startx;
if (blend > 0)
{
dst_base += dst_pitch; // draw blended
starty += incyy;
startx += incyx;
do {
do {
int srcx = (cx >> 16) & 0x1fff;
int srcy = (cy >> 16) & 0x1fff;
int pixel;
UINT32 offs;
offs = srcy * src_pitch + srcx;
cx += incxx;
cy += incxy;
if (offs<0 || offs>=src_size)
continue;
if (srcx < src_minx || srcx > src_maxx || srcy < src_miny || srcy > src_maxy)
continue;
pixel = src_base[offs];
if (!(pixel & cmask))
continue;
if ((dst_ptr+ecx+dst_base2)<dst_size) dst_base[dst_ptr+ecx+dst_base2] = alpha_blend_r32(pal_base[pixel], dst_base[dst_ptr+ecx+dst_base2], alpha);
if (pixeldouble_output)
{
ecx++;
if ((dst_ptr+ecx+dst_base2)<dst_size) dst_base[dst_ptr+ecx+dst_base2] = alpha_blend_r32(pal_base[pixel], dst_base[dst_ptr+ecx+dst_base2], alpha);
}
}
while (++ecx < 0);
ecx = tx;
dst_ptr += dst_pitch;
cy = starty; starty += incyy;
cx = startx; startx += incyx;
} while (--ty);
}
else // draw solid
{
if (blend == 0)
{
dst_ptr += dst_pitch;
starty += incyy;
startx += incyx;
}
else
{
if ((sy & 1) ^ (blend & 1))
{
if (ty <= 1) return;
dst_ptr += dst_pitch;
cy += incyy;
cx += incyx;
}
if (ty > 1)
{
ty >>= 1;
dst_pitch <<= 1;
incyy <<= 1;
incyx <<= 1;
dst_ptr += dst_pitch;
starty = cy + incyy;
startx = cx + incyx;
}
}
do {
do {
int srcx = (cx >> 16) & 0x1fff;
int srcy = (cy >> 16) & 0x1fff;
int pixel;
UINT32 offs;
offs = srcy * src_pitch + srcx;
cx += incxx;
cy += incxy;
if (offs<0 || offs>=src_size)
continue;
if (srcx < src_minx || srcx > src_maxx || srcy < src_miny || srcy > src_maxy)
continue;
pixel = src_base[offs];
if (!(pixel & cmask))
continue;
if ((dst_ptr+ecx+dst_base2)<dst_size) dst_base[dst_ptr+ecx+dst_base2] = pal_base[pixel];
if (pixeldouble_output)
{
ecx++;
if ((dst_ptr+ecx+dst_base2)<dst_size) dst_base[dst_ptr+ecx+dst_base2] = pal_base[pixel];
}
}
while (++ecx < 0);
ecx = tx;
dst_ptr += dst_pitch;
cy = starty; starty += incyy;
cx = startx; startx += incyx;
} while (--ty);
}
}
// adapted from generic K053936_zoom_draw()
static void K053936GP_zoom_draw(running_machine *machine,
int chip, UINT16 *ctrl, UINT16 *linectrl,
bitmap_t *bitmap, const rectangle *cliprect, tilemap_t *tmap,
int tilebpp, int blend, int alpha, int pixeldouble_output)
{
bitmap_t *src_bitmap;
rectangle *src_cliprect;
UINT16 *lineaddr;
rectangle my_clip;
UINT32 startx, starty;
int incxx, incxy, incyx, incyy, y, maxy, clip;
src_bitmap = tilemap_get_pixmap(tmap);
src_cliprect = &K053936_cliprect[chip];
clip = K053936_clip_enabled[chip];
if (ctrl[0x07] & 0x0040) /* "super" mode */
{
my_clip.min_x = cliprect->min_x;
my_clip.max_x = cliprect->max_x;
y = cliprect->min_y;
maxy = cliprect->max_y;
while (y <= maxy)
{
lineaddr = linectrl + ( ((y - K053936_offset[chip][1]) & 0x1ff) << 2);
my_clip.min_y = my_clip.max_y = y;
startx = (INT16)(lineaddr[0] + ctrl[0x00]) << 8;
starty = (INT16)(lineaddr[1] + ctrl[0x01]) << 8;
incxx = (INT16)(lineaddr[2]);
incxy = (INT16)(lineaddr[3]);
if (ctrl[0x06] & 0x8000) incxx <<= 8;
if (ctrl[0x06] & 0x0080) incxy <<= 8;
startx -= K053936_offset[chip][0] * incxx;
starty -= K053936_offset[chip][0] * incxy;
K053936GP_copyroz32clip(machine,
bitmap, src_bitmap, &my_clip, src_cliprect,
startx<<5, starty<<5, incxx<<5, incxy<<5, 0, 0,
tilebpp, blend, alpha, clip, pixeldouble_output);
y++;
}
}
else /* "simple" mode */
{
startx = (INT16)(ctrl[0x00]) << 8;
starty = (INT16)(ctrl[0x01]) << 8;
incyx = (INT16)(ctrl[0x02]);
incyy = (INT16)(ctrl[0x03]);
incxx = (INT16)(ctrl[0x04]);
incxy = (INT16)(ctrl[0x05]);
if (ctrl[0x06] & 0x4000) { incyx <<= 8; incyy <<= 8; }
if (ctrl[0x06] & 0x0040) { incxx <<= 8; incxy <<= 8; }
startx -= K053936_offset[chip][1] * incyx;
starty -= K053936_offset[chip][1] * incyy;
startx -= K053936_offset[chip][0] * incxx;
starty -= K053936_offset[chip][0] * incxy;
K053936GP_copyroz32clip(machine,
bitmap, src_bitmap, cliprect, src_cliprect,
startx<<5, starty<<5, incxx<<5, incxy<<5, incyx<<5, incyy<<5,
tilebpp, blend, alpha, clip, pixeldouble_output);
}
}
static void K053936GP_0_zoom_draw(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect,
tilemap_t *tmap, int tilebpp, int blend, int alpha, int pixeldouble_output)
{
K053936GP_zoom_draw(machine, 0,K053936_0_ctrl,K053936_0_linectrl,bitmap,cliprect,tmap,tilebpp,blend,alpha, pixeldouble_output);
}
static void K053936GP_1_zoom_draw(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect,
tilemap_t *tmap, int tilebpp, int blend, int alpha, int pixeldouble_output)
{
K053936GP_zoom_draw(machine, 1,K053936_1_ctrl,K053936_1_linectrl,bitmap,cliprect,tmap,tilebpp,blend,alpha, pixeldouble_output);
}
/*
Parameter Notes
---------------
clip : *caller must supply a pointer to target clip rectangle
alpha : 0 = invisible, 255 = solid
drawmode:
0 = all pens solid
1 = solid pens only
2 = all pens solid with alpha blending
3 = solid pens only with alpha blending
4 = shadow pens only
5 = all pens shadow
zcode : 0 = closest, 255 = furthest (pixel z-depth), -1 = disable depth buffers and shadows
pri : 0 = topmost, 255 = backmost (pixel priority)
*/
INLINE void zdrawgfxzoom32GP(
bitmap_t *bitmap, const rectangle *cliprect, const gfx_element *gfx,
UINT32 code, UINT32 color, int flipx, int flipy, int sx, int sy,
int scalex, int scaley, int alpha, int drawmode, int zcode, int pri)
{
#define FP 19
#define FPONE (1<<FP)
#define FPHALF (1<<(FP-1))
#define FPENT 0
// inner loop
const UINT8 *src_ptr;
int src_x;
int eax, ecx;
int src_fx, src_fdx;
int shdpen;
UINT8 z8, db0, p8, db1;
UINT8 *ozbuf_ptr;
UINT8 *szbuf_ptr;
const pen_t *pal_base;
const pen_t *shd_base;
UINT32 *dst_ptr;
// outter loop
int src_fby, src_fdy, src_fbx;
const UINT8 *src_base;
int dst_w, dst_h;
// one-time
int nozoom, granularity;
int src_fw, src_fh;
int dst_minx, dst_maxx, dst_miny, dst_maxy;
int dst_skipx, dst_skipy, dst_x, dst_y, dst_lastx, dst_lasty;
int src_pitch, dst_pitch;
// cull illegal and transparent objects
if (!scalex || !scaley) return;
// find shadow pens and cull invisible shadows
granularity = shdpen = gfx->color_granularity;
shdpen--;
if (zcode >= 0)
{
if (drawmode == 5) { drawmode = 4; shdpen = 1; }
}
else
if (drawmode >= 4) return;
// alpha blend necessary?
if (drawmode & 2)
{
if (alpha <= 0) return;
if (alpha >= 255) drawmode &= ~2;
}
// fill internal data structure with default values
ozbuf_ptr = gx_objzbuf;
szbuf_ptr = gx_shdzbuf;
src_pitch = 16;
src_fw = 16;
src_fh = 16;
src_base = gfx_element_get_data(gfx, code % gfx->total_elements);
pal_base = gfx->machine->pens + gfx->color_base + (color % gfx->total_colors) * granularity;
shd_base = gfx->machine->shadow_table;
dst_ptr = (UINT32 *)bitmap->base;
dst_pitch = bitmap->rowpixels;
dst_minx = cliprect->min_x;
dst_maxx = cliprect->max_x;
dst_miny = cliprect->min_y;
dst_maxy = cliprect->max_y;
dst_x = sx;
dst_y = sy;
// cull off-screen objects
if (dst_x > dst_maxx || dst_y > dst_maxy) return;
nozoom = (scalex == 0x10000 && scaley == 0x10000);
if (nozoom)
{
dst_h = dst_w = 16;
src_fdy = src_fdx = 1;
}
else
{
dst_w = ((scalex<<4)+0x8000)>>16;
dst_h = ((scaley<<4)+0x8000)>>16;
if (!dst_w || !dst_h) return;
src_fw <<= FP;
src_fh <<= FP;
src_fdx = src_fw / dst_w;
src_fdy = src_fh / dst_h;
}
dst_lastx = dst_x + dst_w - 1;
if (dst_lastx < dst_minx) return;
dst_lasty = dst_y + dst_h - 1;
if (dst_lasty < dst_miny) return;
// clip destination
dst_skipx = 0;
eax = dst_minx; if ((eax -= dst_x) > 0) { dst_skipx = eax; dst_w -= eax; dst_x = dst_minx; }
eax = dst_lastx; if ((eax -= dst_maxx) > 0) dst_w -= eax;
dst_skipy = 0;
eax = dst_miny; if ((eax -= dst_y) > 0) { dst_skipy = eax; dst_h -= eax; dst_y = dst_miny; }
eax = dst_lasty; if ((eax -= dst_maxy) > 0) dst_h -= eax;
// calculate zoom factors and clip source
if (nozoom)
{
if (!flipx) src_fbx = 0; else { src_fbx = src_fw - 1; src_fdx = -src_fdx; }
if (!flipy) src_fby = 0; else { src_fby = src_fh - 1; src_fdy = -src_fdy; src_pitch = -src_pitch; }
}
else
{
if (!flipx) src_fbx = FPENT; else { src_fbx = src_fw - FPENT - 1; src_fdx = -src_fdx; }
if (!flipy) src_fby = FPENT; else { src_fby = src_fh - FPENT - 1; src_fdy = -src_fdy; }
}
src_fbx += dst_skipx * src_fdx;
src_fby += dst_skipy * src_fdy;
// adjust insertion points and pre-entry constants
eax = (dst_y - dst_miny) * GX_ZBUFW + (dst_x - dst_minx) + dst_w;
db0 = z8 = (UINT8)zcode;
db1 = p8 = (UINT8)pri;
ozbuf_ptr += eax;
szbuf_ptr += eax << 1;
dst_ptr += dst_y * dst_pitch + dst_x + dst_w;
dst_w = -dst_w;
if (!nozoom)
{
ecx = src_fby; src_fby += src_fdy;
ecx >>= FP; src_fx = src_fbx;
src_x = src_fbx; src_fx += src_fdx;
ecx <<= 4; src_ptr = src_base;
src_x >>= FP; src_ptr += ecx;
ecx = dst_w;
if (zcode < 0) // no shadow and z-buffering
{
do {
do {
eax = src_ptr[src_x];
src_x = src_fx;
src_fx += src_fdx;
src_x >>= FP;
if (!eax || eax >= shdpen) continue;
dst_ptr [ecx] = pal_base[eax];
}
while (++ecx);
ecx = src_fby; src_fby += src_fdy;
dst_ptr += dst_pitch;
ecx >>= FP; src_fx = src_fbx;
src_x = src_fbx; src_fx += src_fdx;
ecx <<= 4; src_ptr = src_base;
src_x >>= FP; src_ptr += ecx;
ecx = dst_w;
}
while (--dst_h);
}
else
{
switch (drawmode)
{
case 0: // all pens solid
do {
do {
eax = src_ptr[src_x];
src_x = src_fx;
src_fx += src_fdx;
src_x >>= FP;
if (!eax || ozbuf_ptr[ecx] < z8) continue;
eax = pal_base[eax];
ozbuf_ptr[ecx] = z8;
dst_ptr [ecx] = eax;
}
while (++ecx);
ecx = src_fby; src_fby += src_fdy;
ozbuf_ptr += GX_ZBUFW;
dst_ptr += dst_pitch;
ecx >>= FP; src_fx = src_fbx;
src_x = src_fbx; src_fx += src_fdx;
ecx <<= 4; src_ptr = src_base;
src_x >>= FP; src_ptr += ecx;
ecx = dst_w;
}
while (--dst_h);
break;
case 1: // solid pens only
do {
do {
eax = src_ptr[src_x];
src_x = src_fx;
src_fx += src_fdx;
src_x >>= FP;
if (!eax || eax >= shdpen || ozbuf_ptr[ecx] < z8) continue;
eax = pal_base[eax];
ozbuf_ptr[ecx] = z8;
dst_ptr [ecx] = eax;
}
while (++ecx);
ecx = src_fby; src_fby += src_fdy;
ozbuf_ptr += GX_ZBUFW;
dst_ptr += dst_pitch;
ecx >>= FP; src_fx = src_fbx;
src_x = src_fbx; src_fx += src_fdx;
ecx <<= 4; src_ptr = src_base;
src_x >>= FP; src_ptr += ecx;
ecx = dst_w;
}
while (--dst_h);
break;
case 2: // all pens solid with alpha blending
do {
do {
eax = src_ptr[src_x];
src_x = src_fx;
src_fx += src_fdx;
src_x >>= FP;
if (!eax || ozbuf_ptr[ecx] < z8) continue;
ozbuf_ptr[ecx] = z8;
dst_ptr[ecx] = alpha_blend_r32(pal_base[eax], dst_ptr[ecx], alpha);
}
while (++ecx);
ecx = src_fby; src_fby += src_fdy;
ozbuf_ptr += GX_ZBUFW;
dst_ptr += dst_pitch;
ecx >>= FP; src_fx = src_fbx;
src_x = src_fbx; src_fx += src_fdx;
ecx <<= 4; src_ptr = src_base;
src_x >>= FP; src_ptr += ecx;
ecx = dst_w;
}
while (--dst_h);
break;
case 3: // solid pens only with alpha blending
do {
do {
eax = src_ptr[src_x];
src_x = src_fx;
src_fx += src_fdx;
src_x >>= FP;
if (!eax || eax >= shdpen || ozbuf_ptr[ecx] < z8) continue;
ozbuf_ptr[ecx] = z8;
dst_ptr[ecx] = alpha_blend_r32(pal_base[eax], dst_ptr[ecx], alpha);
}
while (++ecx);
ecx = src_fby; src_fby += src_fdy;
ozbuf_ptr += GX_ZBUFW;
dst_ptr += dst_pitch;
ecx >>= FP; src_fx = src_fbx;
src_x = src_fbx; src_fx += src_fdx;
ecx <<= 4; src_ptr = src_base;
src_x >>= FP; src_ptr += ecx;
ecx = dst_w;
}
while (--dst_h);
break;
case 4: // shadow pens only
do {
do {
eax = src_ptr[src_x];
src_x = src_fx;
src_fx += src_fdx;
src_x >>= FP;
if (eax < shdpen || szbuf_ptr[ecx*2] < z8 || szbuf_ptr[ecx*2+1] <= p8) continue;
eax = dst_ptr[ecx];
szbuf_ptr[ecx*2] = z8;
szbuf_ptr[ecx*2+1] = p8;
// the shadow tables are 15-bit lookup tables which accept RGB15... lossy, nasty, yuck!
dst_ptr[ecx] = shd_base[rgb_to_rgb15(eax)];
//dst_ptr[ecx] =(eax>>3&0x001f);lend_r32( eax, 0x00000000, 128);
}
while (++ecx);
ecx = src_fby; src_fby += src_fdy;
szbuf_ptr += (GX_ZBUFW<<1);
dst_ptr += dst_pitch;
ecx >>= FP; src_fx = src_fbx;
src_x = src_fbx; src_fx += src_fdx;
ecx <<= 4; src_ptr = src_base;
src_x >>= FP; src_ptr += ecx;
ecx = dst_w;
}
while (--dst_h);
break;
} // switch (drawmode)
} // if (zcode < 0)
} // if (!nozoom)
else
{
src_ptr = src_base + (src_fby<<4) + src_fbx;
src_fdy = src_fdx * dst_w + src_pitch;
ecx = dst_w;
if (zcode < 0) // no shadow and z-buffering
{
do {
do {
eax = *src_ptr;
src_ptr += src_fdx;
if (!eax || eax >= shdpen) continue;
dst_ptr[ecx] = pal_base[eax];
}
while (++ecx);
src_ptr += src_fdy;
dst_ptr += dst_pitch;
ecx = dst_w;
}
while (--dst_h);
}
else
{
switch (drawmode)
{
case 0: // all pens solid
do {
do {
eax = *src_ptr;
src_ptr += src_fdx;
if (!eax || ozbuf_ptr[ecx] < z8) continue;
eax = pal_base[eax];
ozbuf_ptr[ecx] = z8;
dst_ptr[ecx] = eax;
}
while (++ecx);
src_ptr += src_fdy;
ozbuf_ptr += GX_ZBUFW;
dst_ptr += dst_pitch;
ecx = dst_w;
}
while (--dst_h);
break;
case 1: // solid pens only
do {
do {
eax = *src_ptr;
src_ptr += src_fdx;
if (!eax || eax >= shdpen || ozbuf_ptr[ecx] < z8) continue;
eax = pal_base[eax];
ozbuf_ptr[ecx] = z8;
dst_ptr[ecx] = eax;
}
while (++ecx);
src_ptr += src_fdy;
ozbuf_ptr += GX_ZBUFW;
dst_ptr += dst_pitch;
ecx = dst_w;
}
while (--dst_h);
break;
case 2: // all pens solid with alpha blending
do {
do {
eax = *src_ptr;
src_ptr += src_fdx;
if (!eax || ozbuf_ptr[ecx] < z8) continue;
ozbuf_ptr[ecx] = z8;
dst_ptr[ecx] = alpha_blend_r32(pal_base[eax], dst_ptr[ecx], alpha);
}
while (++ecx);
src_ptr += src_fdy;
ozbuf_ptr += GX_ZBUFW;
dst_ptr += dst_pitch;
ecx = dst_w;
}
while (--dst_h);
break;
case 3: // solid pens only with alpha blending
do {
do {
eax = *src_ptr;
src_ptr += src_fdx;
if (!eax || eax >= shdpen || ozbuf_ptr[ecx] < z8) continue;
ozbuf_ptr[ecx] = z8;
dst_ptr[ecx] = alpha_blend_r32(pal_base[eax], dst_ptr[ecx], alpha);
}
while (++ecx);
src_ptr += src_fdy;
ozbuf_ptr += GX_ZBUFW;
dst_ptr += dst_pitch;
ecx = dst_w;
}
while (--dst_h);
break;
case 4: // shadow pens only
do {
do {
eax = *src_ptr;
src_ptr += src_fdx;
if (eax < shdpen || szbuf_ptr[ecx*2] < z8 || szbuf_ptr[ecx*2+1] <= p8) continue;
eax = dst_ptr[ecx];
szbuf_ptr[ecx*2] = z8;
szbuf_ptr[ecx*2+1] = p8;
// the shadow tables are 15-bit lookup tables which accept RGB15... lossy, nasty, yuck!
dst_ptr[ecx] = shd_base[rgb_to_rgb15(eax)];
}
while (++ecx);
src_ptr += src_fdy;
szbuf_ptr += (GX_ZBUFW<<1);
dst_ptr += dst_pitch;
ecx = dst_w;
}
while (--dst_h);
break;
}
}
}
#undef FP
#undef FPONE
#undef FPHALF
#undef FPENT
}
/***************************************************************************/
/* */
/* 1st-Tier GX/MW Variables and Functions */
/* */
/***************************************************************************/
// global system ports access
UINT8 konamigx_wrport1_0, konamigx_wrport1_1;
UINT16 konamigx_wrport2;
// frequently used registers
static int K053246_objset1;
static int K053247_vrcbk[4];
static int K053247_coreg, K053247_coregshift, K053247_opset;
static int opri, oinprion;
static int vcblk[6], ocblk;
static int vinmix, vmixon, osinmix, osmixon;
static void konamigx_precache_registers(void)
{
// (see sprite color coding scheme on p.46 & 47)
static const int coregmasks[5] = {0xf,0xe,0xc,0x8,0x0};
static const int coregshifts[5]= {4,5,6,7,8};
int i;
K053246_objset1 = K053246_read_register(5);
i = K053247_read_register(0x8/2);
K053247_vrcbk[0] = (i & 0x000f) << 14;
K053247_vrcbk[1] = (i & 0x0f00) << 6;
i = K053247_read_register(0xa/2);
K053247_vrcbk[2] = (i & 0x000f) << 14;
K053247_vrcbk[3] = (i & 0x0f00) << 6;
// COREG == OBJSET2+1C == bit8-11 of OPSET ??? (see p.50 last table, needs p.49 to confirm)
K053247_opset = K053247_read_register(0xc/2);
i = K053247_opset & 7; if (i > 4) i = 4;
K053247_coreg = K053247_read_register(0xc/2)>>8 & 0xf;
K053247_coreg =(K053247_coreg & coregmasks[i]) << 12;
K053247_coregshift = coregshifts[i];
opri = K055555_read_register(K55_PRIINP_8);
oinprion = K055555_read_register(K55_OINPRI_ON);
vcblk[0] = K055555_read_register(K55_PALBASE_A);
vcblk[1] = K055555_read_register(K55_PALBASE_B);
vcblk[2] = K055555_read_register(K55_PALBASE_C);
vcblk[3] = K055555_read_register(K55_PALBASE_D);
vcblk[4] = K055555_read_register(K55_PALBASE_SUB1);
vcblk[5] = K055555_read_register(K55_PALBASE_SUB2);
ocblk = K055555_read_register(K55_PALBASE_OBJ);
vinmix = K055555_read_register(K55_BLEND_ENABLES);
vmixon = K055555_read_register(K55_VINMIX_ON);
osinmix = K055555_read_register(K55_OSBLEND_ENABLES);
osmixon = K055555_read_register(K55_OSBLEND_ON);
}
INLINE int K053247GX_combine_c18(int attrib) // (see p.46)
{
int c18;
c18 = (attrib & 0xff)<<K053247_coregshift | K053247_coreg;
if (konamigx_wrport2 & 4) c18 &= 0x3fff; else
if (!(konamigx_wrport2 & 8)) c18 = (c18 & 0x3fff) | (attrib<<6 & 0xc000);
return(c18);
}
INLINE int K055555GX_decode_objcolor(int c18) // (see p.59 7.2.2)
{
int ocb, opon;
opon = oinprion<<8 | 0xff;
ocb = (ocblk & 7) << 10;
c18 &= opon;
ocb &=~opon;
return((ocb | c18) >> K053247_coregshift);
}
INLINE int K055555GX_decode_inpri(int c18) // (see p.59 7.2.2)
{
int op = opri;
c18 >>= 8;
op &= oinprion;
c18 &=~oinprion;
return(c18 | op);
}
static void konamigx_type2_sprite_callback(int *code, int *color, int *priority)
{
int num = *code;
int c18 = *color;
*code = K053247_vrcbk[num>>14] | (num & 0x3fff);
c18 = K053247GX_combine_c18(c18);
*color = K055555GX_decode_objcolor(c18);
*priority = K055555GX_decode_inpri(c18);
}
static void konamigx_dragoonj_sprite_callback(int *code, int *color, int *priority)
{
int num, op, pri, c18;
num = *code;
*code = K053247_vrcbk[num>>14] | (num & 0x3fff);
c18 = pri = *color;
op = opri;
pri = (pri & 0x200) ? 4 : pri>>4 & 0xf;
op &= oinprion;
pri &=~oinprion;
*priority = pri | op;
c18 = K053247GX_combine_c18(c18);
*color = K055555GX_decode_objcolor(c18);
}
static void konamigx_salmndr2_sprite_callback(int *code, int *color, int *priority)
{
int num, op, pri, c18;
num = *code;
*code = K053247_vrcbk[num>>14] | (num & 0x3fff);
c18 = pri = *color;
op = opri;
pri = pri>>4 & 0x3f;
op &= oinprion;
pri &=~oinprion;
*priority = pri | op;
c18 = K053247GX_combine_c18(c18);
*color = K055555GX_decode_objcolor(c18);
}
static void konamigx_le2_sprite_callback(int *code, int *color, int *priority)
{
int num, op, pri;
num = *code;
*code = K053247_vrcbk[num>>14] | (num & 0x3fff);
pri = *color;
*color &= 0x1f;
op = opri;
pri &= 0xf0;
op &= oinprion;
pri &=~oinprion;
*priority = pri | op;
}
static int K055555GX_decode_vmixcolor(int layer, int *color) // (see p.62 7.2.6 and p.27 3.3)
{
int vcb, shift, pal, vmx, von, pl45, emx;
vcb = vcblk[layer]<<6;
shift = layer<<1;
pal = *color;
vmx = vinmix>>shift & 3;
von = vmixon>>shift & 3;
emx = pl45 = pal>>4 & 3;
pal &= 0xf;
pl45 &= von;
vmx &= von;
pl45 <<= 4;
emx &= ~von;
pal |= pl45;
emx |= vmx;
pal |= vcb;
if (gx_le2_textcolour_hack)
if (layer==0)
pal |= 0x1c0;
if (von == 3) emx = -1; // invalidate external mix code if all bits are from internal
*color = pal;
return(emx);
}
#ifdef UNUSED_FUNCTION
int K055555GX_decode_osmixcolor(int layer, int *color) // (see p.63, p.49-50 and p.27 3.3)
{
int scb, shift, pal, osmx, oson, pl45, emx;
shift = layer<<1;
pal = *color;
osmx = osinmix>>shift & 3;
oson = osmixon>>shift & 3;
if (layer)
{
// layer 1-3 are external tile layers
scb = vcblk[layer+3]<<6;
emx = pl45 = pal>>4 & 3;
pal &= 0xf;
pl45 &= oson;
osmx &= oson;
pl45 <<= 4;
emx &= ~oson;
pal |= pl45;
emx |= osmx;
pal |= scb;
if (oson == 3) emx = -1; // invalidate external mix code if all bits are from internal
*color = pal;
}
else
{
// layer 0 is the sprite layer with different attributes decode; detail on p.49 (missing)
emx = 0; // K053247_read_register(??)>>? & 3;
osmx &= oson;
emx &=~oson;
emx |= osmx;
}
return(emx);
}
#endif
static void gx_wipezbuf(running_machine *machine, int noshadow)
{
const rectangle &visarea = machine->primary_screen->visible_area();
int w = visarea.max_x - visarea.min_x + 1;
int h = visarea.max_y - visarea.min_y + 1;
UINT8 *zptr = gx_objzbuf;
int ecx = h;
do { memset(zptr, -1, w); zptr += GX_ZBUFW; } while (--ecx);
if (!noshadow)
{
zptr = gx_shdzbuf;
w <<= 1;
ecx = h;
do { memset(zptr, -1, w); zptr += (GX_ZBUFW<<1); } while (--ecx);
}
}
/*
* Sprite Format
* ------------------
*
* Word | Bit(s) | Use
* -----+-fedcba9876543210-+----------------
* 0 | x--------------- | active (show this sprite)
* 0 | -x-------------- | maintain aspect ratio (when set, zoom y acts on both axis)
* 0 | --x------------- | flip y
* 0 | ---x------------ | flip x
* 0 | ----xxxx-------- | sprite size (see below)
* 0 | --------xxxxxxxx | zcode
* 1 | xxxxxxxxxxxxxxxx | sprite code
* 2 | ------xxxxxxxxxx | y position
* 3 | ------xxxxxxxxxx | x position
* 4 | xxxxxxxxxxxxxxxx | zoom y (0x40 = normal, <0x40 = enlarge, >0x40 = reduce)
* 5 | xxxxxxxxxxxxxxxx | zoom x (0x40 = normal, <0x40 = enlarge, >0x40 = reduce)
* 6 | x--------------- | mirror y (top half is drawn as mirror image of the bottom)
* 6 | -x-------------- | mirror x (right half is drawn as mirror image of the left)
* 6 | --xx------------ | reserved (sprites with these two bits set don't seem to be graphics data at all)
* 6 | ----xx---------- | shadow code: 0=off, 0x400=preset1, 0x800=preset2, 0xc00=preset3
* 6 | ------xx-------- | effect code: flicker, upper palette, full shadow...etc. (game dependent)
* 6 | --------xxxxxxxx | "color", but depends on external connections (implies priority)
* 7 | xxxxxxxxxxxxxxxx | game dependent
*
* shadow enables transparent shadows. Note that it applies to the last sprite pen ONLY.
* The rest of the sprite remains normal.
*/
#define GX_MAX_SPRITES 512
#define GX_MAX_LAYERS 6
#define GX_MAX_OBJECTS (GX_MAX_SPRITES + GX_MAX_LAYERS)
static struct GX_OBJ { int order, offs, code, color; } *gx_objpool;
static UINT16 *gx_spriteram;
static int gx_objdma, gx_primode;
// mirrored K053247 and K054338 settings
UINT16 *K053247_ram;
static gfx_element *K053247_gfx;
static void (*K053247_callback)(int *code,int *color,int *priority);
static int K053247_dx, K053247_dy;
static int *K054338_shdRGB;
static void K053247GP_set_SpriteOffset(int offsx, int offsy)
{
K053247_dx = offsx;
K053247_dy = offsy;
}
void konamigx_mixer_init(running_machine *machine, int objdma)
{
gx_objdma = 0;
gx_primode = 0;
gx_objzbuf = (UINT8 *)machine->priority_bitmap->base;
gx_shdzbuf = auto_alloc_array(machine, UINT8, GX_ZBUFSIZE);
gx_objpool = auto_alloc_array(machine, struct GX_OBJ, GX_MAX_OBJECTS);
K053247_export_config(&K053247_ram, &K053247_gfx, &K053247_callback, &K053247_dx, &K053247_dy);
K054338_export_config(&K054338_shdRGB);
if (objdma)
{
gx_spriteram = auto_alloc_array(machine, UINT16, 0x1000/2);
gx_objdma = 1;
}
else
gx_spriteram = K053247_ram;
palette_set_shadow_dRGB32(machine, 3,-80,-80,-80, 0);
K054338_invert_alpha(1);
}
void konamigx_mixer_primode(int mode)
{
gx_primode = mode;
}
void konamigx_objdma(void)
{
if (gx_objdma && gx_spriteram && K053247_ram) memcpy(gx_spriteram, K053247_ram, 0x1000);
}
void konamigx_mixer(running_machine *machine, bitmap_t *bitmap, const rectangle *cliprect,
tilemap_t *sub1, int sub1flags,
tilemap_t *sub2, int sub2flags,
int mixerflags, bitmap_t *extra_bitmap, int rushingheroes_hack)
{
static const int xoffset[8] = { 0, 1, 4, 5, 16, 17, 20, 21 };
static const int yoffset[8] = { 0, 2, 8, 10, 32, 34, 40, 42 };
static int parity = 0;
int objbuf[GX_MAX_OBJECTS];
int shadowon[3], shdpri[3], layerid[6], layerpri[6];
struct GX_OBJ *objpool, *objptr;
int wrapsize, xwraplim, ywraplim, cltc_shdpri, /*prflp,*/ disp;
int xa,ya,ox,oy,zw,zh,flipx,flipy,mirrorx,mirrory,zoomx,zoomy,scalex,scaley,nozoom;
int screenwidth, flipscreenx, flipscreeny, offx, offy;
int nobj, i, j, k, l, temp, temp1, temp2, temp3, temp4, count;
int order, offs, code, color, zcode, pri = 0, spri, spri_min, shdprisel, shadow, alpha, drawmode;
// abort if object database failed to initialize
objpool = gx_objpool;
if (!objpool) return;
// clear screen with backcolor and update flicker pulse
K054338_fill_backcolor(machine, bitmap, konamigx_wrport1_0 & 0x20);
parity ^= 1;
// abort if video has been disabled
disp = K055555_read_register(K55_INPUT_ENABLES);
if (!disp) return;
cltc_shdpri = K054338_read_register(K338_REG_CONTROL);
if (!rushingheroes_hack) // Slam Dunk 2 never sets this. It's either part of the protection, or type4 doesn't use it
{
if (!(cltc_shdpri & K338_CTL_KILL)) return;
}
// demote shadows by one layer when this bit is set??? (see p.73 8.6)
cltc_shdpri &= K338_CTL_SHDPRI;
// wipe z-buffer
if (mixerflags & GXMIX_NOZBUF)
mixerflags |= GXMIX_NOSHADOW;
else
gx_wipezbuf(machine, mixerflags & GXMIX_NOSHADOW);
// cache global parameters
konamigx_precache_registers();
// init OBJSET1 parameters (see p.47 6.2)
flipscreenx = K053246_objset1 & 1;
flipscreeny = K053246_objset1 & 2;
// get "display window" offsets
offx = (K053246_read_register(0)<<8 | K053246_read_register(1)) & 0x3ff;
offy = (K053246_read_register(2)<<8 | K053246_read_register(3)) & 0x3ff;
// init OBJSET2 and mixer parameters (see p.51 and chapter 7)
layerid[0] = 0; layerid[1] = 1; layerid[2] = 2; layerid[3] = 3; layerid[4] = 4; layerid[5] = 5;
if (K053247_opset & 0x40)
{
wrapsize = 512;
xwraplim = 512 - 64;
ywraplim = 512 - 128;
}
else
{
wrapsize = 1024;
xwraplim = 1024 - 384;
ywraplim = 1024 - 512;
}
// invert layer priority when this flag is set (not used by any GX game?)
//prflp = K055555_read_register(K55_CONTROL) & K55_CTL_FLIPPRI;
layerpri[0] = K055555_read_register(K55_PRIINP_0);
layerpri[1] = K055555_read_register(K55_PRIINP_3);
layerpri[3] = K055555_read_register(K55_PRIINP_7);
layerpri[4] = K055555_read_register(K55_PRIINP_9);
layerpri[5] = K055555_read_register(K55_PRIINP_10);
if (gx_primode == -1)
{
// Lethal Enforcer hack (requires pixel color comparison)
layerpri[2] = K055555_read_register(K55_PRIINP_3) + 0x20;
shdprisel = 0x3f;
}
else
{
layerpri[2] = K055555_read_register(K55_PRIINP_6);
shdprisel = K055555_read_register(K55_SHD_PRI_SEL);
}
// SHDPRISEL filters shadows by different priority comparison methods (UNIMPLEMENTED, see detail on p.66)
if (!(shdprisel & 0x03)) shadowon[0] = 0;
if (!(shdprisel & 0x0c)) shadowon[1] = 0;
if (!(shdprisel & 0x30)) shadowon[2] = 0;
shdpri[0] = K055555_read_register(K55_SHAD1_PRI);
shdpri[1] = K055555_read_register(K55_SHAD2_PRI);
shdpri[2] = K055555_read_register(K55_SHAD3_PRI);
spri_min = 0;
shadowon[2] = shadowon[1] = shadowon[0] = 0;
if (!(mixerflags & GXMIX_NOSHADOW))
{
// only enable shadows beyond a +/-7 RGB threshold
for (j=0,i=0; i<3; j+=3,i++)
{
k = K054338_shdRGB[j ]; if (k < -7 || k > 7) { shadowon[i] = 1; continue; }
k = K054338_shdRGB[j+1]; if (k < -7 || k > 7) { shadowon[i] = 1; continue; }
k = K054338_shdRGB[j+2]; if (k < -7 || k > 7) { shadowon[i] = 1; }
}
// SHDON specifies layers on which shadows can be projected (see detail on p.65 7.2.8)
temp = K055555_read_register(K55_SHD_ON);
for (i=0; i<4; i++) if (!(temp>>i & 1) && spri_min < layerpri[i]) spri_min = layerpri[i]; // HACK
// update shadows status
K054338_update_all_shadows(machine, rushingheroes_hack);
}
// pre-sort layers
for (j=0; j<5; j++)
{
temp1 = layerpri[j];
for (i=j+1; i<6; i++)
{
temp2 = layerpri[i];
if ((UINT32)temp1 <= (UINT32)temp2)
{
layerpri[i] = temp1; layerpri[j] = temp1 = temp2;
temp2 = layerid[i]; layerid[i] = layerid[j]; layerid[j] = temp2;
}
}
}
// build object database and create indices
objptr = objpool;
nobj = 0;
for (i=5; i>=0; i--)
{
code = layerid[i];
switch (code)
{
/*
Background layers are represented by negative offset values as follow:
0+ : normal sprites
-1 : tile layer A - D
-2 : K053936 ROZ+ layer 1
-3 : K053936 ROZ+ layer 2
-4 : K053250 LVC layer 1
-5 : K053250 LVC layer 2
*/
case 4 :
offs = -128;
if (sub1flags & 0xf) { if (sub1flags & GXSUB_K053250) offs = -4; else if (sub1) offs = -2; }
break;
case 5 :
offs = -128;
if (sub2flags & 0xf) { if (sub2flags & GXSUB_K053250) offs = -5; else if (sub2) offs = -3; }
if (extra_bitmap) offs = -3;
break;
default: offs = -1;
}
if (offs != -128)
{
objptr->order = layerpri[i]<<24;
objptr->code = code;
objptr->offs = offs;
objptr++;
objbuf[nobj] = nobj;
nobj++;
}
}
i = j = 0xff;
for (offs=0; offs<0x800; offs+=8)
{
if (!(gx_spriteram[offs] & 0x8000)) continue;
zcode = gx_spriteram[offs] & 0xff;
// invert z-order when opset_pri is set (see p.51 OPSET PRI)
if (K053247_opset & 0x10) zcode = 0xff - zcode;
code = gx_spriteram[offs+1];
color = k = gx_spriteram[offs+6];
l = gx_spriteram[offs+7];
(*K053247_callback)(&code, &color, &pri);
/*
shadow = shadow code
spri = shadow priority
temp1 = add solid object
temp2 = solid pens draw mode
temp3 = add shadow object
temp4 = shadow pens draw mode
*/
temp4 = temp3 = temp2 = temp1 = spri = shadow = 0;
if (color & K055555_FULLSHADOW)
{
shadow = 3; // use default intensity and color
spri = pri; // retain host priority
temp3 = 1; // add shadow
temp4 = 5; // draw full shadow
}
else
{
shadow = k>>10 & 3;
if (shadow) // object has shadow?
{
if (shadow != 1 || K053246_objset1 & 0x20)
{
shadow--;
temp1 = 1; // add solid
temp2 = 1; // draw partial solid
if (shadowon[shadow])
{
temp3 = 1; // add shadow
temp4 = 4; // draw partial shadow
}
}
else
{
// drop the entire sprite to shadow if its shadow code is 1 and SD0EN is off (see p.48)
shadow = 0;
if (!shadowon[0]) continue;
temp3 = 1; // add shadow
temp4 = 5; // draw full shadow
}
}
else
{
temp1 = 1; // add solid
temp2 = 0; // draw full solid
}
if (temp1)
{
// tag sprite for alpha blending
if (color>>K055555_MIXSHIFT & 3) temp2 |= 2;
}
if (temp3)
{
// determine shadow priority
spri = (K053247_opset & 0x20) ? pri : shdpri[shadow]; // (see p.51 OPSET SDSEL)
}
}
switch (gx_primode & 0xf)
{
// Dadandarn zcode suppression
case 1:
zcode = 0;
break;
// Daisukiss bad shadow filter
case 4:
if (k & 0x3000 || k == 0x0800) continue;
// Tokkae shadow masking (INACCURATE)
case 5:
if (spri < spri_min) spri = spri_min;
break;
}
/*
default sort order:
fedcba9876543210fedcba9876543210
xxxxxxxx------------------------ (priority)
--------xxxxxxxx---------------- (zcode)
----------------xxxxxxxx-------- (offset)
------------------------xxxx---- (shadow mode)
----------------------------xxxx (shadow code)
*/
if (temp1)
{
// add objects with solid or alpha pens
order = pri<<24 | zcode<<16 | offs<<(8-3) | temp2<<4;
objptr->order = order;
objptr->offs = offs;
objptr->code = code;
objptr->color = color;
objptr++;
objbuf[nobj] = nobj;
nobj++;
}
if (temp3 && !(color & K055555_SKIPSHADOW) && !(mixerflags & GXMIX_NOSHADOW))
{
// add objects with shadows if enabled
order = spri<<24 | zcode<<16 | offs<<(8-3) | temp4<<4 | shadow;
objptr->order = order;
objptr->offs = offs;
objptr->code = code;
objptr->color = color;
objptr++;
objbuf[nobj] = nobj;
nobj++;
}
}
// sort objects in decending order (SLOW)
k = nobj;
l = nobj - 1;
for (j=0; j<l; j++)
{
temp1 = objbuf[j];
temp2 = objpool[temp1].order;
for (i=j+1; i<k; i++)
{
temp3 = objbuf[i];
temp4 = objpool[temp3].order;
if ((UINT32)temp2 <= (UINT32)temp4) { temp2 = temp4; objbuf[i] = temp1; objbuf[j] = temp1 = temp3; }
}
}
// traverse draw list
screenwidth = machine->primary_screen->width();
for (count=0; count<nobj; count++)
{
objptr = objpool + objbuf[count];
order = objptr->order;
offs = objptr->offs;
code = objptr->code;
color = objptr->color;
if (offs >= 0)
{
if (!(disp & K55_INP_OBJ)) continue;
}
else
{
i = code<<1;
j = mixerflags>>i & 3;
k = 0;
switch (offs)
{
case -1:
if (disp & (1<<code))
{
if (j == GXMIX_BLEND_NONE) { temp1 = 0xff; temp2 = temp3 = 0; } else
if (j == GXMIX_BLEND_FORCE) { temp1 = 0x00; temp2 = mixerflags>>(i+16); temp3 = 3; }
else
{
temp1 = vinmix;
temp2 = vinmix>>i & 3;
temp3 = vmixon>>i & 3;
}
/* blend layer only when:
1) vinmix != 0xff
2) its internal mix code is set
3) all mix code bits are internal(overriden until tile blending has been implemented)
4) 0 > alpha < 255;
*/
if (temp1!=0xff && temp2 /*&& temp3==3*/)
{
temp4 = K054338_set_alpha_level(temp2);
if (temp4 <= 0) continue;
if (temp4 < 255) k = TILEMAP_DRAW_ALPHA(temp4);
}
if (mixerflags & 1<<(code+12)) k |= K056382_DRAW_FLAG_FORCE_XYSCROLL;
K056832_tilemap_draw(machine, bitmap, cliprect, code, k, 0);
}
continue;
case -2:
case -4:
if ((disp & K55_INP_SUB1) || (rushingheroes_hack))
{
int alpha = 255;
if (j == GXMIX_BLEND_NONE) { temp1 = 0xff; temp2 = temp3 = 0; } else
if (j == GXMIX_BLEND_FORCE) { temp1 = 0x00; temp2 = mixerflags>>24; temp3 = 3; }
else
{
temp1 = osinmix;
temp2 = osinmix>>2 & 3;
temp3 = osmixon>>2 & 3;
}
if (temp1!=0xff && temp2 /*&& temp3==3*/)
{
alpha = temp4 = K054338_set_alpha_level(temp2);
if (temp4 <= 0) continue;
if (temp4 < 255) k = (j == GXMIX_BLEND_FAST) ? ~parity : 1;
}
l = sub1flags & 0xf;
if (offs == -2)
{
int pixeldouble_output = 0;
const rectangle &visarea = machine->primary_screen->visible_area();
int width = visarea.max_x - visarea.min_x + 1;
if (width>512) // vsnetscr case
pixeldouble_output = 1;
K053936GP_0_zoom_draw(machine, bitmap, cliprect, sub1, l, k, alpha, pixeldouble_output);
}
else
{
K053250_draw(machine, bitmap, cliprect, 0, vcblk[4]<<l, 0, 0);
}
}
continue;
case -3:
case -5:
if (disp & K55_INP_SUB2)
{
int alpha = 255;
if (j == GXMIX_BLEND_NONE) { temp1 = 0xff; temp2 = temp3 = 0; } else
if (j == GXMIX_BLEND_FORCE) { temp1 = 0x00; temp2 = mixerflags>>26; temp3 = 3; }
else
{
temp1 = osinmix;
temp2 = osinmix>>4 & 3;
temp3 = osmixon>>4 & 3;
}
if (temp1!=0xff && temp2 /*&& temp3==3*/)
{
alpha = temp4 = K054338_set_alpha_level(temp2);
if (temp4 <= 0) continue;
if (temp4 < 255) k = (j == GXMIX_BLEND_FAST) ? ~parity : 1;
}
l = sub2flags & 0xf;
if (offs == -3)
{
if (extra_bitmap) // soccer superstars roz layer
{
int xx,yy;
int width = machine->primary_screen->width();
int height = machine->primary_screen->height();
const pen_t *paldata = machine->pens;
// the output size of the roz layer has to be doubled horizontally
// so that it aligns with the sprites and normal tilemaps. This appears
// to be done as a post-processing / mixing step effect
//
// - todo, use the pixeldouble_output I just added for vsnet instead?
for (yy=0;yy<height;yy++)
{
UINT16* src = BITMAP_ADDR16(extra_bitmap,yy,0);
UINT32* dst = BITMAP_ADDR32(bitmap,yy,0);
int shiftpos = 0;
for (xx=0;xx<width;xx+=2)
{
UINT16 dat = src[(((xx/2)+shiftpos))%width];
if (dat&0xff)
dst[xx+1] = dst[xx] = paldata[dat];
}
}
}
else
{
int pixeldouble_output = 0;
K053936GP_1_zoom_draw(machine, bitmap, cliprect, sub2, l, k, alpha, pixeldouble_output);
}
}
else
K053250_draw(machine, bitmap, cliprect, 1, vcblk[5]<<l, 0, 0);
}
continue;
}
continue;
}
drawmode = order>>4 & 0xf;
alpha = 255;
if (drawmode & 2)
{
alpha = color>>K055555_MIXSHIFT & 3;
if (alpha) alpha = K054338_set_alpha_level(alpha);
if (alpha <= 0) continue;
}
color &= K055555_COLORMASK;
if (drawmode >= 4) palette_set_shadow_mode(machine, order & 0x0f);
if (!(mixerflags & GXMIX_NOZBUF))
{
zcode = order>>16 & 0xff;
pri = order>>24 & 0xff;
}
else
zcode = -1; // negative zcode values turn off z-buffering
xa = ya = 0;
if (code & 0x01) xa += 1;
if (code & 0x02) ya += 1;
if (code & 0x04) xa += 2;
if (code & 0x08) ya += 2;
if (code & 0x10) xa += 4;
if (code & 0x20) ya += 4;
code &= ~0x3f;
temp4 = gx_spriteram[offs];
// mask off the upper 6 bits of coordinate and zoom registers
oy = gx_spriteram[offs+2] & 0x3ff;
ox = gx_spriteram[offs+3] & 0x3ff;
scaley = zoomy = gx_spriteram[offs+4] & 0x3ff;
if (zoomy) zoomy = (0x400000+(zoomy>>1)) / zoomy;
else zoomy = 0x800000;
if (!(temp4 & 0x4000))
{
scalex = zoomx = gx_spriteram[offs+5] & 0x3ff;
if (zoomx) zoomx = (0x400000+(zoomx>>1)) / zoomx;
else zoomx = 0x800000;
}
else { zoomx = zoomy; scalex = scaley; }
nozoom = (scalex == 0x40 && scaley == 0x40);
flipx = temp4 & 0x1000;
flipy = temp4 & 0x2000;
temp = gx_spriteram[offs+6];
mirrorx = temp & 0x4000;
if (mirrorx) flipx = 0; // only applies to x mirror, proven
mirrory = temp & 0x8000;
// for Escape Kids (GX975)
if ( K053246_objset1 & 8 ) // Check only "Bit #3 is '1'?"
{
zoomx = zoomx>>1; // Fix sprite width to HALF size
ox = (ox>>1) + 1; // Fix sprite draw position
if (flipscreenx) ox += screenwidth;
}
if (flipscreenx) { ox = -ox; if (!mirrorx) flipx = !flipx; }
if (flipscreeny) { oy = -oy; if (!mirrory) flipy = !flipy; }
// apply wrapping and global offsets
temp = wrapsize-1;
ox += K053247_dx;
oy -= K053247_dy;
ox = ( ox - offx) & temp;
oy = (-oy - offy) & temp;
if (ox >= xwraplim) ox -= wrapsize;
if (oy >= ywraplim) oy -= wrapsize;
temp = temp4>>8 & 0x0f;
k = 1 << (temp & 3);
l = 1 << (temp>>2 & 3);
ox -= (zoomx * k) >> 13;
oy -= (zoomy * l) >> 13;
// substitutes: i=x, j=y, k=w, l=h, temp=code, temp1=fx, temp2=fy, temp3=sx, temp4=sy;
for (j=0; j<l; j++)
{
temp4 = oy + ((zoomy * j + (1<<11)) >> 12);
zh = (oy + ((zoomy * (j+1) + (1<<11)) >> 12)) - temp4;
for (i=0; i<k; i++)
{
temp3 = ox + ((zoomx * i + (1<<11)) >> 12);
zw = (ox + ((zoomx * (i+1) + (1<<11)) >> 12)) - temp3;
temp = code;
if (mirrorx)
{
if ((!flipx)^((i<<1)<k))
{
/* mirror left/right */
temp += xoffset[(k-1-i+xa)&7];
temp1 = 1;
}
else
{
temp += xoffset[(i+xa)&7];
temp1 = 0;
}
}
else
{
if (flipx) temp += xoffset[(k-1-i+xa)&7];
else temp += xoffset[(i+xa)&7];
temp1 = flipx;
}
if (mirrory)
{
if ((!flipy)^((j<<1)>=l))
{
/* mirror top/bottom */
temp += yoffset[(l-1-j+ya)&7];
temp2 = 1;
}
else
{
temp += yoffset[(j+ya)&7];
temp2 = 0;
}
}
else
{
if (flipy) temp += yoffset[(l-1-j+ya)&7];
else temp += yoffset[(j+ya)&7];
temp2 = flipy;
}
if (nozoom) { scaley = scalex = 0x10000; } else { scalex = zw << 12; scaley = zh << 12; };
zdrawgfxzoom32GP(
bitmap, cliprect, K053247_gfx,
temp,
color,
temp1,temp2,
temp3,temp4,
scalex, scaley, alpha, drawmode, zcode, pri);
}
}
}
}
/* Run and Gun 2 / Rushing Heroes */
static TILE_GET_INFO( get_gx_psac_tile_info )
{
int tileno, colour, col, flip = 0;
if (tile_index&1)
{
tileno = gx_psacram[tile_index/2] & 0x00001fff;
col =(gx_psacram[tile_index/2] & 0x00002000)>>13;
if (gx_psacram[tile_index/2] & 0x00004000) flip |= TILE_FLIPX;
if (gx_psacram[tile_index/2] & 0x00008000) flip |= TILE_FLIPY;
}
else
{
tileno = (gx_psacram[tile_index/2] & 0x1fff0000)>>16;
col = (gx_psacram[tile_index/2] & 0x20000000)>>29;
if (gx_psacram[tile_index/2] & 0x40000000) flip |= TILE_FLIPX;
if (gx_psacram[tile_index/2] & 0x80000000) flip |= TILE_FLIPY;
}
colour = (psac_colorbase << 4) + col;
SET_TILE_INFO(0, tileno, colour, TILE_FLIPYX(flip));
}
UINT32* konamigx_type3_psac2_bank;
static int konamigx_type3_psac2_actual_bank;
//int konamigx_type3_psac2_actual_last_bank = 0;
WRITE32_HANDLER( konamigx_type3_psac2_bank_w )
{
// other bits are used for something...
COMBINE_DATA(&konamigx_type3_psac2_bank[offset]);
konamigx_type3_psac2_actual_bank = (konamigx_type3_psac2_bank[0] & 0x10000000) >> 28;
/* handle this by creating 2 roz tilemaps instead, otherwise performance dies completely on dual screen mode
if (konamigx_type3_psac2_actual_bank!=konamigx_type3_psac2_actual_last_bank)
{
tilemap_mark_all_tiles_dirty (gx_psac_tilemap);
konamigx_type3_psac2_actual_last_bank = konamigx_type3_psac2_actual_bank;
}
*/
}
/* Soccer Superstars (tile and flip bits now TRUSTED) */
static TILE_GET_INFO( get_gx_psac3_tile_info )
{
int tileno, colour, flip;
UINT8 *tmap = memory_region(machine, "gfx4");
int base_index = tile_index;
// if (konamigx_type3_psac2_actual_bank)
// base_index+=0x20000/2;
tileno = tmap[base_index*2] | ((tmap[(base_index*2)+1] & 0x0f)<<8);
colour = (tmap[(base_index*2)+1]&0xc0)>>6;
flip = 0;
if (tmap[(base_index*2)+1] & 0x20) flip |= TILE_FLIPY;
if (tmap[(base_index*2)+1] & 0x10) flip |= TILE_FLIPX;
SET_TILE_INFO(0, tileno, colour, flip);
}
static TILE_GET_INFO( get_gx_psac3_alt_tile_info )
{
int tileno, colour, flip;
UINT8 *tmap = memory_region(machine, "gfx4")+0x20000;
int base_index = tile_index;
// if (konamigx_type3_psac2_actual_bank)
// base_index+=0x20000/2;
tileno = tmap[base_index*2] | ((tmap[(base_index*2)+1] & 0x0f)<<8);
colour = (tmap[(base_index*2)+1]&0xc0)>>6;
flip = 0;
if (tmap[(base_index*2)+1] & 0x20) flip |= TILE_FLIPY;
if (tmap[(base_index*2)+1] & 0x10) flip |= TILE_FLIPX;
SET_TILE_INFO(0, tileno, colour, flip);
}
/* PSAC4 */
/* these tilemaps are weird in both format and content, one of them
doesn't really look like it should be displayed? - it's height data */
static TILE_GET_INFO( get_gx_psac1a_tile_info )
{
int tileno, colour, flipx,flipy;
int flip;
flip=0;
colour = 0;
tileno = (gx_psacram[tile_index*2] & 0x00003fff)>>0;
// scanrows
//flipx = (gx_psacram[tile_index*2+1] & 0x00800000)>>23;
//flipy = (gx_psacram[tile_index*2+1] & 0x00400000)>>22;
// scancols
flipy = (gx_psacram[tile_index*2+1] & 0x00800000)>>23;
flipx = (gx_psacram[tile_index*2+1] & 0x00400000)>>22;
if (flipx) flip |= TILE_FLIPX;
if (flipy) flip |= TILE_FLIPY;
SET_TILE_INFO(1, tileno, colour, flip);
}
static TILE_GET_INFO( get_gx_psac1b_tile_info )
{
int tileno, colour, flipx,flipy;
int flip;
flip=0;
colour = 0;
tileno = (gx_psacram[tile_index*2+1] & 0x00003fff)>>0;
// scanrows
//flipx = (gx_psacram[tile_index*2+1] & 0x00800000)>>23;
//flipy = (gx_psacram[tile_index*2+1] & 0x00400000)>>22;
// scancols
flipy = (gx_psacram[tile_index*2+1] & 0x00200000)>>21;
flipx = (gx_psacram[tile_index*2+1] & 0x00100000)>>20;
if (flipx) flip |= TILE_FLIPX;
if (flipy) flip |= TILE_FLIPY;
SET_TILE_INFO(0, tileno, colour, flip);
}
static void konamigx_type2_tile_callback(int layer, int *code, int *color, int *flags)
{
int d = *code;
*code = (gx_tilebanks[(d & 0xe000)>>13]<<13) + (d & 0x1fff);
K055555GX_decode_vmixcolor(layer, color);
}
static void konamigx_alpha_tile_callback(int layer, int *code, int *color, int *flags)
{
int mixcode;
int d = *code;
mixcode = K055555GX_decode_vmixcolor(layer, color);
if (mixcode < 0)
*code = (gx_tilebanks[(d & 0xe000)>>13]<<13) + (d & 0x1fff);
else
{
/* save mixcode and mark tile alpha (unimplemented) */
*code = 0;
if (VERBOSE)
popmessage("skipped alpha tile(layer=%d mix=%d)", layer, mixcode);
}
}
/*
> bits 8-13 are the low priority bits
> i.e. pri 0-5
> pri 6-7 can be either 1, bits 14,15 or bits 16,17
> contro.bit 2 being 0 forces the 1
> when control.bit 2 is 1, control.bit 3 selects between the two
> 0 selects 16,17
> that gives you the entire 8 bits of the sprite priority
> ok, lemme see if I've got this. bit2 = 0 means the top bits are 11, bit2=1 means the top bits are bits 14/15 (of the whatever word?) else
+16+17?
> bit3=1 for the second
* 6 | ---------xxxxxxx | "color", but depends on external connections
> there are 8 color lines entering the 5x5
> that means the palette is 4 bits, not 5 as you currently have
> the bits 4-9 are the low priority bits
> bits 10/11 or 12/13 are the two high priority bits, depending on the control word
> and bits 14/15 are the shadow bits
> mix0/1 and brit0/1 come from elsewhere
> they come from the '673 all right, but not from word 6
> and in fact the top address bits are highly suspect
> only 18 of the address bits go to the roms
> the next 2 go to cai0/1 and the next 4 to bk0-3
> (the '246 indexes the roms, the '673 reads the result)
> the roms are 64 bits wide
> so, well, the top bits of the code are suspicious
*/
static void _gxcommoninitnosprites(running_machine *machine)
{
int i;
K054338_vh_start(machine);
K055555_vh_start(machine);
konamigx_mixer_init(machine, 0);
for (i = 0; i < 8; i++)
{
gx_tilebanks[i] = gx_oldbanks[i] = 0;
}
state_save_register_global_array(machine, gx_tilebanks);
gx_tilemode = 0;
gx_rozenable = 0;
gx_specialrozenable = 0;
gx_rushingheroes_hack = 0;
gx_le2_textcolour_hack = 0;
// Documented relative offsets of non-flipped games are (-2, 0, 2, 3),(0, 0, 0, 0).
// (+ve values move layers to the right and -ve values move layers to the left)
// In most cases only a constant is needed to add to the X offsets to yield correct
// displacement. This should be done by the CCU but the CRT timings have not been
// figured out.
K056832_set_LayerOffset(0, -2, 0);
K056832_set_LayerOffset(1, 0, 0);
K056832_set_LayerOffset(2, 2, 0);
K056832_set_LayerOffset(3, 3, 0);
konamigx_has_dual_screen = 0;
konamigx_current_frame = 0;
}
static void _gxcommoninit(running_machine *machine)
{
// (+ve values move objects to the right and -ve values move objects to the left)
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_GX, -26, -23, konamigx_type2_sprite_callback);
_gxcommoninitnosprites(machine);
}
VIDEO_START(konamigx_5bpp)
{
if (!strcmp(machine->gamedrv->name,"sexyparo"))
game_tile_callback = konamigx_alpha_tile_callback;
else
game_tile_callback = konamigx_type2_tile_callback;
K056832_vh_start(machine, "gfx1", K056832_BPP_5, 0, NULL, game_tile_callback, 0);
_gxcommoninit(machine);
/* here are some hand tuned per game scroll offsets to go with the per game visible areas,
i see no better way of doing this for now... */
if (!strcmp(machine->gamedrv->name,"tbyahhoo"))
{
K056832_set_UpdateMode(1);
gx_tilemode = 1;
} else
if (!strcmp(machine->gamedrv->name,"puzldama"))
{
K053247GP_set_SpriteOffset(-46, -23);
konamigx_mixer_primode(5);
} else
if (!strcmp(machine->gamedrv->name,"daiskiss"))
{
konamigx_mixer_primode(4);
} else
if (!strcmp(machine->gamedrv->name,"gokuparo") || !strcmp(machine->gamedrv->name,"fantjour") || !strcmp(machine->gamedrv->name,"fantjoura"))
{
K053247GP_set_SpriteOffset(-46, -23);
} else
if (!strcmp(machine->gamedrv->name,"sexyparo"))
{
K053247GP_set_SpriteOffset(-42, -23);
}
}
VIDEO_START(winspike)
{
K056832_vh_start(machine, "gfx1", K056832_BPP_8, 0, NULL, konamigx_alpha_tile_callback, 2);
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_LE2, -53, -23, konamigx_type2_sprite_callback);
_gxcommoninitnosprites(machine);
}
VIDEO_START(dragoonj)
{
K056832_vh_start(machine, "gfx1", K056832_BPP_5, 1, NULL, konamigx_type2_tile_callback, 0);
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_RNG, -53, -23, konamigx_dragoonj_sprite_callback);
_gxcommoninitnosprites(machine);
K056832_set_LayerOffset(0, -2+1, 0);
K056832_set_LayerOffset(1, 0+1, 0);
K056832_set_LayerOffset(2, 2+1, 0);
K056832_set_LayerOffset(3, 3+1, 0);
}
VIDEO_START(le2)
{
K056832_vh_start(machine, "gfx1", K056832_BPP_8, 1, NULL, konamigx_type2_tile_callback, 0);
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_LE2, -46, -23, konamigx_le2_sprite_callback);
_gxcommoninitnosprites(machine);
konamigx_mixer_primode(-1); // swapped layer B and C priorities?
gx_le2_textcolour_hack = 1; // force text layer to use the right palette
K055555_write_reg(K55_INPUT_ENABLES, 1); // it doesn't turn on the video output at first for the test screens, maybe it should default to ON?
}
VIDEO_START(konamigx_6bpp)
{
K056832_vh_start(machine, "gfx1", K056832_BPP_6, 0, NULL, konamigx_type2_tile_callback, 0);
_gxcommoninit(machine);
if (!strcmp(machine->gamedrv->name,"tokkae") || !strcmp(machine->gamedrv->name,"tkmmpzdm"))
{
K053247GP_set_SpriteOffset(-46, -23);
konamigx_mixer_primode(5);
}
}
VIDEO_START(konamigx_type3)
{
int width = machine->primary_screen->width();
int height = machine->primary_screen->height();
K056832_vh_start(machine, "gfx1", K056832_BPP_6, 0, NULL, konamigx_type2_tile_callback, 1);
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_GX6, -132, -23, konamigx_type2_sprite_callback);
dualscreen_left_tempbitmap = auto_bitmap_alloc(machine, width, height, BITMAP_FORMAT_RGB32);
dualscreen_right_tempbitmap = auto_bitmap_alloc(machine, width, height, BITMAP_FORMAT_RGB32);
_gxcommoninitnosprites(machine);
gx_psac_tilemap = tilemap_create(machine, get_gx_psac3_tile_info, tilemap_scan_cols, 16, 16, 256, 256);
gx_psac_tilemap_alt = tilemap_create(machine, get_gx_psac3_alt_tile_info, tilemap_scan_cols, 16, 16, 256, 256);
gx_rozenable = 0;
gx_specialrozenable = 2;
/* set up tile layers */
type3_roz_temp_bitmap = auto_bitmap_alloc(machine, width, height, BITMAP_FORMAT_INDEXED16);
//tilemap_set_flip(gx_psac_tilemap, TILEMAP_FLIPX| TILEMAP_FLIPY);
K053936_wraparound_enable(0, 1);
// K053936GP_set_offset(0, -30, -1);
K053936_set_offset(0, -30, +1);
K056832_set_LayerOffset(0, -52, 0);
K056832_set_LayerOffset(1, -48, 0);
K056832_set_LayerOffset(2, -48, 0);
K056832_set_LayerOffset(3, -48, 0);
konamigx_has_dual_screen = 1;
konamigx_palformat = 1;
}
VIDEO_START(konamigx_type4)
{
int width = machine->primary_screen->width();
int height = machine->primary_screen->height();
K056832_vh_start(machine, "gfx1", K056832_BPP_8, 0, NULL, konamigx_type2_tile_callback, 0);
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_GX6, -79, -24, konamigx_type2_sprite_callback); // -23 looks better in intro
dualscreen_left_tempbitmap = auto_bitmap_alloc(machine, width, height, BITMAP_FORMAT_RGB32);
dualscreen_right_tempbitmap = auto_bitmap_alloc(machine, width, height, BITMAP_FORMAT_RGB32);
_gxcommoninitnosprites(machine);
gx_psac_tilemap = tilemap_create(machine, get_gx_psac_tile_info, tilemap_scan_cols, 16, 16, 128, 128);
gx_rozenable = 0;
gx_specialrozenable = 3;
K056832_set_LayerOffset(0, -27, 0);
K056832_set_LayerOffset(1, -25, 0);
K056832_set_LayerOffset(2, -24, 0);
K056832_set_LayerOffset(3, -22, 0);
K053936_wraparound_enable(0, 0);
K053936GP_set_offset(0, -36, 1);
gx_rushingheroes_hack = 1;
konamigx_has_dual_screen = 1;
konamigx_palformat = 0;
}
VIDEO_START(konamigx_type4_vsn)
{
int width = machine->primary_screen->width();
int height = machine->primary_screen->height();
K056832_vh_start(machine, "gfx1", K056832_BPP_8, 0, NULL, konamigx_type2_tile_callback, 2); // set djmain_hack to 2 to kill layer association or half the tilemaps vanish on screen 0
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_GX6, -132, -23, konamigx_type2_sprite_callback);
dualscreen_left_tempbitmap = auto_bitmap_alloc(machine, width, height, BITMAP_FORMAT_RGB32);
dualscreen_right_tempbitmap = auto_bitmap_alloc(machine, width, height, BITMAP_FORMAT_RGB32);
_gxcommoninitnosprites(machine);
gx_psac_tilemap = tilemap_create(machine, get_gx_psac_tile_info, tilemap_scan_cols, 16, 16, 128, 128);
gx_rozenable = 0;
gx_specialrozenable = 3;
K056832_set_LayerOffset(0, -52, 0);
K056832_set_LayerOffset(1, -48, 0);
K056832_set_LayerOffset(2, -48, 0);
K056832_set_LayerOffset(3, -48, 0);
K053936_wraparound_enable(0, 1); // wraparound doesn't work properly with the custom drawing function anyway, see the crowd in vsnet and rushhero
K053936GP_set_offset(0, -30, 0);
gx_rushingheroes_hack = 1;
konamigx_has_dual_screen = 1;
konamigx_palformat = 0;
}
VIDEO_START(konamigx_type4_sd2)
{
int width = machine->primary_screen->width();
int height = machine->primary_screen->height();
K056832_vh_start(machine, "gfx1", K056832_BPP_8, 0, NULL, konamigx_type2_tile_callback, 0);
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_GX6, -81, -23, konamigx_type2_sprite_callback);
dualscreen_left_tempbitmap = auto_bitmap_alloc(machine, width, height, BITMAP_FORMAT_RGB32);
dualscreen_right_tempbitmap = auto_bitmap_alloc(machine, width, height, BITMAP_FORMAT_RGB32);
_gxcommoninitnosprites(machine);
gx_psac_tilemap = tilemap_create(machine, get_gx_psac_tile_info, tilemap_scan_cols, 16, 16, 128, 128);
gx_rozenable = 0;
gx_specialrozenable = 3;
K056832_set_LayerOffset(0, -29, -1);
K056832_set_LayerOffset(1, -27, -1);
K056832_set_LayerOffset(2, -26, -1);
K056832_set_LayerOffset(3, -24, -1);
K053936_wraparound_enable(0, 0);
K053936GP_set_offset(0, -36, -1);
gx_rushingheroes_hack = 1;
konamigx_has_dual_screen = 1;
konamigx_palformat = 0;
}
VIDEO_START(konamigx_6bpp_2)
{
K056832_vh_start(machine, "gfx1", K056832_BPP_6, 1, NULL, konamigx_type2_tile_callback, 0);
if (!strcmp(machine->gamedrv->name,"salmndr2") || !strcmp(machine->gamedrv->name,"salmndr2a"))
{
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_GX6, -48, -23, konamigx_salmndr2_sprite_callback);
_gxcommoninitnosprites(machine);
}
else
{
_gxcommoninit(machine);
}
}
VIDEO_START(opengolf)
{
K056832_vh_start(machine, "gfx1", K056832_BPP_5, 0, NULL, konamigx_type2_tile_callback, 0);
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_GX6, -53, -23, konamigx_type2_sprite_callback);
_gxcommoninitnosprites(machine);
K056832_set_LayerOffset(0, -2+1, 0);
K056832_set_LayerOffset(1, 0+1, 0);
K056832_set_LayerOffset(2, 2+1, 0);
K056832_set_LayerOffset(3, 3+1, 0);
gx_psac_tilemap = tilemap_create(machine, get_gx_psac1a_tile_info, tilemap_scan_cols, 16, 16, 128, 128);
gx_psac_tilemap2 = tilemap_create(machine, get_gx_psac1b_tile_info, tilemap_scan_cols, 16, 16, 128, 128);
// transparency will be handled manually in post-processing
//tilemap_set_transparent_pen(gx_psac_tilemap, 0);
//tilemap_set_transparent_pen(gx_psac_tilemap2, 0);
gx_rozenable = 0;
gx_specialrozenable = 1;
gxtype1_roz_dstbitmap = auto_bitmap_alloc(machine,512,512,BITMAP_FORMAT_INDEXED16); // BITMAP_FORMAT_INDEXED16 because we NEED the raw pen data for post-processing
gxtype1_roz_dstbitmap2 = auto_bitmap_alloc(machine,512,512,BITMAP_FORMAT_INDEXED16); // BITMAP_FORMAT_INDEXED16 because we NEED the raw pen data for post-processing
gxtype1_roz_dstbitmapclip.min_x = 0;
gxtype1_roz_dstbitmapclip.max_x = 512-1;
gxtype1_roz_dstbitmapclip.min_y = 0;
gxtype1_roz_dstbitmapclip.max_y = 512-1;
K053936_wraparound_enable(0, 1);
K053936GP_set_offset(0, 0, 0);
// urgh.. the priority bitmap is global, and because our temp bitmaps are bigger than the screen, this causes issues.. so just allocate something huge
// until there is a better solution, or priority bitmap can be specified manually.
machine->priority_bitmap = auto_bitmap_alloc(machine,2048,2048,BITMAP_FORMAT_INDEXED16);
}
VIDEO_START(racinfrc)
{
K056832_vh_start(machine, "gfx1", K056832_BPP_6, 0, NULL, konamigx_type2_tile_callback, 0);
K055673_vh_start(machine, "gfx2", K055673_LAYOUT_GX, -53, -23, konamigx_type2_sprite_callback);
_gxcommoninitnosprites(machine);
K056832_set_LayerOffset(0, -2+1, 0);
K056832_set_LayerOffset(1, 0+1, 0);
K056832_set_LayerOffset(2, 2+1, 0);
K056832_set_LayerOffset(3, 3+1, 0);
gx_psac_tilemap = tilemap_create(machine, get_gx_psac1a_tile_info, tilemap_scan_cols, 16, 16, 128, 128);
gx_psac_tilemap2 = tilemap_create(machine, get_gx_psac1b_tile_info, tilemap_scan_cols, 16, 16, 128, 128);
// transparency will be handled manually in post-processing
//tilemap_set_transparent_pen(gx_psac_tilemap, 0);
//tilemap_set_transparent_pen(gx_psac_tilemap2, 0);
gx_rozenable = 0;
gx_specialrozenable = 1;
gxtype1_roz_dstbitmap = auto_bitmap_alloc(machine,512,512,BITMAP_FORMAT_INDEXED16); // BITMAP_FORMAT_INDEXED16 because we NEED the raw pen data for post-processing
gxtype1_roz_dstbitmap2 = auto_bitmap_alloc(machine,512,512,BITMAP_FORMAT_INDEXED16); // BITMAP_FORMAT_INDEXED16 because we NEED the raw pen data for post-processing
gxtype1_roz_dstbitmapclip.min_x = 0;
gxtype1_roz_dstbitmapclip.max_x = 512-1;
gxtype1_roz_dstbitmapclip.min_y = 0;
gxtype1_roz_dstbitmapclip.max_y = 512-1;
K053936_wraparound_enable(0, 1);
K053936GP_set_offset(0, 0, 0);
// urgh.. the priority bitmap is global, and because our temp bitmaps are bigger than the screen, this causes issues.. so just allocate something huge
// until there is a better solution, or priority bitmap can be specified manually.
machine->priority_bitmap = auto_bitmap_alloc(machine,2048,2048,BITMAP_FORMAT_INDEXED16);
}
VIDEO_UPDATE(konamigx)
{
int i, newbank, newbase, dirty, unchained;
bitmap_t* realbitmap = bitmap;
if (konamigx_has_dual_screen)
{
running_device *left_screen = screen->machine->device("screen");
running_device *right_screen = screen->machine->device("screen2");
/* the video gets demuxed by a board which plugs into the jamma connector */
if (screen==left_screen)
{
konamigx_current_frame^=1;
if (konamigx_current_frame==1)
{
int offset=0;
if (konamigx_palformat==1)
{
for (offset=0;offset<0x4000/4;offset++)
{
UINT32 coldat = screen->machine->generic.paletteram.u32[offset];
set_color_555(screen->machine, offset*2, 0, 5, 10,coldat >> 16);
set_color_555(screen->machine, offset*2+1, 0, 5, 10,coldat & 0xffff);
}
}
else
{
for (offset=0;offset<0x8000/4;offset++)
{
int r,g,b;
r = (screen->machine->generic.paletteram.u32[offset] >>16) & 0xff;
g = (screen->machine->generic.paletteram.u32[offset] >> 8) & 0xff;
b = (screen->machine->generic.paletteram.u32[offset] >> 0) & 0xff;
palette_set_color(screen->machine,offset,MAKE_RGB(r,g,b));
}
}
bitmap = dualscreen_left_tempbitmap;
// draw
}
else
{
copybitmap(bitmap, dualscreen_left_tempbitmap, 0, 0, 0, 0, cliprect);
return 0;
}
}
else if (screen==right_screen)
{
if (konamigx_current_frame==1)
{
copybitmap(bitmap, dualscreen_right_tempbitmap, 0, 0, 0, 0, cliprect);
return 0;
}
else
{
int offset=0;
if (konamigx_palformat==1)
{
for (offset=0;offset<0x4000/4;offset++)
{
UINT32 coldat = gx_subpaletteram32[offset];
set_color_555(screen->machine, offset*2, 0, 5, 10,coldat >> 16);
set_color_555(screen->machine, offset*2+1, 0, 5, 10,coldat & 0xffff);
}
}
else
{
for (offset=0;offset<0x8000/4;offset++)
{
int r,g,b;
r = (gx_subpaletteram32[offset] >>16) & 0xff;
g = (gx_subpaletteram32[offset] >> 8) & 0xff;
b = (gx_subpaletteram32[offset] >> 0) & 0xff;
palette_set_color(screen->machine,offset,MAKE_RGB(r,g,b));
}
}
bitmap = dualscreen_right_tempbitmap;
// draw
}
}
}
/* if any banks are different from last render, we need to flush the planes */
for (dirty = 0, i = 0; i < 8; i++)
{
newbank = gx_tilebanks[i];
if (gx_oldbanks[i] != newbank) { gx_oldbanks[i] = newbank; dirty = 1; }
}
if (gx_tilemode == 0)
{
// driver approximates tile update in mode 0 for speed
unchained = K056832_get_LayerAssociation();
for (i=0; i<4; i++)
{
newbase = K055555_get_palette_index(i)<<6;
if (layer_colorbase[i] != newbase)
{
layer_colorbase[i] = newbase;
if (unchained)
K056832_mark_plane_dirty(i);
else
dirty = 1;
}
}
}
else
{
// K056832 does all the tracking in mode 1 for accuracy (Twinbee needs this)
}
// sub2 is PSAC colorbase on GX
if (gx_rozenable)
{
last_psac_colorbase = psac_colorbase;
psac_colorbase = K055555_get_palette_index(6);
if (psac_colorbase != last_psac_colorbase)
{
tilemap_mark_all_tiles_dirty(gx_psac_tilemap);
if (gx_rozenable == 3)
{
tilemap_mark_all_tiles_dirty(gx_psac_tilemap2);
}
}
}
if (dirty) K056832_MarkAllTilemapsDirty();
// Type-1
if (gx_specialrozenable == 1)
{
K053936_0_zoom_draw(gxtype1_roz_dstbitmap, &gxtype1_roz_dstbitmapclip,gx_psac_tilemap, 0,0,0); // height data
K053936_0_zoom_draw(gxtype1_roz_dstbitmap2,&gxtype1_roz_dstbitmapclip,gx_psac_tilemap2,0,0,0); // colour data (+ some voxel height data?)
}
if (gx_specialrozenable==3)
{
konamigx_mixer(screen->machine, bitmap, cliprect, gx_psac_tilemap, GXSUB_8BPP,0,0, 0, 0, gx_rushingheroes_hack);
}
// hack, draw the roz tilemap if W is held
// todo: fix so that it works with the mixer without crashing(!)
else if (gx_specialrozenable == 2)
{
// we're going to throw half of this away anyway in post-process, so only render what's needed
rectangle temprect;
temprect.min_x = cliprect->min_x;
temprect.max_x = cliprect->min_x+320;
temprect.min_y = cliprect->min_y;
temprect.max_y = cliprect->max_y;
if (konamigx_type3_psac2_actual_bank == 1) K053936_0_zoom_draw(type3_roz_temp_bitmap, &temprect,gx_psac_tilemap_alt, 0,0,0); // soccerss playfield
else K053936_0_zoom_draw(type3_roz_temp_bitmap, &temprect,gx_psac_tilemap, 0,0,0); // soccerss playfield
konamigx_mixer(screen->machine, bitmap, cliprect, 0, 0, 0, 0, 0, type3_roz_temp_bitmap, gx_rushingheroes_hack);
}
else
{
konamigx_mixer(screen->machine, bitmap, cliprect, 0, 0, 0, 0, 0, 0, gx_rushingheroes_hack);
}
/* Hack! draw type-1 roz layer here for testing purposes only */
if (gx_specialrozenable == 1)
{
const pen_t *paldata = screen->machine->pens;
if ( input_code_pressed(screen->machine, KEYCODE_W) )
{
int y,x;
// make it flicker, to compare positioning
//if (screen->frame_number() & 1)
{
for (y=0;y<256;y++)
{
//UINT16* src = BITMAP_ADDR16( gxtype1_roz_dstbitmap, y, 0);
//UINT32* dst = BITMAP_ADDR32( bitmap, y, 0);
// ths K053936 rendering should probably just be flipped
// this is just kludged to align the racing force 2d logo
UINT16* src = BITMAP_ADDR16( gxtype1_roz_dstbitmap2, y+30, 0);
UINT32* dst = BITMAP_ADDR32( bitmap, 256-y, 0);
for (x=0;x<512;x++)
{
UINT16 dat = src[x];
dst[x] = paldata[dat];
}
}
}
}
}
if (konamigx_has_dual_screen)
{
running_device *left_screen = screen->machine->device("screen");
running_device *right_screen = screen->machine->device("screen2");
if (screen==left_screen)
{
copybitmap(realbitmap, dualscreen_left_tempbitmap, 0, 0, 0, 0, cliprect);
}
else if (screen==right_screen)
{
copybitmap(realbitmap, dualscreen_right_tempbitmap, 0, 0, 0, 0, cliprect);
}
}
return 0;
}
WRITE32_HANDLER( konamigx_palette_w )
{
int r,g,b;
COMBINE_DATA(&space->machine->generic.paletteram.u32[offset]);
r = (space->machine->generic.paletteram.u32[offset] >>16) & 0xff;
g = (space->machine->generic.paletteram.u32[offset] >> 8) & 0xff;
b = (space->machine->generic.paletteram.u32[offset] >> 0) & 0xff;
palette_set_color(space->machine,offset,MAKE_RGB(r,g,b));
}
#ifdef UNUSED_FUNCTION
WRITE32_HANDLER( konamigx_palette2_w )
{
int r,g,b;
COMBINE_DATA(&gx_subpaletteram32[offset]);
r = (gx_subpaletteram32[offset] >>16) & 0xff;
g = (gx_subpaletteram32[offset] >> 8) & 0xff;
b = (gx_subpaletteram32[offset] >> 0) & 0xff;
offset += (0x8000/4);
palette_set_color(space->machine,offset,MAKE_RGB(r,g,b));
}
#endif
INLINE void set_color_555(running_machine *machine, pen_t color, int rshift, int gshift, int bshift, UINT16 data)
{
palette_set_color_rgb(machine, color, pal5bit(data >> rshift), pal5bit(data >> gshift), pal5bit(data >> bshift));
}
#ifdef UNUSED_FUNCTION
// main monitor for type 3
WRITE32_HANDLER( konamigx_555_palette_w )
{
UINT32 coldat;
COMBINE_DATA(&space->machine->generic.paletteram.u32[offset]);
coldat = space->machine->generic.paletteram.u32[offset];
set_color_555(space->machine, offset*2, 0, 5, 10,coldat >> 16);
set_color_555(space->machine, offset*2+1, 0, 5, 10,coldat & 0xffff);
}
// sub monitor for type 3
WRITE32_HANDLER( konamigx_555_palette2_w )
{
UINT32 coldat;
COMBINE_DATA(&gx_subpaletteram32[offset]);
coldat = gx_subpaletteram32[offset];
offset += (0x4000/4);
set_color_555(space->machine, offset*2, 0, 5, 10,coldat >> 16);
set_color_555(space->machine, offset*2+1, 0, 5, 10,coldat & 0xffff);
}
#endif
WRITE32_HANDLER( konamigx_tilebank_w )
{
if (ACCESSING_BITS_24_31)
gx_tilebanks[offset*4] = (data>>24)&0xff;
if (ACCESSING_BITS_16_23)
gx_tilebanks[offset*4+1] = (data>>16)&0xff;
if (ACCESSING_BITS_8_15)
gx_tilebanks[offset*4+2] = (data>>8)&0xff;
if (ACCESSING_BITS_0_7)
gx_tilebanks[offset*4+3] = data&0xff;
}
// type 1 RAM-based PSAC tilemap
WRITE32_HANDLER(konamigx_t1_psacmap_w)
{
COMBINE_DATA(&gx_psacram[offset]);
tilemap_mark_tile_dirty(gx_psac_tilemap, offset/2);
tilemap_mark_tile_dirty(gx_psac_tilemap2, offset/2);
}
// type 4 RAM-based PSAC tilemap
WRITE32_HANDLER( konamigx_t4_psacmap_w )
{
COMBINE_DATA(&gx_psacram[offset]);
tilemap_mark_tile_dirty(gx_psac_tilemap, offset*2);
tilemap_mark_tile_dirty(gx_psac_tilemap, (offset*2)+1);
}
| 28.377352 | 185 | 0.619919 | [
"render",
"object",
"solid"
] |
43d9601416c44cad19d31c069fba93d77a595872 | 50,854 | c | C | Core/rt/vm/core/src/method.c | bugvm/robovm | 430cbeb4a9f49f48b982821b40741fad110efe57 | [
"MIT"
] | 29 | 2018-06-04T21:34:00.000Z | 2022-02-21T16:34:44.000Z | Core/rt/vm/core/src/method.c | bugvm/robovm | 430cbeb4a9f49f48b982821b40741fad110efe57 | [
"MIT"
] | 15 | 2018-03-02T03:38:56.000Z | 2021-03-22T02:06:14.000Z | Core/rt/vm/core/src/method.c | bugvm/robovm | 430cbeb4a9f49f48b982821b40741fad110efe57 | [
"MIT"
] | 6 | 2018-10-17T02:28:28.000Z | 2020-11-27T04:47:50.000Z | /*
* Copyright (C) 2012 RoboVM AB
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <bugvm.h>
#include <string.h>
#include <unwind.h>
#include "private.h"
#include "utlist.h"
#define LOG_TAG "core.method"
// Line numbers greater or equal to this value is used
// for methods which have no line number info.
#define FIRST_NO_LINE_NUMBERS_LINE 0x00100000
DynamicLib* bootNativeLibs = NULL;
DynamicLib* mainNativeLibs = NULL;
static Mutex nativeLibsLock;
static Mutex threadStackTraceLock;
static jvalue emptyJValueArgs[1];
static Class* java_lang_StackTraceElement = NULL;
static Method* java_lang_StackTraceElement_constructor = NULL;
static ObjectArray* empty_java_lang_StackTraceElement_array = NULL;
// A shared CallStack struct used by bugvmCaptureCallStackForThread() that can store at most MAX_CALL_STACK_LENGTH
// frames. dumpThreadStackTrace() assumes MAX_CALL_STACK_LENGTH.
static CallStack* shared_callStack = NULL;
static inline void obtainNativeLibsLock() {
bugvmLockMutex(&nativeLibsLock);
}
static inline void releaseNativeLibsLock() {
bugvmUnlockMutex(&nativeLibsLock);
}
static inline void obtainThreadStackTraceLock() {
bugvmLockMutex(&threadStackTraceLock);
}
static inline void releaseThreadStackTraceLock() {
bugvmUnlockMutex(&threadStackTraceLock);
}
static Method* findMethod(Env* env, Class* clazz, const char* name, const char* desc) {
Method* method = bugvmGetMethods(env, clazz);
if (bugvmExceptionCheck(env)) return NULL;
for (; method != NULL; method = method->next) {
if (!strcmp(method->name, name) && !strcmp(method->desc, desc)) {
return method;
}
}
return NULL;
}
static Method* getMethod(Env* env, Class* clazz, const char* name, const char* desc) {
if (!strcmp("<init>", name) || !strcmp("<clinit>", name)) {
// Constructors and static initializers are not inherited so we shouldn't check with the superclasses.
return findMethod(env, clazz, name, desc);
}
Class* c = clazz;
for (c = clazz; c != NULL; c = c->superclass) {
Method* method = findMethod(env, c, name, desc);
if (bugvmExceptionCheck(env)) return NULL;
if (method) return method;
}
/*
* Check with interfaces.
* TODO: Should we really do this? Does the JNI GetMethodID() function do this?
*/
for (c = clazz; c != NULL; c = c->superclass) {
Interface* interfaze = bugvmGetInterfaces(env, c);
if (bugvmExceptionCheck(env)) return NULL;
for (; interfaze != NULL; interfaze = interfaze->next) {
Method* method = getMethod(env, interfaze->interfaze, name, desc);
if (bugvmExceptionCheck(env)) return NULL;
if (method) return method;
}
}
if (CLASS_IS_INTERFACE(clazz)) {
/*
* Class is an interface so check with java.lang.Object.
* TODO: Should we really do this? Does the JNI GetMethodID() function do this?
*/
return getMethod(env, java_lang_Object, name, desc);
}
return NULL;
}
jboolean bugvmInitMethods(Env* env) {
if (bugvmInitMutex(&nativeLibsLock) != 0) {
return FALSE;
}
if (bugvmInitMutex(&threadStackTraceLock) != 0) {
return FALSE;
}
java_lang_StackTraceElement = bugvmFindClassUsingLoader(env, "java/lang/StackTraceElement", NULL);
if (!java_lang_StackTraceElement) {
return FALSE;
}
java_lang_StackTraceElement_constructor = bugvmGetInstanceMethod(env, java_lang_StackTraceElement, "<init>",
"(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;I)V");
if (!java_lang_StackTraceElement_constructor) {
return FALSE;
}
empty_java_lang_StackTraceElement_array = bugvmNewObjectArray(env, 0, java_lang_StackTraceElement, NULL, NULL);
if (!empty_java_lang_StackTraceElement_array) {
return FALSE;
}
if (!bugvmAddGlobalRef(env, (Object*) empty_java_lang_StackTraceElement_array)) {
return FALSE;
}
return TRUE;
}
jboolean bugvmHasMethod(Env* env, Class* clazz, const char* name, const char* desc) {
Method* method = getMethod(env, clazz, name, desc);
if (bugvmExceptionCheck(env)) return FALSE;
return method ? TRUE : FALSE;
}
Method* bugvmGetMethod(Env* env, Class* clazz, const char* name, const char* desc) {
Method* method = getMethod(env, clazz, name, desc);
if (bugvmExceptionCheck(env)) return NULL;
if (!method) {
bugvmThrowNoSuchMethodError(env, name);
return NULL;
}
return method;
}
Method* bugvmGetClassMethod(Env* env, Class* clazz, const char* name, const char* desc) {
Method* method = bugvmGetMethod(env, clazz, name, desc);
if (!method) return NULL;
if (!METHOD_IS_STATIC(method)) {
// TODO: JNI spec doesn't say anything about throwing this
bugvmThrowIncompatibleClassChangeErrorMethod(env, clazz, name, desc);
return NULL;
}
return method;
}
Method* bugvmGetClassInitializer(Env* env, Class* clazz) {
return getMethod(env, clazz, "<clinit>", "()V");
}
Method* bugvmGetInstanceMethod(Env* env, Class* clazz, const char* name, const char* desc) {
Method* method = bugvmGetMethod(env, clazz, name, desc);
if (!method) return NULL;
if (METHOD_IS_STATIC(method)) {
// TODO: JNI spec doesn't say anything about throwing this
bugvmThrowIncompatibleClassChangeErrorMethod(env, clazz, name, desc);
return NULL;
}
return method;
}
Method* bugvmFindMethodAtAddress(Env* env, void* address) {
Class* clazz = env->vm->options->findClassAt(env, address);
if (!clazz) return NULL;
Method* method = bugvmGetMethods(env, clazz);
if (bugvmExceptionCheck(env)) return NULL;
for (; method != NULL; method = method->next) {
void* start = method->impl;
void* end = start + method->size;
if (start && address >= start && address < end) {
return method;
}
}
// TODO: We should never end up here
return NULL;
}
static jboolean getCallingMethodIterator(Env* env, void* pc, void* fp, ProxyMethod* proxyMethod, void* data) {
Method** result = data;
Method* method = bugvmFindMethodAtAddress(env, pc);
if (method) {
*result = method;
return FALSE; // Stop iterating
}
return TRUE;
}
Method* bugvmGetCallingMethod(Env* env) {
Method* result = NULL;
unwindIterateCallStack(env, NULL, getCallingMethodIterator, &result);
return result;
}
static jboolean captureCallStackCountFramesIterator(Env* env, void* pc, void* fp, ProxyMethod* proxyMethod, void* data) {
jint* countPtr = (jint*) data;
*countPtr += 1;
return *countPtr < MAX_CALL_STACK_LENGTH ? TRUE : FALSE;
}
typedef struct {
CallStack* data;
jint maxLength;
} CaptureCallStackArgs;
static jboolean captureCallStackIterator(Env* env, void* pc, void* fp, ProxyMethod* proxyMethod, void* _args) {
CaptureCallStackArgs* args = (CaptureCallStackArgs*) _args;
CallStack* data = args->data;
data->frames[data->length].pc = pc;
data->frames[data->length].fp = fp;
data->frames[data->length].method = (Method*) proxyMethod;
data->length++;
return data->length < args->maxLength ? TRUE : FALSE;
}
jint countCallStackFrames(Env* env, Frame* fp) {
jint count = 0;
unwindIterateCallStack(env, fp, captureCallStackCountFramesIterator, &count);
return count;
}
CallStack* allocateCallStackFrames(Env* env, jint maxLength) {
return bugvmAllocateMemoryAtomic(env, sizeof(CallStack) + sizeof(CallStackFrame) * maxLength);
}
void captureCallStack(Env* env, Frame* fp, CallStack* data, jint maxLength) {
CaptureCallStackArgs args = {data, maxLength};
unwindIterateCallStack(env, fp, captureCallStackIterator, &args);
}
CallStack* captureCallStackFromFrame(Env* env, Frame* fp) {
jint count = countCallStackFrames(env, fp);
if (bugvmExceptionOccurred(env)) return NULL;
CallStack* data = allocateCallStackFrames(env, count);
if (!data) return NULL;
captureCallStack(env, fp, data, count);
if (bugvmExceptionOccurred(env)) return NULL;
return data;
}
CallStack* bugvmCaptureCallStack(Env* env) {
return captureCallStackFromFrame(env, NULL);
}
CallStack* bugvmCaptureCallStackForThread(Env* env, Thread* thread) {
if (thread == env->currentThread) {
return bugvmCaptureCallStack(env);
}
// dumpThreadStackTrace() must not be called concurrently
obtainThreadStackTraceLock();
if (!shared_callStack) {
shared_callStack = bugvmAllocateMemoryAtomicUncollectable(env, sizeof(CallStack) + sizeof(CallStackFrame) * MAX_CALL_STACK_LENGTH);
if (!shared_callStack) {
releaseThreadStackTraceLock();
return NULL;
}
}
memset(shared_callStack, 0, sizeof(CallStack) + sizeof(CallStackFrame) * MAX_CALL_STACK_LENGTH);
dumpThreadStackTrace(env, thread, shared_callStack);
if (bugvmExceptionOccurred(env)) {
releaseThreadStackTraceLock();
return NULL;
}
// Make a copy of the CallStack that is just big enough
CallStack* copy = allocateCallStackFrames(env, shared_callStack->length);
if (!copy) {
releaseThreadStackTraceLock();
return NULL;
}
memcpy(copy, shared_callStack, sizeof(CallStack) + sizeof(CallStackFrame) * shared_callStack->length);
releaseThreadStackTraceLock();
return copy;
}
static inline jint getLineTableEntryB(uint8_t* table, jint index) {
return table[index];
}
static inline jint getLineTableEntryS(uint16_t* table, jint index) {
return table[index];
}
static inline jint getLineTableEntryI(jint* table, jint index) {
return table[index];
}
static inline jint getLineTableEntry(void* table, jint entrySize, jint index) {
if (entrySize == 1) {
return getLineTableEntryB((uint8_t*) table, index);
} else if (entrySize == 2) {
return getLineTableEntryS((uint16_t*) table, index);
}
return getLineTableEntryI((jint*) table, index);
}
static jint getLinesIndex(void* addressOffsets, jint addressOffsetSize, jint size, jint frameOffset) {
for (jint i = 0; i < size; i++) {
jint entry = getLineTableEntry(addressOffsets, addressOffsetSize, i);
if (frameOffset < entry) {
return i - 1;
}
}
return size - 1;
}
static jint getLineNumber(CallStackFrame* frame) {
if (!frame->method || !frame->method->linetable) {
return -1;
}
uint32_t* linetable = (uint32_t*) frame->method->linetable;
if (*linetable == 0xffffffff) {
return -1;
}
jint size = *linetable & 0xfffffff;
if (size == 0) {
return -1;
}
jint frameOffset = frame->pc - frame->method->impl;
jint addressOffsetSize = ((*linetable >> 30) & 0x3) + 1;
jint lineOffsetSize = ((*linetable >> 28) & 0x3) + 1;
linetable++;
jint firstLineNumber = *linetable;
if (firstLineNumber >= FIRST_NO_LINE_NUMBERS_LINE) {
return -1;
}
linetable++;
jint index = getLinesIndex(linetable, addressOffsetSize, size, frameOffset);
if (index == -1) {
return firstLineNumber;
}
uint8_t* lineOffsets = ((uint8_t*) linetable) + size * addressOffsetSize;
// Adjust lineOffsets for proper alignment
lineOffsets += (lineOffsetSize - ((ptrdiff_t) lineOffsets & (lineOffsetSize - 1))) & (lineOffsetSize - 1);
return firstLineNumber + getLineTableEntry(lineOffsets, lineOffsetSize, index);
}
CallStackFrame* bugvmResolveCallStackFrame(Env* env, CallStackFrame* frame) {
if (frame->pc == NULL && frame->method == NULL) {
// We've already tried to resolve this frame but
// it doesn't correspond to any method
return NULL;
}
if (frame->method != NULL) {
// We've already resolved this frame successfully or
// the method is a ProxyMethod so no call to bugvmFindMethodAtAddress()
// is required
return frame;
}
frame->method = bugvmFindMethodAtAddress(env, frame->pc);
if (!frame->method) {
frame->pc = NULL;
return NULL;
}
frame->lineNumber = METHOD_IS_NATIVE(frame->method) ? -2 : getLineNumber(frame);
return frame;
}
ObjectArray* bugvmCallStackToStackTraceElements(Env* env, CallStack* callStack, jint first) {
if (!callStack || callStack->length == 0) {
return empty_java_lang_StackTraceElement_array;
}
// Count the number of methods
jint index = first;
jint length = 0;
while (bugvmGetNextCallStackMethod(env, callStack, &index)) {
length++;
}
if (length == 0) {
return empty_java_lang_StackTraceElement_array;
}
ObjectArray* array = bugvmNewObjectArray(env, length, java_lang_StackTraceElement, NULL, NULL);
if (!array) return NULL;
if (length > 0) {
jvalue args[4];
index = first;
jint i;
for (i = 0; i < length; i++) {
CallStackFrame* frame = bugvmGetNextCallStackMethod(env, callStack, &index);
Method* m = frame->method;
args[0].l = (jobject) m->clazz;
args[1].l = (jobject) bugvmNewStringUTF(env, m->name, -1);
if (!args[1].l) return NULL;
args[2].l = (jobject) bugvmAttributeGetClassSourceFile(env, m->clazz);
if (bugvmExceptionOccurred(env)) {
return NULL;
}
args[3].i = frame->lineNumber;
array->values[i] = bugvmNewObjectA(env, java_lang_StackTraceElement,
java_lang_StackTraceElement_constructor, args);
if (!array->values[i]) return NULL;
}
}
return array;
}
const char* bugvmGetReturnType(const char* desc) {
while (*desc != ')') desc++;
desc++;
return desc;
}
const char* bugvmGetNextParameterType(const char** desc) {
const char* s = *desc;
(*desc)++;
switch (s[0]) {
case 'B':
case 'Z':
case 'S':
case 'C':
case 'I':
case 'J':
case 'F':
case 'D':
return s;
case '[':
bugvmGetNextParameterType(desc);
return s;
case 'L':
while (**desc != ';') (*desc)++;
(*desc)++;
return s;
case '(':
return bugvmGetNextParameterType(desc);
}
return 0;
}
jint bugvmGetParameterCount(Method* method) {
const char* desc = method->desc;
jint count = 0;
while (bugvmGetNextParameterType(&desc)) {
count++;
}
return count;
}
typedef struct {
jint ptrArgsCount, intArgsCount, longArgsCount, floatArgsCount, doubleArgsCount;
} ArgsCount;
static void countArgs(Env* env, Method* method, ArgsCount* argsCount) {
jint ptrArgsCount = 0, intArgsCount = 0, longArgsCount = 0, floatArgsCount = 0, doubleArgsCount = 0;
ptrArgsCount = 1; // First arg is always the Env*
if (!(method->access & ACC_STATIC)) {
// Non-static methods takes the receiver object (this) as arg 2
ptrArgsCount++;
}
const char* desc = method->desc;
const char* c;
while ((c = bugvmGetNextParameterType(&desc))) {
switch (c[0]) {
case 'Z':
case 'B':
case 'S':
case 'C':
case 'I':
intArgsCount++;
break;
case 'J':
longArgsCount++;
break;
case 'F':
floatArgsCount++;
break;
case 'D':
doubleArgsCount++;
break;
case 'L':
case '[':
ptrArgsCount++;
break;
}
}
argsCount->ptrArgsCount = ptrArgsCount;
argsCount->intArgsCount = intArgsCount;
argsCount->longArgsCount = longArgsCount;
argsCount->floatArgsCount = floatArgsCount;
argsCount->doubleArgsCount = doubleArgsCount;
}
static void setArgs(Env* env, Object* obj, Method* method, CallInfo* callInfo, jvalue* args) {
call0AddPtr(callInfo, env);
if (!(method->access & ACC_STATIC)) {
call0AddPtr(callInfo, obj);
}
const char* desc = method->desc;
const char* c;
jint i = 0;
while ((c = bugvmGetNextParameterType(&desc))) {
switch (c[0]) {
case 'Z':
call0AddInt(callInfo, (jint) args[i++].z);
break;
case 'B':
call0AddInt(callInfo, (jint) args[i++].b);
break;
case 'S':
call0AddInt(callInfo, (jint) args[i++].s);
break;
case 'C':
call0AddInt(callInfo, (jint) args[i++].c);
break;
case 'I':
call0AddInt(callInfo, args[i++].i);
break;
case 'J':
call0AddLong(callInfo, args[i++].j);
break;
case 'F':
call0AddFloat(callInfo, args[i++].f);
break;
case 'D':
call0AddDouble(callInfo, args[i++].d);
break;
case 'L':
case '[':
call0AddPtr(callInfo, args[i++].l);
break;
}
}
}
#define /* CallInfo* */ INIT_CALL_INFO(/* Env* */ _env, /* Object* */ _obj, /* Method* */ _method, /* jboolean */ _virtual, /* jvalue* */ _args) ({ \
CallInfo* _callInfo = NULL; \
if (_virtual && !(_method->access & ACC_PRIVATE)) { \
/* Lookup the real method to be invoked */ \
_method = bugvmGetMethod(_env, ((Object*) _obj)->clazz, _method->name, _method->desc); \
} \
if (_method) { \
ArgsCount _argsCount; \
countArgs(_env, _method, &_argsCount); \
void* _function = _method->synchronizedImpl ? _method->synchronizedImpl : _method->impl; \
_callInfo = CALL0_ALLOCATE_CALL_INFO(_env, _function, _argsCount.ptrArgsCount, _argsCount.intArgsCount, _argsCount.longArgsCount, _argsCount.floatArgsCount, _argsCount.doubleArgsCount); \
setArgs(_env, _obj, _method, _callInfo, _args); \
} \
_callInfo; \
})
static jvalue* va_list2jargs(Env* env, Method* method, va_list args) {
jint argsCount = bugvmGetParameterCount(method);
if (argsCount == 0) {
return emptyJValueArgs;
}
jvalue *jvalueArgs = (jvalue*) bugvmAllocateMemory(env, sizeof(jvalue) * argsCount);
if (!jvalueArgs) return NULL;
const char* desc = method->desc;
const char* c;
jint i = 0;
while ((c = bugvmGetNextParameterType(&desc))) {
switch (c[0]) {
case 'B':
jvalueArgs[i++].b = (jbyte) va_arg(args, jint);
break;
case 'Z':
jvalueArgs[i++].z = (jboolean) va_arg(args, jint);
break;
case 'S':
jvalueArgs[i++].s = (jshort) va_arg(args, jint);
break;
case 'C':
jvalueArgs[i++].c = (jchar) va_arg(args, jint);
break;
case 'I':
jvalueArgs[i++].i = va_arg(args, jint);
break;
case 'J':
jvalueArgs[i++].j = va_arg(args, jlong);
break;
case 'F':
jvalueArgs[i++].f = (jfloat) va_arg(args, jdouble);
break;
case 'D':
jvalueArgs[i++].d = va_arg(args, jdouble);
break;
case '[':
case 'L':
jvalueArgs[i++].l = va_arg(args, jobject);
break;
}
}
return jvalueArgs;
}
static void callVoidMethod(Env* env, CallInfo* callInfo) {
void (*f)(CallInfo*) = _call0;
bugvmPushGatewayFrame(env);
TrycatchContext tc = {0};
tc.sel = CATCH_ALL_SEL;
if (!bugvmTrycatchEnter(env, &tc)) {
f(callInfo);
}
bugvmTrycatchLeave(env);
bugvmPopGatewayFrame(env);
}
static Object* callObjectMethod(Env* env, CallInfo* callInfo) {
Object* result = NULL;
Object* (*f)(CallInfo*) = (Object* (*)(CallInfo*)) _call0;
bugvmPushGatewayFrame(env);
TrycatchContext tc = {0};
tc.sel = CATCH_ALL_SEL;
if (!bugvmTrycatchEnter(env, &tc)) {
result = f(callInfo);
}
bugvmTrycatchLeave(env);
bugvmPopGatewayFrame(env);
return result;
}
static jint callIntMethod(Env* env, CallInfo* callInfo) {
jint result = 0;
jint (*f)(CallInfo*) = (jint (*)(CallInfo*)) _call0;
bugvmPushGatewayFrame(env);
TrycatchContext tc = {0};
tc.sel = CATCH_ALL_SEL;
if (!bugvmTrycatchEnter(env, &tc)) {
result = f(callInfo);
}
bugvmTrycatchLeave(env);
bugvmPopGatewayFrame(env);
return result;
}
static jboolean callBooleanMethod(Env* env, CallInfo* callInfo) {
return ((jboolean) callIntMethod(env, callInfo)) == 0 ? FALSE : TRUE;
}
static jbyte callByteMethod(Env* env, CallInfo* callInfo) {
return (jbyte) callIntMethod(env, callInfo);
}
static jchar callCharMethod(Env* env, CallInfo* callInfo) {
return (jchar) callIntMethod(env, callInfo);
}
static jshort callShortMethod(Env* env, CallInfo* callInfo) {
return (jshort) callIntMethod(env, callInfo);
}
static jlong callLongMethod(Env* env, CallInfo* callInfo) {
jlong result = 0;
jlong (*f)(CallInfo*) = (jlong (*)(CallInfo*)) _call0;
bugvmPushGatewayFrame(env);
TrycatchContext tc = {0};
tc.sel = CATCH_ALL_SEL;
if (!bugvmTrycatchEnter(env, &tc)) {
result = f(callInfo);
}
bugvmTrycatchLeave(env);
bugvmPopGatewayFrame(env);
return result;
}
static jfloat callFloatMethod(Env* env, CallInfo* callInfo) {
jfloat result = 0;
jfloat (*f)(CallInfo*) = (jfloat (*)(CallInfo*)) _call0;
bugvmPushGatewayFrame(env);
TrycatchContext tc = {0};
tc.sel = CATCH_ALL_SEL;
if (!bugvmTrycatchEnter(env, &tc)) {
result = f(callInfo);
}
bugvmTrycatchLeave(env);
bugvmPopGatewayFrame(env);
return result;
}
static jdouble callDoubleMethod(Env* env, CallInfo* callInfo) {
jdouble result = 0;
jdouble (*f)(CallInfo*) = (jdouble (*)(CallInfo*)) _call0;
bugvmPushGatewayFrame(env);
TrycatchContext tc = {0};
tc.sel = CATCH_ALL_SEL;
if (!bugvmTrycatchEnter(env, &tc)) {
result = f(callInfo);
}
bugvmTrycatchLeave(env);
bugvmPopGatewayFrame(env);
return result;
}
void bugvmCallVoidInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
callVoidMethod(env, callInfo);
}
void bugvmCallVoidInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return;
bugvmCallVoidInstanceMethodA(env, obj, method, jargs);
}
void bugvmCallVoidInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
bugvmCallVoidInstanceMethodV(env, obj, method, args);
}
Object* bugvmCallObjectInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return NULL;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callObjectMethod(env, callInfo);
}
Object* bugvmCallObjectInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return NULL;
return bugvmCallObjectInstanceMethodA(env, obj, method, jargs);
}
Object* bugvmCallObjectInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallObjectInstanceMethodV(env, obj, method, args);
}
jboolean bugvmCallBooleanInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return FALSE;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callBooleanMethod(env, callInfo);
}
jboolean bugvmCallBooleanInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return FALSE;
return bugvmCallBooleanInstanceMethodA(env, obj, method, jargs);
}
jboolean bugvmCallBooleanInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallBooleanInstanceMethodV(env, obj, method, args);
}
jbyte bugvmCallByteInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callByteMethod(env, callInfo);
}
jbyte bugvmCallByteInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallByteInstanceMethodA(env, obj, method, jargs);
}
jbyte bugvmCallByteInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallByteInstanceMethodV(env, obj, method, args);
}
jchar bugvmCallCharInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callCharMethod(env, callInfo);
}
jchar bugvmCallCharInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallCharInstanceMethodA(env, obj, method, jargs);
}
jchar bugvmCallCharInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallCharInstanceMethodV(env, obj, method, args);
}
jshort bugvmCallShortInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callShortMethod(env, callInfo);
}
jshort bugvmCallShortInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallShortInstanceMethodA(env, obj, method, jargs);
}
jshort bugvmCallShortInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallShortInstanceMethodV(env, obj, method, args);
}
jint bugvmCallIntInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callIntMethod(env, callInfo);
}
jint bugvmCallIntInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallIntInstanceMethodA(env, obj, method, jargs);
}
jint bugvmCallIntInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallIntInstanceMethodV(env, obj, method, args);
}
jlong bugvmCallLongInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callLongMethod(env, callInfo);
}
jlong bugvmCallLongInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallLongInstanceMethodA(env, obj, method, jargs);
}
jlong bugvmCallLongInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallLongInstanceMethodV(env, obj, method, args);
}
jfloat bugvmCallFloatInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return 0.0f;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callFloatMethod(env, callInfo);
}
jfloat bugvmCallFloatInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0.0f;
return bugvmCallFloatInstanceMethodA(env, obj, method, jargs);
}
jfloat bugvmCallFloatInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallFloatInstanceMethodV(env, obj, method, args);
}
jdouble bugvmCallDoubleInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, TRUE, args);
if (!callInfo) return 0.0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callDoubleMethod(env, callInfo);
}
jdouble bugvmCallDoubleInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0.0;
return bugvmCallDoubleInstanceMethodA(env, obj, method, jargs);
}
jdouble bugvmCallDoubleInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallDoubleInstanceMethodV(env, obj, method, args);
}
void bugvmCallNonvirtualVoidInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
callVoidMethod(env, callInfo);
}
void bugvmCallNonvirtualVoidInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return;
bugvmCallNonvirtualVoidInstanceMethodA(env, obj, method, jargs);
}
void bugvmCallNonvirtualVoidInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
bugvmCallNonvirtualVoidInstanceMethodV(env, obj, method, args);
}
Object* bugvmCallNonvirtualObjectInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return NULL;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callObjectMethod(env, callInfo);
}
Object* bugvmCallNonvirtualObjectInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return NULL;
return bugvmCallNonvirtualObjectInstanceMethodA(env, obj, method, jargs);
}
Object* bugvmCallNonvirtualObjectInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallNonvirtualObjectInstanceMethodV(env, obj, method, args);
}
jboolean bugvmCallNonvirtualBooleanInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return FALSE;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callBooleanMethod(env, callInfo);
}
jboolean bugvmCallNonvirtualBooleanInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return FALSE;
return bugvmCallNonvirtualBooleanInstanceMethodA(env, obj, method, jargs);
}
jboolean bugvmCallNonvirtualBooleanInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallNonvirtualBooleanInstanceMethodV(env, obj, method, args);
}
jbyte bugvmCallNonvirtualByteInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callByteMethod(env, callInfo);
}
jbyte bugvmCallNonvirtualByteInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallNonvirtualByteInstanceMethodA(env, obj, method, jargs);
}
jbyte bugvmCallNonvirtualByteInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallNonvirtualByteInstanceMethodV(env, obj, method, args);
}
jchar bugvmCallNonvirtualCharInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callCharMethod(env, callInfo);
}
jchar bugvmCallNonvirtualCharInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallNonvirtualCharInstanceMethodA(env, obj, method, jargs);
}
jchar bugvmCallNonvirtualCharInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallNonvirtualCharInstanceMethodV(env, obj, method, args);
}
jshort bugvmCallNonvirtualShortInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callShortMethod(env, callInfo);
}
jshort bugvmCallNonvirtualShortInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallNonvirtualShortInstanceMethodA(env, obj, method, jargs);
}
jshort bugvmCallNonvirtualShortInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallNonvirtualShortInstanceMethodV(env, obj, method, args);
}
jint bugvmCallNonvirtualIntInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callIntMethod(env, callInfo);
}
jint bugvmCallNonvirtualIntInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallNonvirtualIntInstanceMethodA(env, obj, method, jargs);
}
jint bugvmCallNonvirtualIntInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallNonvirtualIntInstanceMethodV(env, obj, method, args);
}
jlong bugvmCallNonvirtualLongInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return 0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callLongMethod(env, callInfo);
}
jlong bugvmCallNonvirtualLongInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallNonvirtualLongInstanceMethodA(env, obj, method, jargs);
}
jlong bugvmCallNonvirtualLongInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallNonvirtualLongInstanceMethodV(env, obj, method, args);
}
jfloat bugvmCallNonvirtualFloatInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return 0.0f;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callFloatMethod(env, callInfo);
}
jfloat bugvmCallNonvirtualFloatInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0.0f;
return bugvmCallNonvirtualFloatInstanceMethodA(env, obj, method, jargs);
}
jfloat bugvmCallNonvirtualFloatInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallNonvirtualFloatInstanceMethodV(env, obj, method, args);
}
jdouble bugvmCallNonvirtualDoubleInstanceMethodA(Env* env, Object* obj, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, obj, method, FALSE, args);
if (!callInfo) return 0.0;
if (obj && CLASS_IS_PROXY(obj->clazz)) {
env->reserved0 = (void*) method->name;
env->reserved1 = (void*) method->desc;
}
return callDoubleMethod(env, callInfo);
}
jdouble bugvmCallNonvirtualDoubleInstanceMethodV(Env* env, Object* obj, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0.0;
return bugvmCallNonvirtualDoubleInstanceMethodA(env, obj, method, jargs);
}
jdouble bugvmCallNonvirtualDoubleInstanceMethod(Env* env, Object* obj, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallNonvirtualDoubleInstanceMethodV(env, obj, method, args);
}
void bugvmCallVoidClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return;
callVoidMethod(env, callInfo);
}
void bugvmCallVoidClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return;
bugvmCallVoidClassMethodA(env, clazz, method, jargs);
}
void bugvmCallVoidClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
bugvmCallVoidClassMethodV(env, clazz, method, args);
}
Object* bugvmCallObjectClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return NULL;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return NULL;
return callObjectMethod(env, callInfo);
}
Object* bugvmCallObjectClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return NULL;
return bugvmCallObjectClassMethodA(env, clazz, method, jargs);
}
Object* bugvmCallObjectClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallObjectClassMethodV(env, clazz, method, args);
}
jboolean bugvmCallBooleanClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return FALSE;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return FALSE;
return callBooleanMethod(env, callInfo);
}
jboolean bugvmCallBooleanClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return FALSE;
return bugvmCallBooleanClassMethodA(env, clazz, method, jargs);
}
jboolean bugvmCallBooleanClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallBooleanClassMethodV(env, clazz, method, args);
}
jbyte bugvmCallByteClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return 0;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return 0;
return callByteMethod(env, callInfo);
}
jbyte bugvmCallByteClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallByteClassMethodA(env, clazz, method, jargs);
}
jbyte bugvmCallByteClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallByteClassMethodV(env, clazz, method, args);
}
jchar bugvmCallCharClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return 0;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return 0;
return callCharMethod(env, callInfo);
}
jchar bugvmCallCharClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallCharClassMethodA(env, clazz, method, jargs);
}
jchar bugvmCallCharClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallCharClassMethodV(env, clazz, method, args);
}
jshort bugvmCallShortClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return 0;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return 0;
return callShortMethod(env, callInfo);
}
jshort bugvmCallShortClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallShortClassMethodA(env, clazz, method, jargs);
}
jshort bugvmCallShortClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallShortClassMethodV(env, clazz, method, args);
}
jint bugvmCallIntClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return 0;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return 0;
return callIntMethod(env, callInfo);
}
jint bugvmCallIntClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallIntClassMethodA(env, clazz, method, jargs);
}
jint bugvmCallIntClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallIntClassMethodV(env, clazz, method, args);
}
jlong bugvmCallLongClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return 0;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return 0;
return callLongMethod(env, callInfo);
}
jlong bugvmCallLongClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0;
return bugvmCallLongClassMethodA(env, clazz, method, jargs);
}
jlong bugvmCallLongClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallLongClassMethodV(env, clazz, method, args);
}
jfloat bugvmCallFloatClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return 0.0f;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return 0.0f;
return callFloatMethod(env, callInfo);
}
jfloat bugvmCallFloatClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0.0f;
return bugvmCallFloatClassMethodA(env, clazz, method, jargs);
}
jfloat bugvmCallFloatClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallFloatClassMethodV(env, clazz, method, args);
}
jdouble bugvmCallDoubleClassMethodA(Env* env, Class* clazz, Method* method, jvalue* args) {
CallInfo* callInfo = INIT_CALL_INFO(env, NULL, method, FALSE, args);
if (!callInfo) return 0.0;
bugvmInitialize(env, method->clazz);
if (bugvmExceptionOccurred(env)) return 0.0;
return callDoubleMethod(env, callInfo);
}
jdouble bugvmCallDoubleClassMethodV(Env* env, Class* clazz, Method* method, va_list args) {
jvalue* jargs = va_list2jargs(env, method, args);
if (!jargs) return 0.0;
return bugvmCallDoubleClassMethodA(env, clazz, method, jargs);
}
jdouble bugvmCallDoubleClassMethod(Env* env, Class* clazz, Method* method, ...) {
va_list args;
va_start(args, method);
return bugvmCallDoubleClassMethodV(env, clazz, method, args);
}
jboolean bugvmRegisterNative(Env* env, NativeMethod* method, void* impl) {
method->nativeImpl = impl;
return TRUE;
}
jboolean bugvmUnregisterNative(Env* env, NativeMethod* method) {
method->nativeImpl = NULL;
return TRUE;
}
void* bugvmResolveNativeMethodImpl(Env* env, NativeMethod* method, const char* shortMangledName, const char* longMangledName, Object* classLoader, void** ptr) {
void* f = method->nativeImpl;
if (!f) {
DynamicLib* nativeLibs = NULL;
if (!classLoader || bugvmGetParentClassLoader(env, classLoader) == NULL) {
// This is the bootstrap classloader
nativeLibs = bootNativeLibs;
} else if (bugvmGetParentParentClassLoader(env, classLoader) == NULL && classLoader->clazz->classLoader == NULL) {
// This is the system classloader
nativeLibs = mainNativeLibs;
} else {
// Unknown classloader
bugvmThrowUnsatisfiedLinkError(env, "Unknown classloader");
return NULL;
}
obtainNativeLibsLock();
TRACEF("Searching for native method using short name: %s", shortMangledName);
f = bugvmFindDynamicLibSymbol(env, nativeLibs, shortMangledName, TRUE);
if (f) {
TRACEF("Found native method using short name: %s", shortMangledName);
} else if (strcmp(shortMangledName, longMangledName)) {
TRACEF("Searching for native method using long name: %s", longMangledName);
f = bugvmFindDynamicLibSymbol(env, nativeLibs, longMangledName, TRUE);
if (f) {
TRACEF("Found native method using long name: %s", longMangledName);
}
}
method->nativeImpl = f;
releaseNativeLibsLock();
}
if (!f) {
char* className = bugvmToBinaryClassName(env, method->method.clazz->name);
if (className) {
bugvmThrowNewf(env, java_lang_UnsatisfiedLinkError, "%s.%s%s", className, method->method.name, method->method.desc);
}
return NULL;
}
// TODO: Remember ptr to allow it to be reset when the JNI RegisterNatives/UnregisterNatives functions are called
*ptr = f;
return f;
}
jboolean bugvmLoadNativeLibrary(Env* env, const char* path, Object* classLoader) {
DynamicLib** nativeLibs = NULL;
if (!classLoader || bugvmGetParentClassLoader(env, classLoader) == NULL) {
// This is the bootstrap classloader
nativeLibs = &bootNativeLibs;
} else if (bugvmGetParentParentClassLoader(env, classLoader) == NULL && classLoader->clazz->classLoader == NULL) {
// This is the system classloader
nativeLibs = &mainNativeLibs;
} else {
// Unknown classloader
bugvmThrowUnsatisfiedLinkError(env, "Unknown classloader");
return FALSE;
}
char* errorMsg = NULL;
DynamicLib* lib = bugvmOpenDynamicLib(env, path, &errorMsg);
if (!lib) {
if (!bugvmExceptionOccurred(env)) {
bugvmThrowUnsatisfiedLinkError(env, errorMsg);
}
return FALSE;
}
obtainNativeLibsLock();
if (bugvmHasDynamicLib(env, lib, *nativeLibs)) {
// The lib is already in nativeLibs
bugvmCloseDynamicLib(env, lib);
releaseNativeLibsLock();
return TRUE;
}
jint (*JNI_OnLoad)(JavaVM*, void*) = bugvmFindDynamicLibSymbol(env, lib, "JNI_OnLoad", FALSE);
if (JNI_OnLoad) {
// TODO: Check that JNI_OnLoad returns a supported JNI version?
JNI_OnLoad(&env->vm->javaVM, NULL);
if (bugvmExceptionOccurred(env)) {
releaseNativeLibsLock();
return FALSE;
}
}
bugvmAddDynamicLib(env, lib, nativeLibs);
releaseNativeLibsLock();
return TRUE;
}
| 34.807666 | 195 | 0.667125 | [
"object"
] |
43da229bcea41651ebb27a903617accc83f1e17a | 3,840 | h | C | common_classes/vertexBufferObject.h | talkad/animation3D | 44213fe19a1d3c25793de29ce63fcea96c5b8f41 | [
"Apache-2.0"
] | 2 | 2021-12-24T21:06:45.000Z | 2021-12-25T09:42:06.000Z | common_classes/vertexBufferObject.h | talkad/animation3D | 44213fe19a1d3c25793de29ce63fcea96c5b8f41 | [
"Apache-2.0"
] | null | null | null | common_classes/vertexBufferObject.h | talkad/animation3D | 44213fe19a1d3c25793de29ce63fcea96c5b8f41 | [
"Apache-2.0"
] | null | null | null | #pragma once
// STL
#include <vector>
// GLAD
#include <glad/glad.h>
/**
* Wraps OpenGL's vertex buffer object to a convenient higher level class.
*/
class VertexBufferObject
{
public:
/**
* Creates a new VBO, with optional reserved buffer size.
*
* @param reserveSizeBytes Buffer size reservation, in bytes (so that no memory allocations happen while preparing buffer data)
*/
void createVBO(size_t reserveSizeBytes = 0);
/**
* Binds this vertex buffer object (makes current).
*
* @param bufferType Type of the bound buffer (usually GL_ARRAY_BUFFER, but can be also GL_ELEMENT_BUFFER for instance)
*/
void bindVBO(GLenum bufferType = GL_ARRAY_BUFFER);
/**
* Adds raw data to the in-memory buffer, before they get uploaded.
*
* @param ptrData Pointer to the raw data (arbitrary type)
* @param dataSizeBytes Size of the added data (in bytes)
* @param repeat How many times to repeat same data in the buffer (default is 1)
*/
void addRawData(const void* ptrData, size_t dataSizeBytes, size_t repeat = 1);
/**
* Adds arbitrary data to the in-memory buffer, before they get uploaded.
*
* @param ptrObj Pointer to trivial object (sizeof which can be determined with sizeof)
* @param repeat How many times to repeat same data in the buffer (default is 1)
*/
template<typename T>
void addData(const T& ptrObj, size_t repeat = 1)
{
addRawData(&ptrObj, static_cast<size_t>(sizeof(T)), repeat);
}
/**
* Gets pointer to the raw data from in-memory buffer (only before uploading them).
*/
void* getRawDataPointer();
/**
* Uploads gathered data to the GPU memory. Now the VBO is ready to be used.
*
* @param usageHint Hint for OpenGL, how is the data intended to be used (GL_STATIC_DRAW, GL_DYNAMIC_DRAW)
*/
void uploadDataToGPU(GLenum usageHint);
/**
* Maps buffer data to a memory pointer.
*
* @param usageHint Hint for OpenGL, how is the data intended to be used (GL_STATIC_DRAW, GL_DYNAMIC_DRAW)
*
* @return Pointer to the mapped data, or nullptr, if something fails.
*/
void* mapBufferToMemory(GLenum usageHint) const;
/**
* Maps buffer sub-data to a memory pointer.
*
* @param usageHint Hint for OpenGL, how is the data intended to be used (GL_READ_ONLY, GL_WRITE_ONLY...`)
* @param offset Byte offset in buffer where to start
* @param length Byte length of the mapped data
*
* @return Pointer to the mapped data, or nullptr, if something fails.
*/
void* mapSubBufferToMemory(GLenum usageHint, size_t offset, size_t length) const;
/**
* Unmaps buffer from memory (must have been mapped previously).
*/
void unmapBuffer() const;
/**
* Gets OpenGL-assigned buffer ID.
*/
GLuint getBufferID() const;
/**
* Gets buffer size (in bytes).
*/
size_t getBufferSize();
/**
* Deletes VBO and frees memory and internal structures.
*/
void deleteVBO();
private:
GLuint bufferID_{ 0 }; // OpenGL assigned buffer ID
GLenum bufferType_{ 0 }; // Buffer type (GL_ARRAY_BUFFER, GL_ELEMENT_BUFFER...)
std::vector<unsigned char> rawData_; // In-memory raw data buffer, used to gather the data for VBO
size_t bytesAdded_{ 0 }; // Number of bytes added to the buffer so far
size_t uploadedDataSize_{ 0 }; // Holds buffer data size after uploading to GPU (if it's not null, then data have been uploaded)
/**
* Checks if the buffer has been created and has OpenGL-assigned ID.
*/
bool isBufferCreated() const;
/**
* Checks if the the data has been uploaded to the buffer already.
*/
bool isDataUploaded() const;
}; | 32.268908 | 132 | 0.655469 | [
"object",
"vector"
] |
43e631dd3162bef7dd68573d1658f3a719a59a5c | 1,274 | h | C | Engine/Source/Editor/AudioEditor/Classes/Factories/DialogueWaveFactory.h | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | 1 | 2022-01-29T18:36:12.000Z | 2022-01-29T18:36:12.000Z | Engine/Source/Editor/AudioEditor/Classes/Factories/DialogueWaveFactory.h | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | Engine/Source/Editor/AudioEditor/Classes/Factories/DialogueWaveFactory.h | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
//~=============================================================================
// DialogueWaveFactory
//~=============================================================================
#pragma once
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Factories/Factory.h"
#include "DialogueWaveFactory.generated.h"
class UDialogueVoice;
UCLASS(hidecategories=Object, MinimalAPI)
class UDialogueWaveFactory : public UFactory
{
GENERATED_UCLASS_BODY()
//~ Begin UFactory Interface
virtual UObject* FactoryCreateNew(UClass* Class,UObject* InParent,FName Name,EObjectFlags Flags,UObject* Context,FFeedbackContext* Warn) override;
//~ Begin UFactory Interface
/** An initial sound wave to place in the newly created dialogue wave */
UPROPERTY()
class USoundWave* InitialSoundWave;
/** An initial speaking dialogue voice to place in the newly created dialogue wave */
UPROPERTY()
class UDialogueVoice* InitialSpeakerVoice;
/** Whether an initial target dialogue voice should be set */
UPROPERTY()
bool HasSetInitialTargetVoice;
/** An initial target dialogue voices to place in the newly created dialogue wave */
UPROPERTY()
TArray<UDialogueVoice*> InitialTargetVoices;
};
| 28.954545 | 147 | 0.680534 | [
"object"
] |
43ea3700999c2aa99e6541cbaf824f0ef70fbebc | 1,028 | h | C | Maple/cameraclass.h | mld2443/DX12-Samples | 28fcd7ce82b659c2a2ab3a5eb3967606f6ce30b8 | [
"MIT"
] | null | null | null | Maple/cameraclass.h | mld2443/DX12-Samples | 28fcd7ce82b659c2a2ab3a5eb3967606f6ce30b8 | [
"MIT"
] | null | null | null | Maple/cameraclass.h | mld2443/DX12-Samples | 28fcd7ce82b659c2a2ab3a5eb3967606f6ce30b8 | [
"MIT"
] | null | null | null | ////////////////////////////////////////////////////////////////////////////////
// Filename: cameraclass.h
////////////////////////////////////////////////////////////////////////////////
#pragma once
//////////////
// INCLUDES //
//////////////
#include <directxmath.h>
///////////////
// CONSTANTS //
///////////////
#define PI_180 0.0174532925f
using namespace DirectX;
////////////////////////////////////////////////////////////////////////////////
// Class name: CameraClass
////////////////////////////////////////////////////////////////////////////////
class CameraClass
{
public:
CameraClass();
CameraClass(const CameraClass&);
~CameraClass();
void SetPosition(float, float, float);
void SetLookDirection(float, float, float);
void SetRotation(float, float, float);
XMFLOAT3 GetPosition();
XMFLOAT3 GetLookDirection();
XMFLOAT3 GetRotation();
void Render();
void GetViewMatrix(XMMATRIX&);
private:
XMFLOAT3 m_position;
XMFLOAT3 m_lookDirection;
XMFLOAT3 m_rotation;
XMMATRIX m_viewMatrix;
};
| 21.87234 | 80 | 0.466926 | [
"render"
] |
43eb31365ed10059bb6e1147af197ed54550e6c5 | 68,397 | c | C | include/sysdeps/posix/getaddrinfo.c | abhijeetviswam/libucresolv | f4911dcf4d9b5410a423970d698ac98ac071a413 | [
"Apache-2.0"
] | 1 | 2019-02-02T05:08:01.000Z | 2019-02-02T05:08:01.000Z | include/sysdeps/posix/getaddrinfo.c | DalavanCloud/libucresolv | 04a4827aa44c47556f425a4eed5e0ab4a5c0d25a | [
"Apache-2.0"
] | 3 | 2019-07-12T00:44:18.000Z | 2020-12-07T17:32:23.000Z | include/sysdeps/posix/getaddrinfo.c | DalavanCloud/libucresolv | 04a4827aa44c47556f425a4eed5e0ab4a5c0d25a | [
"Apache-2.0"
] | 7 | 2017-07-04T10:52:39.000Z | 2019-02-28T08:37:16.000Z | /* Host and service name lookups using Name Service Switch modules.
Copyright (C) 1996-2017 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
/* The Inner Net License, Version 2.00
The author(s) grant permission for redistribution and use in source and
binary forms, with or without modification, of the software and documentation
provided that the following conditions are met:
0. If you receive a version of the software that is specifically labelled
as not being for redistribution (check the version message and/or README),
you are not permitted to redistribute that version of the software in any
way or form.
1. All terms of the all other applicable copyrights and licenses must be
followed.
2. Redistributions of source code must retain the authors' copyright
notice(s), this list of conditions, and the following disclaimer.
3. Redistributions in binary form must reproduce the authors' copyright
notice(s), this list of conditions, and the following disclaimer in the
documentation and/or other materials provided with the distribution.
4. [The copyright holder has authorized the removal of this clause.]
5. Neither the name(s) of the author(s) nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY ITS AUTHORS AND CONTRIBUTORS ``AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
If these license terms cause you a real problem, contact the author. */
/* This software is Copyright 1996 by Craig Metz, All Rights Reserved. */
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <ifaddrs.h>
#include <netdb.h>
#include <nss.h>
#include <resolv/resolv-internal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <sys/utsname.h>
#include <unistd.h>
#include <nsswitch.h>
#include <libc-lock.h>
#include <not-cancel.h>
#include <nscd/nscd-client.h>
#include <nscd/nscd_proto.h>
#include <resolv/res_hconf.h>
#include <scratch_buffer.h>
#include <inet/net-internal.h>
#ifdef HAVE_LIBIDN
extern int __idna_to_ascii_lz (const char *input, char **output, int flags);
extern int __idna_to_unicode_lzlz (const char *input, char **output,
int flags);
# include <libidn/idna.h>
#endif
struct gaih_service
{
const char *name;
int num;
};
struct gaih_servtuple
{
struct gaih_servtuple *next;
int socktype;
int protocol;
int port;
};
static const struct gaih_servtuple nullserv;
struct gaih_typeproto
{
int socktype;
int protocol;
uint8_t protoflag;
bool defaultflag;
char name[8];
};
/* Values for `protoflag'. */
#define GAI_PROTO_NOSERVICE 1
#define GAI_PROTO_PROTOANY 2
static const struct gaih_typeproto gaih_inet_typeproto[] =
{
{ 0, 0, 0, false, "" },
{ SOCK_STREAM, IPPROTO_TCP, 0, true, "tcp" },
{ SOCK_DGRAM, IPPROTO_UDP, 0, true, "udp" },
#if defined SOCK_DCCP && defined IPPROTO_DCCP
{ SOCK_DCCP, IPPROTO_DCCP, 0, false, "dccp" },
#endif
#ifdef IPPROTO_UDPLITE
{ SOCK_DGRAM, IPPROTO_UDPLITE, 0, false, "udplite" },
#endif
#ifdef IPPROTO_SCTP
{ SOCK_STREAM, IPPROTO_SCTP, 0, false, "sctp" },
{ SOCK_SEQPACKET, IPPROTO_SCTP, 0, false, "sctp" },
#endif
{ SOCK_RAW, 0, GAI_PROTO_PROTOANY|GAI_PROTO_NOSERVICE, true, "raw" },
{ 0, 0, 0, false, "" }
};
static const struct addrinfo default_hints =
{
.ai_flags = AI_DEFAULT,
.ai_family = PF_UNSPEC,
.ai_socktype = 0,
.ai_protocol = 0,
.ai_addrlen = 0,
.ai_addr = NULL,
.ai_canonname = NULL,
.ai_next = NULL
};
static int
gaih_inet_serv (const char *servicename, const struct gaih_typeproto *tp,
const struct addrinfo *req, struct gaih_servtuple *st,
struct scratch_buffer *tmpbuf)
{
struct servent *s;
struct servent ts;
int r;
do
{
r = __getservbyname_r (servicename, tp->name, &ts,
tmpbuf->data, tmpbuf->length, &s);
if (r != 0 || s == NULL)
{
if (r == ERANGE)
{
if (!scratch_buffer_grow (tmpbuf))
return -EAI_MEMORY;
}
else
return -EAI_SERVICE;
}
}
while (r);
st->next = NULL;
st->socktype = tp->socktype;
st->protocol = ((tp->protoflag & GAI_PROTO_PROTOANY)
? req->ai_protocol : tp->protocol);
st->port = s->s_port;
return 0;
}
/* Convert struct hostent to a list of struct gaih_addrtuple objects.
h_name is not copied, and the struct hostent object must not be
deallocated prematurely. *RESULT must be NULL or a pointer to an
object allocated using malloc, which is freed. */
static bool
convert_hostent_to_gaih_addrtuple (const struct addrinfo *req,
int family,
struct hostent *h,
struct gaih_addrtuple **result)
{
free (*result);
*result = NULL;
/* Count the number of addresses in h->h_addr_list. */
size_t count = 0;
for (char **p = h->h_addr_list; *p != NULL; ++p)
++count;
/* Report no data if no addresses are available, or if the incoming
address size is larger than what we can store. */
if (count == 0 || h->h_length > sizeof (((struct gaih_addrtuple) {}).addr))
return true;
struct gaih_addrtuple *array = calloc (count, sizeof (*array));
if (array == NULL)
return false;
for (size_t i = 0; i < count; ++i)
{
if (family == AF_INET && req->ai_family == AF_INET6)
{
/* Perform address mapping. */
array[i].family = AF_INET6;
memcpy(array[i].addr + 3, h->h_addr_list[i], sizeof (uint32_t));
array[i].addr[2] = htonl (0xffff);
}
else
{
array[i].family = family;
memcpy (array[i].addr, h->h_addr_list[i], h->h_length);
}
array[i].next = array + i + 1;
}
array[0].name = h->h_name;
array[count - 1].next = NULL;
*result = array;
return true;
}
#define gethosts(_family, _type) \
{ \
int herrno; \
struct hostent th; \
struct hostent *h; \
char *localcanon = NULL; \
no_data = 0; \
while (1) { \
rc = 0; \
status = DL_CALL_FCT (fct, (name, _family, &th, \
tmpbuf->data, tmpbuf->length, \
&rc, &herrno, NULL, &localcanon)); \
if (rc != ERANGE || herrno != NETDB_INTERNAL) \
break; \
if (!scratch_buffer_grow (tmpbuf)) \
{ \
result = -EAI_MEMORY; \
goto free_and_return; \
} \
} \
if (status == NSS_STATUS_SUCCESS && rc == 0) \
h = &th; \
else \
h = NULL; \
if (rc != 0) \
{ \
if (herrno == NETDB_INTERNAL) \
{ \
__set_h_errno (herrno); \
_res.options |= old_res_options & DEPRECATED_RES_USE_INET6; \
result = -EAI_SYSTEM; \
goto free_and_return; \
} \
if (herrno == TRY_AGAIN) \
no_data = EAI_AGAIN; \
else \
no_data = herrno == NO_DATA; \
} \
else if (h != NULL) \
{ \
/* Make sure that addrmem can be freed. */ \
if (!malloc_addrmem) \
addrmem = NULL; \
if (!convert_hostent_to_gaih_addrtuple (req, _family,h, &addrmem)) \
{ \
_res.options |= old_res_options & DEPRECATED_RES_USE_INET6; \
result = -EAI_SYSTEM; \
goto free_and_return; \
} \
*pat = addrmem; \
/* The conversion uses malloc unconditionally. */ \
malloc_addrmem = true; \
\
if (localcanon != NULL && canon == NULL) \
canon = strdupa (localcanon); \
\
if (_family == AF_INET6 && *pat != NULL) \
got_ipv6 = true; \
} \
}
typedef enum nss_status (*nss_gethostbyname4_r)
(const char *name, struct gaih_addrtuple **pat,
char *buffer, size_t buflen, int *errnop,
int *h_errnop, int32_t *ttlp);
typedef enum nss_status (*nss_gethostbyname3_r)
(const char *name, int af, struct hostent *host,
char *buffer, size_t buflen, int *errnop,
int *h_errnop, int32_t *ttlp, char **canonp);
typedef enum nss_status (*nss_getcanonname_r)
(const char *name, char *buffer, size_t buflen, char **result,
int *errnop, int *h_errnop);
extern service_user *__nss_hosts_database attribute_hidden;
static int
gaih_inet (const char *name, const struct gaih_service *service,
const struct addrinfo *req, struct addrinfo **pai,
unsigned int *naddrs, struct scratch_buffer *tmpbuf)
{
const struct gaih_typeproto *tp = gaih_inet_typeproto;
struct gaih_servtuple *st = (struct gaih_servtuple *) &nullserv;
struct gaih_addrtuple *at = NULL;
int rc;
bool got_ipv6 = false;
const char *canon = NULL;
const char *orig_name = name;
/* Reserve stack memory for the scratch buffer in the getaddrinfo
function. */
size_t alloca_used = sizeof (struct scratch_buffer);
if (req->ai_protocol || req->ai_socktype)
{
++tp;
while (tp->name[0]
&& ((req->ai_socktype != 0 && req->ai_socktype != tp->socktype)
|| (req->ai_protocol != 0
&& !(tp->protoflag & GAI_PROTO_PROTOANY)
&& req->ai_protocol != tp->protocol)))
++tp;
if (! tp->name[0])
{
if (req->ai_socktype)
return -EAI_SOCKTYPE;
else
return -EAI_SERVICE;
}
}
int port = 0;
if (service != NULL)
{
if ((tp->protoflag & GAI_PROTO_NOSERVICE) != 0)
return -EAI_SERVICE;
if (service->num < 0)
{
if (tp->name[0])
{
st = (struct gaih_servtuple *)
alloca_account (sizeof (struct gaih_servtuple), alloca_used);
if ((rc = gaih_inet_serv (service->name, tp, req, st, tmpbuf)))
return rc;
}
else
{
struct gaih_servtuple **pst = &st;
for (tp++; tp->name[0]; tp++)
{
struct gaih_servtuple *newp;
if ((tp->protoflag & GAI_PROTO_NOSERVICE) != 0)
continue;
if (req->ai_socktype != 0
&& req->ai_socktype != tp->socktype)
continue;
if (req->ai_protocol != 0
&& !(tp->protoflag & GAI_PROTO_PROTOANY)
&& req->ai_protocol != tp->protocol)
continue;
newp = (struct gaih_servtuple *)
alloca_account (sizeof (struct gaih_servtuple),
alloca_used);
if ((rc = gaih_inet_serv (service->name,
tp, req, newp, tmpbuf)))
{
if (rc)
continue;
return rc;
}
*pst = newp;
pst = &(newp->next);
}
if (st == (struct gaih_servtuple *) &nullserv)
return -EAI_SERVICE;
}
}
else
{
port = htons (service->num);
goto got_port;
}
}
else
{
got_port:
if (req->ai_socktype || req->ai_protocol)
{
st = alloca_account (sizeof (struct gaih_servtuple), alloca_used);
st->next = NULL;
st->socktype = tp->socktype;
st->protocol = ((tp->protoflag & GAI_PROTO_PROTOANY)
? req->ai_protocol : tp->protocol);
st->port = port;
}
else
{
/* Neither socket type nor protocol is set. Return all socket types
we know about. */
struct gaih_servtuple **lastp = &st;
for (++tp; tp->name[0]; ++tp)
if (tp->defaultflag)
{
struct gaih_servtuple *newp;
newp = alloca_account (sizeof (struct gaih_servtuple),
alloca_used);
newp->next = NULL;
newp->socktype = tp->socktype;
newp->protocol = tp->protocol;
newp->port = port;
*lastp = newp;
lastp = &newp->next;
}
}
}
bool malloc_name = false;
bool malloc_addrmem = false;
struct gaih_addrtuple *addrmem = NULL;
bool malloc_canonbuf = false;
char *canonbuf = NULL;
int result = 0;
if (name != NULL)
{
at = alloca_account (sizeof (struct gaih_addrtuple), alloca_used);
at->family = AF_UNSPEC;
at->scopeid = 0;
at->next = NULL;
#ifdef HAVE_LIBIDN
if (req->ai_flags & AI_IDN)
{
int idn_flags = 0;
if (req->ai_flags & AI_IDN_ALLOW_UNASSIGNED)
idn_flags |= IDNA_ALLOW_UNASSIGNED;
if (req->ai_flags & AI_IDN_USE_STD3_ASCII_RULES)
idn_flags |= IDNA_USE_STD3_ASCII_RULES;
char *p = NULL;
rc = __idna_to_ascii_lz (name, &p, idn_flags);
if (rc != IDNA_SUCCESS)
{
/* No need to jump to free_and_return here. */
if (rc == IDNA_MALLOC_ERROR)
return -EAI_MEMORY;
if (rc == IDNA_DLOPEN_ERROR)
return -EAI_SYSTEM;
return -EAI_IDN_ENCODE;
}
/* In case the output string is the same as the input string
no new string has been allocated. */
if (p != name)
{
name = p;
malloc_name = true;
}
}
#endif
if (__inet_aton (name, (struct in_addr *) at->addr) != 0)
{
if (req->ai_family == AF_UNSPEC || req->ai_family == AF_INET)
at->family = AF_INET;
else if (req->ai_family == AF_INET6 && (req->ai_flags & AI_V4MAPPED))
{
at->addr[3] = at->addr[0];
at->addr[2] = htonl (0xffff);
at->addr[1] = 0;
at->addr[0] = 0;
at->family = AF_INET6;
}
else
{
result = -EAI_ADDRFAMILY;
goto free_and_return;
}
if (req->ai_flags & AI_CANONNAME)
canon = name;
}
else if (at->family == AF_UNSPEC)
{
char *scope_delim = strchr (name, SCOPE_DELIMITER);
int e;
{
bool malloc_namebuf = false;
char *namebuf = (char *) name;
if (__glibc_unlikely (scope_delim != NULL))
{
if (malloc_name)
*scope_delim = '\0';
else
{
if (__libc_use_alloca (alloca_used
+ scope_delim - name + 1))
{
namebuf = alloca_account (scope_delim - name + 1,
alloca_used);
*((char *) __mempcpy (namebuf, name,
scope_delim - name)) = '\0';
}
else
{
namebuf = strndup (name, scope_delim - name);
if (namebuf == NULL)
{
assert (!malloc_name);
return -EAI_MEMORY;
}
malloc_namebuf = true;
}
}
}
e = inet_pton (AF_INET6, namebuf, at->addr);
if (malloc_namebuf)
free (namebuf);
else if (scope_delim != NULL && malloc_name)
/* Undo what we did above. */
*scope_delim = SCOPE_DELIMITER;
}
if (e > 0)
{
if (req->ai_family == AF_UNSPEC || req->ai_family == AF_INET6)
at->family = AF_INET6;
else if (req->ai_family == AF_INET
&& IN6_IS_ADDR_V4MAPPED (at->addr))
{
at->addr[0] = at->addr[3];
at->family = AF_INET;
}
else
{
result = -EAI_ADDRFAMILY;
goto free_and_return;
}
if (scope_delim != NULL
&& __inet6_scopeid_pton ((struct in6_addr *) at->addr,
scope_delim + 1,
&at->scopeid) != 0)
{
result = -EAI_NONAME;
goto free_and_return;
}
if (req->ai_flags & AI_CANONNAME)
canon = name;
}
}
if (at->family == AF_UNSPEC && (req->ai_flags & AI_NUMERICHOST) == 0)
{
struct gaih_addrtuple **pat = &at;
int no_data = 0;
int no_inet6_data = 0;
service_user *nip;
enum nss_status inet6_status = NSS_STATUS_UNAVAIL;
enum nss_status status = NSS_STATUS_UNAVAIL;
int no_more;
int old_res_options;
/* If we do not have to look for IPv6 addresses or the canonical
name, use the simple, old functions, which do not support
IPv6 scope ids, nor retrieving the canonical name. */
if (req->ai_family == AF_INET
&& (req->ai_flags & AI_CANONNAME) == 0)
{
int rc;
struct hostent th;
struct hostent *h;
int herrno;
while (1)
{
rc = __gethostbyname2_r (name, AF_INET, &th,
tmpbuf->data, tmpbuf->length,
&h, &herrno);
if (rc != ERANGE || herrno != NETDB_INTERNAL)
break;
if (!scratch_buffer_grow (tmpbuf))
{
result = -EAI_MEMORY;
goto free_and_return;
}
}
if (rc == 0)
{
if (h != NULL)
{
/* We found data, convert it. */
if (!convert_hostent_to_gaih_addrtuple
(req, AF_INET, h, &addrmem))
{
result = -EAI_MEMORY;
goto free_and_return;
}
*pat = addrmem;
/* The conversion uses malloc unconditionally. */
malloc_addrmem = true;
}
}
else
{
if (herrno == NETDB_INTERNAL)
{
__set_h_errno (herrno);
result = -EAI_SYSTEM;
}
else if (herrno == TRY_AGAIN)
result = -EAI_AGAIN;
else
/* We made requests but they turned out no data.
The name is known, though. */
result = -EAI_NODATA;
goto free_and_return;
}
goto process_list;
}
#ifdef USE_NSCD
if (__nss_not_use_nscd_hosts > 0
&& ++__nss_not_use_nscd_hosts > NSS_NSCD_RETRY)
__nss_not_use_nscd_hosts = 0;
if (!__nss_not_use_nscd_hosts
&& !__nss_database_custom[NSS_DBSIDX_hosts])
{
/* Try to use nscd. */
struct nscd_ai_result *air = NULL;
int herrno;
int err = __nscd_getai (name, &air, &herrno);
if (air != NULL)
{
/* Transform into gaih_addrtuple list. */
bool added_canon = (req->ai_flags & AI_CANONNAME) == 0;
char *addrs = air->addrs;
if (__libc_use_alloca (alloca_used
+ air->naddrs * sizeof (struct gaih_addrtuple)))
addrmem = alloca_account (air->naddrs
* sizeof (struct gaih_addrtuple),
alloca_used);
else
{
addrmem = malloc (air->naddrs
* sizeof (struct gaih_addrtuple));
if (addrmem == NULL)
{
result = -EAI_MEMORY;
goto free_and_return;
}
malloc_addrmem = true;
}
struct gaih_addrtuple *addrfree = addrmem;
for (int i = 0; i < air->naddrs; ++i)
{
socklen_t size = (air->family[i] == AF_INET
? INADDRSZ : IN6ADDRSZ);
if (!((air->family[i] == AF_INET
&& req->ai_family == AF_INET6
&& (req->ai_flags & AI_V4MAPPED) != 0)
|| req->ai_family == AF_UNSPEC
|| air->family[i] == req->ai_family))
{
/* Skip over non-matching result. */
addrs += size;
continue;
}
if (*pat == NULL)
{
*pat = addrfree++;
(*pat)->scopeid = 0;
}
uint32_t *pataddr = (*pat)->addr;
(*pat)->next = NULL;
if (added_canon || air->canon == NULL)
(*pat)->name = NULL;
else if (canonbuf == NULL)
{
size_t canonlen = strlen (air->canon) + 1;
if ((req->ai_flags & AI_CANONIDN) != 0
&& __libc_use_alloca (alloca_used + canonlen))
canonbuf = alloca_account (canonlen, alloca_used);
else
{
canonbuf = malloc (canonlen);
if (canonbuf == NULL)
{
result = -EAI_MEMORY;
goto free_and_return;
}
malloc_canonbuf = true;
}
canon = (*pat)->name = memcpy (canonbuf, air->canon,
canonlen);
}
if (air->family[i] == AF_INET
&& req->ai_family == AF_INET6
&& (req->ai_flags & AI_V4MAPPED))
{
(*pat)->family = AF_INET6;
pataddr[3] = *(uint32_t *) addrs;
pataddr[2] = htonl (0xffff);
pataddr[1] = 0;
pataddr[0] = 0;
pat = &((*pat)->next);
added_canon = true;
}
else if (req->ai_family == AF_UNSPEC
|| air->family[i] == req->ai_family)
{
(*pat)->family = air->family[i];
memcpy (pataddr, addrs, size);
pat = &((*pat)->next);
added_canon = true;
if (air->family[i] == AF_INET6)
got_ipv6 = true;
}
addrs += size;
}
free (air);
if (at->family == AF_UNSPEC)
{
result = -EAI_NONAME;
goto free_and_return;
}
goto process_list;
}
else if (err == 0)
/* The database contains a negative entry. */
goto free_and_return;
else if (__nss_not_use_nscd_hosts == 0)
{
if (herrno == NETDB_INTERNAL && errno == ENOMEM)
result = -EAI_MEMORY;
else if (herrno == TRY_AGAIN)
result = -EAI_AGAIN;
else
result = -EAI_SYSTEM;
goto free_and_return;
}
}
#endif
if (__nss_hosts_database == NULL)
no_more = __nss_database_lookup ("hosts", NULL,
"dns [!UNAVAIL=return] files",
&__nss_hosts_database);
else
no_more = 0;
nip = __nss_hosts_database;
/* Initialize configurations. */
_res_hconf_init ();
if (__res_maybe_init (&_res, 0) == -1)
no_more = 1;
/* If we are looking for both IPv4 and IPv6 address we don't
want the lookup functions to automatically promote IPv4
addresses to IPv6 addresses. Currently this is decided
by setting the RES_USE_INET6 bit in _res.options. */
old_res_options = _res.options;
_res.options &= ~DEPRECATED_RES_USE_INET6;
while (!no_more)
{
no_data = 0;
nss_gethostbyname4_r fct4 = NULL;
/* gethostbyname4_r sends out parallel A and AAAA queries and
is thus only suitable for PF_UNSPEC. */
if (req->ai_family == PF_UNSPEC)
fct4 = __nss_lookup_function (nip, "gethostbyname4_r");
if (fct4 != NULL)
{
int herrno;
while (1)
{
rc = 0;
status = DL_CALL_FCT (fct4, (name, pat,
tmpbuf->data, tmpbuf->length,
&rc, &herrno,
NULL));
if (status == NSS_STATUS_SUCCESS)
break;
if (status != NSS_STATUS_TRYAGAIN
|| rc != ERANGE || herrno != NETDB_INTERNAL)
{
if (herrno == TRY_AGAIN)
no_data = EAI_AGAIN;
else
no_data = herrno == NO_DATA;
break;
}
if (!scratch_buffer_grow (tmpbuf))
{
_res.options
|= old_res_options & DEPRECATED_RES_USE_INET6;
result = -EAI_MEMORY;
goto free_and_return;
}
}
if (status == NSS_STATUS_SUCCESS)
{
assert (!no_data);
no_data = 1;
if ((req->ai_flags & AI_CANONNAME) != 0 && canon == NULL)
canon = (*pat)->name;
while (*pat != NULL)
{
if ((*pat)->family == AF_INET
&& req->ai_family == AF_INET6
&& (req->ai_flags & AI_V4MAPPED) != 0)
{
uint32_t *pataddr = (*pat)->addr;
(*pat)->family = AF_INET6;
pataddr[3] = pataddr[0];
pataddr[2] = htonl (0xffff);
pataddr[1] = 0;
pataddr[0] = 0;
pat = &((*pat)->next);
no_data = 0;
}
else if (req->ai_family == AF_UNSPEC
|| (*pat)->family == req->ai_family)
{
pat = &((*pat)->next);
no_data = 0;
if (req->ai_family == AF_INET6)
got_ipv6 = true;
}
else
*pat = ((*pat)->next);
}
}
no_inet6_data = no_data;
}
else
{
nss_gethostbyname3_r fct = NULL;
if (req->ai_flags & AI_CANONNAME)
/* No need to use this function if we do not look for
the canonical name. The function does not exist in
all NSS modules and therefore the lookup would
often fail. */
fct = __nss_lookup_function (nip, "gethostbyname3_r");
if (fct == NULL)
/* We are cheating here. The gethostbyname2_r
function does not have the same interface as
gethostbyname3_r but the extra arguments the
latter takes are added at the end. So the
gethostbyname2_r code will just ignore them. */
fct = __nss_lookup_function (nip, "gethostbyname2_r");
if (fct != NULL)
{
if (req->ai_family == AF_INET6
|| req->ai_family == AF_UNSPEC)
{
gethosts (AF_INET6, struct in6_addr);
no_inet6_data = no_data;
inet6_status = status;
}
if (req->ai_family == AF_INET
|| req->ai_family == AF_UNSPEC
|| (req->ai_family == AF_INET6
&& (req->ai_flags & AI_V4MAPPED)
/* Avoid generating the mapped addresses if we
know we are not going to need them. */
&& ((req->ai_flags & AI_ALL) || !got_ipv6)))
{
gethosts (AF_INET, struct in_addr);
if (req->ai_family == AF_INET)
{
no_inet6_data = no_data;
inet6_status = status;
}
}
/* If we found one address for AF_INET or AF_INET6,
don't continue the search. */
if (inet6_status == NSS_STATUS_SUCCESS
|| status == NSS_STATUS_SUCCESS)
{
if ((req->ai_flags & AI_CANONNAME) != 0
&& canon == NULL)
{
/* If we need the canonical name, get it
from the same service as the result. */
nss_getcanonname_r cfct;
int herrno;
cfct = __nss_lookup_function (nip,
"getcanonname_r");
if (cfct != NULL)
{
const size_t max_fqdn_len = 256;
if ((req->ai_flags & AI_CANONIDN) != 0
&& __libc_use_alloca (alloca_used
+ max_fqdn_len))
canonbuf = alloca_account (max_fqdn_len,
alloca_used);
else
{
canonbuf = malloc (max_fqdn_len);
if (canonbuf == NULL)
{
_res.options
|= old_res_options
& DEPRECATED_RES_USE_INET6;
result = -EAI_MEMORY;
goto free_and_return;
}
malloc_canonbuf = true;
}
char *s;
if (DL_CALL_FCT (cfct, (at->name ?: name,
canonbuf,
max_fqdn_len,
&s, &rc, &herrno))
== NSS_STATUS_SUCCESS)
canon = s;
else
{
/* If the canonical name cannot be
determined, use the passed in
string. */
if (malloc_canonbuf)
{
free (canonbuf);
malloc_canonbuf = false;
}
canon = name;
}
}
}
status = NSS_STATUS_SUCCESS;
}
else
{
/* We can have different states for AF_INET and
AF_INET6. Try to find a useful one for both. */
if (inet6_status == NSS_STATUS_TRYAGAIN)
status = NSS_STATUS_TRYAGAIN;
else if (status == NSS_STATUS_UNAVAIL
&& inet6_status != NSS_STATUS_UNAVAIL)
status = inet6_status;
}
}
else
{
status = NSS_STATUS_UNAVAIL;
/* Could not load any of the lookup functions. Indicate
an internal error if the failure was due to a system
error other than the file not being found. We use the
errno from the last failed callback. */
if (errno != 0 && errno != ENOENT)
__set_h_errno (NETDB_INTERNAL);
}
}
if (nss_next_action (nip, status) == NSS_ACTION_RETURN)
break;
if (nip->next == NULL)
no_more = -1;
else
nip = nip->next;
}
_res.options |= old_res_options & DEPRECATED_RES_USE_INET6;
if (h_errno == NETDB_INTERNAL)
{
result = -EAI_SYSTEM;
goto free_and_return;
}
if (no_data != 0 && no_inet6_data != 0)
{
/* If both requests timed out report this. */
if (no_data == EAI_AGAIN && no_inet6_data == EAI_AGAIN)
result = -EAI_AGAIN;
else
/* We made requests but they turned out no data. The name
is known, though. */
result = -EAI_NODATA;
goto free_and_return;
}
}
process_list:
if (at->family == AF_UNSPEC)
{
result = -EAI_NONAME;
goto free_and_return;
}
}
else
{
struct gaih_addrtuple *atr;
atr = at = alloca_account (sizeof (struct gaih_addrtuple), alloca_used);
memset (at, '\0', sizeof (struct gaih_addrtuple));
if (req->ai_family == AF_UNSPEC)
{
at->next = __alloca (sizeof (struct gaih_addrtuple));
memset (at->next, '\0', sizeof (struct gaih_addrtuple));
}
if (req->ai_family == AF_UNSPEC || req->ai_family == AF_INET6)
{
at->family = AF_INET6;
if ((req->ai_flags & AI_PASSIVE) == 0)
memcpy (at->addr, &in6addr_loopback, sizeof (struct in6_addr));
atr = at->next;
}
if (req->ai_family == AF_UNSPEC || req->ai_family == AF_INET)
{
atr->family = AF_INET;
if ((req->ai_flags & AI_PASSIVE) == 0)
atr->addr[0] = htonl (INADDR_LOOPBACK);
}
}
{
struct gaih_servtuple *st2;
struct gaih_addrtuple *at2 = at;
size_t socklen;
sa_family_t family;
/*
buffer is the size of an unformatted IPv6 address in printable format.
*/
while (at2 != NULL)
{
/* Only the first entry gets the canonical name. */
if (at2 == at && (req->ai_flags & AI_CANONNAME) != 0)
{
if (canon == NULL)
/* If the canonical name cannot be determined, use
the passed in string. */
canon = orig_name;
#ifdef HAVE_LIBIDN
if (req->ai_flags & AI_CANONIDN)
{
int idn_flags = 0;
if (req->ai_flags & AI_IDN_ALLOW_UNASSIGNED)
idn_flags |= IDNA_ALLOW_UNASSIGNED;
if (req->ai_flags & AI_IDN_USE_STD3_ASCII_RULES)
idn_flags |= IDNA_USE_STD3_ASCII_RULES;
char *out;
int rc = __idna_to_unicode_lzlz (canon, &out, idn_flags);
if (rc != IDNA_SUCCESS)
{
if (rc == IDNA_MALLOC_ERROR)
result = -EAI_MEMORY;
else if (rc == IDNA_DLOPEN_ERROR)
result = -EAI_SYSTEM;
else
result = -EAI_IDN_ENCODE;
goto free_and_return;
}
/* In case the output string is the same as the input
string no new string has been allocated and we
make a copy. */
if (out == canon)
goto make_copy;
canon = out;
}
else
#endif
{
#ifdef HAVE_LIBIDN
make_copy:
#endif
if (malloc_canonbuf)
/* We already allocated the string using malloc. */
malloc_canonbuf = false;
else
{
canon = strdup (canon);
if (canon == NULL)
{
result = -EAI_MEMORY;
goto free_and_return;
}
}
}
}
family = at2->family;
if (family == AF_INET6)
{
socklen = sizeof (struct sockaddr_in6);
/* If we looked up IPv4 mapped address discard them here if
the caller isn't interested in all address and we have
found at least one IPv6 address. */
if (got_ipv6
&& (req->ai_flags & (AI_V4MAPPED|AI_ALL)) == AI_V4MAPPED
&& IN6_IS_ADDR_V4MAPPED (at2->addr))
goto ignore;
}
else
socklen = sizeof (struct sockaddr_in);
for (st2 = st; st2 != NULL; st2 = st2->next)
{
struct addrinfo *ai;
ai = *pai = malloc (sizeof (struct addrinfo) + socklen);
if (ai == NULL)
{
free ((char *) canon);
result = -EAI_MEMORY;
goto free_and_return;
}
ai->ai_flags = req->ai_flags;
ai->ai_family = family;
ai->ai_socktype = st2->socktype;
ai->ai_protocol = st2->protocol;
ai->ai_addrlen = socklen;
ai->ai_addr = (void *) (ai + 1);
/* We only add the canonical name once. */
ai->ai_canonname = (char *) canon;
canon = NULL;
#ifdef _HAVE_SA_LEN
ai->ai_addr->sa_len = socklen;
#endif /* _HAVE_SA_LEN */
ai->ai_addr->sa_family = family;
/* In case of an allocation error the list must be NULL
terminated. */
ai->ai_next = NULL;
if (family == AF_INET6)
{
struct sockaddr_in6 *sin6p =
(struct sockaddr_in6 *) ai->ai_addr;
sin6p->sin6_port = st2->port;
sin6p->sin6_flowinfo = 0;
memcpy (&sin6p->sin6_addr,
at2->addr, sizeof (struct in6_addr));
sin6p->sin6_scope_id = at2->scopeid;
}
else
{
struct sockaddr_in *sinp =
(struct sockaddr_in *) ai->ai_addr;
sinp->sin_port = st2->port;
memcpy (&sinp->sin_addr,
at2->addr, sizeof (struct in_addr));
memset (sinp->sin_zero, '\0', sizeof (sinp->sin_zero));
}
pai = &(ai->ai_next);
}
++*naddrs;
ignore:
at2 = at2->next;
}
}
free_and_return:
if (malloc_name)
free ((char *) name);
if (malloc_addrmem)
free (addrmem);
if (malloc_canonbuf)
free (canonbuf);
return result;
}
struct sort_result
{
struct addrinfo *dest_addr;
/* Using sockaddr_storage is for now overkill. We only support IPv4
and IPv6 so far. If this changes at some point we can adjust the
type here. */
struct sockaddr_in6 source_addr;
uint8_t source_addr_len;
bool got_source_addr;
uint8_t source_addr_flags;
uint8_t prefixlen;
uint32_t index;
int32_t native;
};
struct sort_result_combo
{
struct sort_result *results;
int nresults;
};
#if __BYTE_ORDER == __BIG_ENDIAN
# define htonl_c(n) n
#else
# define htonl_c(n) __bswap_constant_32 (n)
#endif
static const struct scopeentry
{
union
{
char addr[4];
uint32_t addr32;
};
uint32_t netmask;
int32_t scope;
} default_scopes[] =
{
/* Link-local addresses: scope 2. */
{ { { 169, 254, 0, 0 } }, htonl_c (0xffff0000), 2 },
{ { { 127, 0, 0, 0 } }, htonl_c (0xff000000), 2 },
/* Default: scope 14. */
{ { { 0, 0, 0, 0 } }, htonl_c (0x00000000), 14 }
};
/* The label table. */
static const struct scopeentry *scopes;
static int
get_scope (const struct sockaddr_in6 *in6)
{
int scope;
if (in6->sin6_family == PF_INET6)
{
if (! IN6_IS_ADDR_MULTICAST (&in6->sin6_addr))
{
if (IN6_IS_ADDR_LINKLOCAL (&in6->sin6_addr)
/* RFC 4291 2.5.3 says that the loopback address is to be
treated like a link-local address. */
|| IN6_IS_ADDR_LOOPBACK (&in6->sin6_addr))
scope = 2;
else if (IN6_IS_ADDR_SITELOCAL (&in6->sin6_addr))
scope = 5;
else
/* XXX Is this the correct default behavior? */
scope = 14;
}
else
scope = in6->sin6_addr.s6_addr[1] & 0xf;
}
else if (in6->sin6_family == PF_INET)
{
const struct sockaddr_in *in = (const struct sockaddr_in *) in6;
size_t cnt = 0;
while (1)
{
if ((in->sin_addr.s_addr & scopes[cnt].netmask)
== scopes[cnt].addr32)
return scopes[cnt].scope;
++cnt;
}
/* NOTREACHED */
}
else
/* XXX What is a good default? */
scope = 15;
return scope;
}
struct prefixentry
{
struct in6_addr prefix;
unsigned int bits;
int val;
};
/* The label table. */
static const struct prefixentry *labels;
/* Default labels. */
static const struct prefixentry default_labels[] =
{
/* See RFC 3484 for the details. */
{ { .__in6_u
= { .__u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } }
}, 128, 0 },
{ { .__in6_u
= { .__u6_addr8 = { 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
}, 16, 2 },
{ { .__in6_u
= { .__u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
}, 96, 3 },
{ { .__in6_u
= { .__u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } }
}, 96, 4 },
/* The next two entries differ from RFC 3484. We need to treat
IPv6 site-local addresses special because they are never NATed,
unlike site-locale IPv4 addresses. If this would not happen, on
machines which have only IPv4 and IPv6 site-local addresses, the
sorting would prefer the IPv6 site-local addresses, causing
unnecessary delays when trying to connect to a global IPv6 address
through a site-local IPv6 address. */
{ { .__in6_u
= { .__u6_addr8 = { 0xfe, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
}, 10, 5 },
{ { .__in6_u
= { .__u6_addr8 = { 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
}, 7, 6 },
/* Additional rule for Teredo tunnels. */
{ { .__in6_u
= { .__u6_addr8 = { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
}, 32, 7 },
{ { .__in6_u
= { .__u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
}, 0, 1 }
};
/* The precedence table. */
static const struct prefixentry *precedence;
/* The default precedences. */
static const struct prefixentry default_precedence[] =
{
/* See RFC 3484 for the details. */
{ { .__in6_u
= { .__u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } }
}, 128, 50 },
{ { .__in6_u
= { .__u6_addr8 = { 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
}, 16, 30 },
{ { .__in6_u
= { .__u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
}, 96, 20 },
{ { .__in6_u
= { .__u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } }
}, 96, 10 },
{ { .__in6_u
= { .__u6_addr8 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
}, 0, 40 }
};
static int
match_prefix (const struct sockaddr_in6 *in6,
const struct prefixentry *list, int default_val)
{
int idx;
struct sockaddr_in6 in6_mem;
if (in6->sin6_family == PF_INET)
{
const struct sockaddr_in *in = (const struct sockaddr_in *) in6;
/* Construct a V4-to-6 mapped address. */
in6_mem.sin6_family = PF_INET6;
in6_mem.sin6_port = in->sin_port;
in6_mem.sin6_flowinfo = 0;
memset (&in6_mem.sin6_addr, '\0', sizeof (in6_mem.sin6_addr));
in6_mem.sin6_addr.s6_addr16[5] = 0xffff;
in6_mem.sin6_addr.s6_addr32[3] = in->sin_addr.s_addr;
in6_mem.sin6_scope_id = 0;
in6 = &in6_mem;
}
else if (in6->sin6_family != PF_INET6)
return default_val;
for (idx = 0; ; ++idx)
{
unsigned int bits = list[idx].bits;
const uint8_t *mask = list[idx].prefix.s6_addr;
const uint8_t *val = in6->sin6_addr.s6_addr;
while (bits >= 8)
{
if (*mask != *val)
break;
++mask;
++val;
bits -= 8;
}
if (bits < 8)
{
if ((*mask & (0xff00 >> bits)) == (*val & (0xff00 >> bits)))
/* Match! */
break;
}
}
return list[idx].val;
}
static int
get_label (const struct sockaddr_in6 *in6)
{
/* XXX What is a good default value? */
return match_prefix (in6, labels, INT_MAX);
}
static int
get_precedence (const struct sockaddr_in6 *in6)
{
/* XXX What is a good default value? */
return match_prefix (in6, precedence, 0);
}
/* Find last bit set in a word. */
static int
fls (uint32_t a)
{
uint32_t mask;
int n;
for (n = 0, mask = 1 << 31; n < 32; mask >>= 1, ++n)
if ((a & mask) != 0)
break;
return n;
}
static int
rfc3484_sort (const void *p1, const void *p2, void *arg)
{
const size_t idx1 = *(const size_t *) p1;
const size_t idx2 = *(const size_t *) p2;
struct sort_result_combo *src = (struct sort_result_combo *) arg;
struct sort_result *a1 = &src->results[idx1];
struct sort_result *a2 = &src->results[idx2];
/* Rule 1: Avoid unusable destinations.
We have the got_source_addr flag set if the destination is reachable. */
if (a1->got_source_addr && ! a2->got_source_addr)
return -1;
if (! a1->got_source_addr && a2->got_source_addr)
return 1;
/* Rule 2: Prefer matching scope. Only interesting if both
destination addresses are IPv6. */
int a1_dst_scope
= get_scope ((struct sockaddr_in6 *) a1->dest_addr->ai_addr);
int a2_dst_scope
= get_scope ((struct sockaddr_in6 *) a2->dest_addr->ai_addr);
if (a1->got_source_addr)
{
int a1_src_scope = get_scope (&a1->source_addr);
int a2_src_scope = get_scope (&a2->source_addr);
if (a1_dst_scope == a1_src_scope && a2_dst_scope != a2_src_scope)
return -1;
if (a1_dst_scope != a1_src_scope && a2_dst_scope == a2_src_scope)
return 1;
}
/* Rule 3: Avoid deprecated addresses. */
if (a1->got_source_addr)
{
if (!(a1->source_addr_flags & in6ai_deprecated)
&& (a2->source_addr_flags & in6ai_deprecated))
return -1;
if ((a1->source_addr_flags & in6ai_deprecated)
&& !(a2->source_addr_flags & in6ai_deprecated))
return 1;
}
/* Rule 4: Prefer home addresses. */
if (a1->got_source_addr)
{
if (!(a1->source_addr_flags & in6ai_homeaddress)
&& (a2->source_addr_flags & in6ai_homeaddress))
return 1;
if ((a1->source_addr_flags & in6ai_homeaddress)
&& !(a2->source_addr_flags & in6ai_homeaddress))
return -1;
}
/* Rule 5: Prefer matching label. */
if (a1->got_source_addr)
{
int a1_dst_label
= get_label ((struct sockaddr_in6 *) a1->dest_addr->ai_addr);
int a1_src_label = get_label (&a1->source_addr);
int a2_dst_label
= get_label ((struct sockaddr_in6 *) a2->dest_addr->ai_addr);
int a2_src_label = get_label (&a2->source_addr);
if (a1_dst_label == a1_src_label && a2_dst_label != a2_src_label)
return -1;
if (a1_dst_label != a1_src_label && a2_dst_label == a2_src_label)
return 1;
}
/* Rule 6: Prefer higher precedence. */
int a1_prec
= get_precedence ((struct sockaddr_in6 *) a1->dest_addr->ai_addr);
int a2_prec
= get_precedence ((struct sockaddr_in6 *) a2->dest_addr->ai_addr);
if (a1_prec > a2_prec)
return -1;
if (a1_prec < a2_prec)
return 1;
/* Rule 7: Prefer native transport. */
if (a1->got_source_addr)
{
/* The same interface index means the same interface which means
there is no difference in transport. This should catch many
(most?) cases. */
if (a1->index != a2->index)
{
int a1_native = a1->native;
int a2_native = a2->native;
if (a1_native == -1 || a2_native == -1)
{
uint32_t a1_index;
if (a1_native == -1)
{
/* If we do not have the information use 'native' as
the default. */
a1_native = 0;
a1_index = a1->index;
}
else
a1_index = 0xffffffffu;
uint32_t a2_index;
if (a2_native == -1)
{
/* If we do not have the information use 'native' as
the default. */
a2_native = 0;
a2_index = a2->index;
}
else
a2_index = 0xffffffffu;
__check_native (a1_index, &a1_native, a2_index, &a2_native);
/* Fill in the results in all the records. */
for (int i = 0; i < src->nresults; ++i)
if (a1_index != -1 && src->results[i].index == a1_index)
{
assert (src->results[i].native == -1
|| src->results[i].native == a1_native);
src->results[i].native = a1_native;
}
else if (a2_index != -1 && src->results[i].index == a2_index)
{
assert (src->results[i].native == -1
|| src->results[i].native == a2_native);
src->results[i].native = a2_native;
}
}
if (a1_native && !a2_native)
return -1;
if (!a1_native && a2_native)
return 1;
}
}
/* Rule 8: Prefer smaller scope. */
if (a1_dst_scope < a2_dst_scope)
return -1;
if (a1_dst_scope > a2_dst_scope)
return 1;
/* Rule 9: Use longest matching prefix. */
if (a1->got_source_addr
&& a1->dest_addr->ai_family == a2->dest_addr->ai_family)
{
int bit1 = 0;
int bit2 = 0;
if (a1->dest_addr->ai_family == PF_INET)
{
assert (a1->source_addr.sin6_family == PF_INET);
assert (a2->source_addr.sin6_family == PF_INET);
/* Outside of subnets, as defined by the network masks,
common address prefixes for IPv4 addresses make no sense.
So, define a non-zero value only if source and
destination address are on the same subnet. */
struct sockaddr_in *in1_dst
= (struct sockaddr_in *) a1->dest_addr->ai_addr;
in_addr_t in1_dst_addr = ntohl (in1_dst->sin_addr.s_addr);
struct sockaddr_in *in1_src
= (struct sockaddr_in *) &a1->source_addr;
in_addr_t in1_src_addr = ntohl (in1_src->sin_addr.s_addr);
in_addr_t netmask1 = 0xffffffffu << (32 - a1->prefixlen);
if ((in1_src_addr & netmask1) == (in1_dst_addr & netmask1))
bit1 = fls (in1_dst_addr ^ in1_src_addr);
struct sockaddr_in *in2_dst
= (struct sockaddr_in *) a2->dest_addr->ai_addr;
in_addr_t in2_dst_addr = ntohl (in2_dst->sin_addr.s_addr);
struct sockaddr_in *in2_src
= (struct sockaddr_in *) &a2->source_addr;
in_addr_t in2_src_addr = ntohl (in2_src->sin_addr.s_addr);
in_addr_t netmask2 = 0xffffffffu << (32 - a2->prefixlen);
if ((in2_src_addr & netmask2) == (in2_dst_addr & netmask2))
bit2 = fls (in2_dst_addr ^ in2_src_addr);
}
else if (a1->dest_addr->ai_family == PF_INET6)
{
assert (a1->source_addr.sin6_family == PF_INET6);
assert (a2->source_addr.sin6_family == PF_INET6);
struct sockaddr_in6 *in1_dst;
struct sockaddr_in6 *in1_src;
struct sockaddr_in6 *in2_dst;
struct sockaddr_in6 *in2_src;
in1_dst = (struct sockaddr_in6 *) a1->dest_addr->ai_addr;
in1_src = (struct sockaddr_in6 *) &a1->source_addr;
in2_dst = (struct sockaddr_in6 *) a2->dest_addr->ai_addr;
in2_src = (struct sockaddr_in6 *) &a2->source_addr;
int i;
for (i = 0; i < 4; ++i)
if (in1_dst->sin6_addr.s6_addr32[i]
!= in1_src->sin6_addr.s6_addr32[i]
|| (in2_dst->sin6_addr.s6_addr32[i]
!= in2_src->sin6_addr.s6_addr32[i]))
break;
if (i < 4)
{
bit1 = fls (ntohl (in1_dst->sin6_addr.s6_addr32[i]
^ in1_src->sin6_addr.s6_addr32[i]));
bit2 = fls (ntohl (in2_dst->sin6_addr.s6_addr32[i]
^ in2_src->sin6_addr.s6_addr32[i]));
}
}
if (bit1 > bit2)
return -1;
if (bit1 < bit2)
return 1;
}
/* Rule 10: Otherwise, leave the order unchanged. To ensure this
compare with the value indicating the order in which the entries
have been received from the services. NB: no two entries can have
the same order so the test will never return zero. */
return idx1 < idx2 ? -1 : 1;
}
static int
in6aicmp (const void *p1, const void *p2)
{
struct in6addrinfo *a1 = (struct in6addrinfo *) p1;
struct in6addrinfo *a2 = (struct in6addrinfo *) p2;
return memcmp (a1->addr, a2->addr, sizeof (a1->addr));
}
/* Name of the config file for RFC 3484 sorting (for now). */
#define GAICONF_FNAME "/etc/gai.conf"
/* Non-zero if we are supposed to reload the config file automatically
whenever it changed. */
static int gaiconf_reload_flag;
/* Non-zero if gaiconf_reload_flag was ever set to true. */
static int gaiconf_reload_flag_ever_set;
/* Last modification time. */
#ifdef _STATBUF_ST_NSEC
static struct timespec gaiconf_mtime;
static inline void
save_gaiconf_mtime (const struct stat64 *st)
{
gaiconf_mtime = st->st_mtim;
}
static inline bool
check_gaiconf_mtime (const struct stat64 *st)
{
return (st->st_mtim.tv_sec == gaiconf_mtime.tv_sec
&& st->st_mtim.tv_nsec == gaiconf_mtime.tv_nsec);
}
#else
static time_t gaiconf_mtime;
static inline void
save_gaiconf_mtime (const struct stat64 *st)
{
gaiconf_mtime = st->st_mtime;
}
static inline bool
check_gaiconf_mtime (const struct stat64 *st)
{
return st->st_mtime == gaiconf_mtime;
}
#endif
libc_freeres_fn(fini)
{
if (labels != default_labels)
{
const struct prefixentry *old = labels;
labels = default_labels;
free ((void *) old);
}
if (precedence != default_precedence)
{
const struct prefixentry *old = precedence;
precedence = default_precedence;
free ((void *) old);
}
if (scopes != default_scopes)
{
const struct scopeentry *old = scopes;
scopes = default_scopes;
free ((void *) old);
}
}
struct prefixlist
{
struct prefixentry entry;
struct prefixlist *next;
};
struct scopelist
{
struct scopeentry entry;
struct scopelist *next;
};
static void
free_prefixlist (struct prefixlist *list)
{
while (list != NULL)
{
struct prefixlist *oldp = list;
list = list->next;
free (oldp);
}
}
static void
free_scopelist (struct scopelist *list)
{
while (list != NULL)
{
struct scopelist *oldp = list;
list = list->next;
free (oldp);
}
}
static int
prefixcmp (const void *p1, const void *p2)
{
const struct prefixentry *e1 = (const struct prefixentry *) p1;
const struct prefixentry *e2 = (const struct prefixentry *) p2;
if (e1->bits < e2->bits)
return 1;
if (e1->bits == e2->bits)
return 0;
return -1;
}
static int
scopecmp (const void *p1, const void *p2)
{
const struct scopeentry *e1 = (const struct scopeentry *) p1;
const struct scopeentry *e2 = (const struct scopeentry *) p2;
if (e1->netmask > e2->netmask)
return -1;
if (e1->netmask == e2->netmask)
return 0;
return 1;
}
static void
gaiconf_init (void)
{
struct prefixlist *labellist = NULL;
size_t nlabellist = 0;
bool labellist_nullbits = false;
struct prefixlist *precedencelist = NULL;
size_t nprecedencelist = 0;
bool precedencelist_nullbits = false;
struct scopelist *scopelist = NULL;
size_t nscopelist = 0;
bool scopelist_nullbits = false;
FILE *fp = fopen (GAICONF_FNAME, "rce");
if (fp != NULL)
{
struct stat64 st;
if (__fxstat64 (_STAT_VER, fileno (fp), &st) != 0)
{
fclose (fp);
goto no_file;
}
char *line = NULL;
size_t linelen = 0;
__fsetlocking (fp, FSETLOCKING_BYCALLER);
while (!feof_unlocked (fp))
{
ssize_t n = __getline (&line, &linelen, fp);
if (n <= 0)
break;
/* Handle comments. No escaping possible so this is easy. */
char *cp = strchr (line, '#');
if (cp != NULL)
*cp = '\0';
cp = line;
while (isspace (*cp))
++cp;
char *cmd = cp;
while (*cp != '\0' && !isspace (*cp))
++cp;
size_t cmdlen = cp - cmd;
if (*cp != '\0')
*cp++ = '\0';
while (isspace (*cp))
++cp;
char *val1 = cp;
while (*cp != '\0' && !isspace (*cp))
++cp;
size_t val1len = cp - cmd;
/* We always need at least two values. */
if (val1len == 0)
continue;
if (*cp != '\0')
*cp++ = '\0';
while (isspace (*cp))
++cp;
char *val2 = cp;
while (*cp != '\0' && !isspace (*cp))
++cp;
/* Ignore the rest of the line. */
*cp = '\0';
struct prefixlist **listp;
size_t *lenp;
bool *nullbitsp;
switch (cmdlen)
{
case 5:
if (strcmp (cmd, "label") == 0)
{
struct in6_addr prefix;
unsigned long int bits;
unsigned long int val;
char *endp;
listp = &labellist;
lenp = &nlabellist;
nullbitsp = &labellist_nullbits;
new_elem:
bits = 128;
__set_errno (0);
cp = strchr (val1, '/');
if (cp != NULL)
*cp++ = '\0';
if (inet_pton (AF_INET6, val1, &prefix)
&& (cp == NULL
|| (bits = strtoul (cp, &endp, 10)) != ULONG_MAX
|| errno != ERANGE)
&& *endp == '\0'
&& bits <= 128
&& ((val = strtoul (val2, &endp, 10)) != ULONG_MAX
|| errno != ERANGE)
&& *endp == '\0'
&& val <= INT_MAX)
{
struct prefixlist *newp = malloc (sizeof (*newp));
if (newp == NULL)
{
free (line);
fclose (fp);
goto no_file;
}
memcpy (&newp->entry.prefix, &prefix, sizeof (prefix));
newp->entry.bits = bits;
newp->entry.val = val;
newp->next = *listp;
*listp = newp;
++*lenp;
*nullbitsp |= bits == 0;
}
}
break;
case 6:
if (strcmp (cmd, "reload") == 0)
{
gaiconf_reload_flag = strcmp (val1, "yes") == 0;
if (gaiconf_reload_flag)
gaiconf_reload_flag_ever_set = 1;
}
break;
case 7:
if (strcmp (cmd, "scopev4") == 0)
{
struct in6_addr prefix;
unsigned long int bits;
unsigned long int val;
char *endp;
bits = 32;
__set_errno (0);
cp = strchr (val1, '/');
if (cp != NULL)
*cp++ = '\0';
if (inet_pton (AF_INET6, val1, &prefix))
{
bits = 128;
if (IN6_IS_ADDR_V4MAPPED (&prefix)
&& (cp == NULL
|| (bits = strtoul (cp, &endp, 10)) != ULONG_MAX
|| errno != ERANGE)
&& *endp == '\0'
&& bits >= 96
&& bits <= 128
&& ((val = strtoul (val2, &endp, 10)) != ULONG_MAX
|| errno != ERANGE)
&& *endp == '\0'
&& val <= INT_MAX)
{
struct scopelist *newp;
new_scope:
newp = malloc (sizeof (*newp));
if (newp == NULL)
{
free (line);
fclose (fp);
goto no_file;
}
newp->entry.netmask = htonl (bits != 96
? (0xffffffff
<< (128 - bits))
: 0);
newp->entry.addr32 = (prefix.s6_addr32[3]
& newp->entry.netmask);
newp->entry.scope = val;
newp->next = scopelist;
scopelist = newp;
++nscopelist;
scopelist_nullbits |= bits == 96;
}
}
else if (inet_pton (AF_INET, val1, &prefix.s6_addr32[3])
&& (cp == NULL
|| (bits = strtoul (cp, &endp, 10)) != ULONG_MAX
|| errno != ERANGE)
&& *endp == '\0'
&& bits <= 32
&& ((val = strtoul (val2, &endp, 10)) != ULONG_MAX
|| errno != ERANGE)
&& *endp == '\0'
&& val <= INT_MAX)
{
bits += 96;
goto new_scope;
}
}
break;
case 10:
if (strcmp (cmd, "precedence") == 0)
{
listp = &precedencelist;
lenp = &nprecedencelist;
nullbitsp = &precedencelist_nullbits;
goto new_elem;
}
break;
}
}
free (line);
fclose (fp);
/* Create the array for the labels. */
struct prefixentry *new_labels;
if (nlabellist > 0)
{
if (!labellist_nullbits)
++nlabellist;
new_labels = malloc (nlabellist * sizeof (*new_labels));
if (new_labels == NULL)
goto no_file;
int i = nlabellist;
if (!labellist_nullbits)
{
--i;
memset (&new_labels[i].prefix, '\0', sizeof (struct in6_addr));
new_labels[i].bits = 0;
new_labels[i].val = 1;
}
struct prefixlist *l = labellist;
while (i-- > 0)
{
new_labels[i] = l->entry;
l = l->next;
}
free_prefixlist (labellist);
/* Sort the entries so that the most specific ones are at
the beginning. */
qsort (new_labels, nlabellist, sizeof (*new_labels), prefixcmp);
}
else
new_labels = (struct prefixentry *) default_labels;
struct prefixentry *new_precedence;
if (nprecedencelist > 0)
{
if (!precedencelist_nullbits)
++nprecedencelist;
new_precedence = malloc (nprecedencelist * sizeof (*new_precedence));
if (new_precedence == NULL)
{
if (new_labels != default_labels)
free (new_labels);
goto no_file;
}
int i = nprecedencelist;
if (!precedencelist_nullbits)
{
--i;
memset (&new_precedence[i].prefix, '\0',
sizeof (struct in6_addr));
new_precedence[i].bits = 0;
new_precedence[i].val = 40;
}
struct prefixlist *l = precedencelist;
while (i-- > 0)
{
new_precedence[i] = l->entry;
l = l->next;
}
free_prefixlist (precedencelist);
/* Sort the entries so that the most specific ones are at
the beginning. */
qsort (new_precedence, nprecedencelist, sizeof (*new_precedence),
prefixcmp);
}
else
new_precedence = (struct prefixentry *) default_precedence;
struct scopeentry *new_scopes;
if (nscopelist > 0)
{
if (!scopelist_nullbits)
++nscopelist;
new_scopes = malloc (nscopelist * sizeof (*new_scopes));
if (new_scopes == NULL)
{
if (new_labels != default_labels)
free (new_labels);
if (new_precedence != default_precedence)
free (new_precedence);
goto no_file;
}
int i = nscopelist;
if (!scopelist_nullbits)
{
--i;
new_scopes[i].addr32 = 0;
new_scopes[i].netmask = 0;
new_scopes[i].scope = 14;
}
struct scopelist *l = scopelist;
while (i-- > 0)
{
new_scopes[i] = l->entry;
l = l->next;
}
free_scopelist (scopelist);
/* Sort the entries so that the most specific ones are at
the beginning. */
qsort (new_scopes, nscopelist, sizeof (*new_scopes),
scopecmp);
}
else
new_scopes = (struct scopeentry *) default_scopes;
/* Now we are ready to replace the values. */
const struct prefixentry *old = labels;
labels = new_labels;
if (old != default_labels)
free ((void *) old);
old = precedence;
precedence = new_precedence;
if (old != default_precedence)
free ((void *) old);
const struct scopeentry *oldscope = scopes;
scopes = new_scopes;
if (oldscope != default_scopes)
free ((void *) oldscope);
save_gaiconf_mtime (&st);
}
else
{
no_file:
free_prefixlist (labellist);
free_prefixlist (precedencelist);
free_scopelist (scopelist);
/* If we previously read the file but it is gone now, free the
old data and use the builtin one. Leave the reload flag
alone. */
fini ();
}
}
static void
gaiconf_reload (void)
{
struct stat64 st;
if (__xstat64 (_STAT_VER, GAICONF_FNAME, &st) != 0
|| !check_gaiconf_mtime (&st))
gaiconf_init ();
}
int
getaddrinfo (const char *name, const char *service,
const struct addrinfo *hints, struct addrinfo **pai)
{
int i = 0, last_i = 0;
int nresults = 0;
struct addrinfo *p = NULL;
struct gaih_service gaih_service, *pservice;
struct addrinfo local_hints;
if (name != NULL && name[0] == '*' && name[1] == 0)
name = NULL;
if (service != NULL && service[0] == '*' && service[1] == 0)
service = NULL;
if (name == NULL && service == NULL)
return EAI_NONAME;
if (hints == NULL)
hints = &default_hints;
if (hints->ai_flags
& ~(AI_PASSIVE|AI_CANONNAME|AI_NUMERICHOST|AI_ADDRCONFIG|AI_V4MAPPED
#ifdef HAVE_LIBIDN
|AI_IDN|AI_CANONIDN|AI_IDN_ALLOW_UNASSIGNED
|AI_IDN_USE_STD3_ASCII_RULES
#endif
|AI_NUMERICSERV|AI_ALL))
return EAI_BADFLAGS;
if ((hints->ai_flags & AI_CANONNAME) && name == NULL)
return EAI_BADFLAGS;
struct in6addrinfo *in6ai = NULL;
size_t in6ailen = 0;
bool seen_ipv4 = false;
bool seen_ipv6 = false;
bool check_pf_called = false;
if (hints->ai_flags & AI_ADDRCONFIG)
{
/* We might need information about what interfaces are available.
Also determine whether we have IPv4 or IPv6 interfaces or both. We
cannot cache the results since new interfaces could be added at
any time. */
__check_pf (&seen_ipv4, &seen_ipv6, &in6ai, &in6ailen);
check_pf_called = true;
/* Now make a decision on what we return, if anything. */
if (hints->ai_family == PF_UNSPEC && (seen_ipv4 || seen_ipv6))
{
/* If we haven't seen both IPv4 and IPv6 interfaces we can
narrow down the search. */
if ((! seen_ipv4 || ! seen_ipv6) && (seen_ipv4 || seen_ipv6))
{
local_hints = *hints;
local_hints.ai_family = seen_ipv4 ? PF_INET : PF_INET6;
hints = &local_hints;
}
}
else if ((hints->ai_family == PF_INET && ! seen_ipv4)
|| (hints->ai_family == PF_INET6 && ! seen_ipv6))
{
/* We cannot possibly return a valid answer. */
__free_in6ai (in6ai);
return EAI_NONAME;
}
}
if (service && service[0])
{
char *c;
gaih_service.name = service;
gaih_service.num = strtoul (gaih_service.name, &c, 10);
if (*c != '\0')
{
if (hints->ai_flags & AI_NUMERICSERV)
{
__free_in6ai (in6ai);
return EAI_NONAME;
}
gaih_service.num = -1;
}
pservice = &gaih_service;
}
else
pservice = NULL;
struct addrinfo **end = &p;
unsigned int naddrs = 0;
if (hints->ai_family == AF_UNSPEC || hints->ai_family == AF_INET
|| hints->ai_family == AF_INET6)
{
struct scratch_buffer tmpbuf;
scratch_buffer_init (&tmpbuf);
last_i = gaih_inet (name, pservice, hints, end, &naddrs, &tmpbuf);
scratch_buffer_free (&tmpbuf);
if (last_i != 0)
{
freeaddrinfo (p);
__free_in6ai (in6ai);
return -last_i;
}
while (*end)
{
end = &((*end)->ai_next);
++nresults;
}
}
else
{
__free_in6ai (in6ai);
return EAI_FAMILY;
}
if (naddrs > 1)
{
/* Read the config file. */
__libc_once_define (static, once);
__typeof (once) old_once = once;
__libc_once (once, gaiconf_init);
/* Sort results according to RFC 3484. */
struct sort_result *results;
size_t *order;
struct addrinfo *q;
struct addrinfo *last = NULL;
char *canonname = NULL;
bool malloc_results;
size_t alloc_size = nresults * (sizeof (*results) + sizeof (size_t));
malloc_results
= !__libc_use_alloca (alloc_size);
if (malloc_results)
{
results = malloc (alloc_size);
if (results == NULL)
{
__free_in6ai (in6ai);
return EAI_MEMORY;
}
}
else
results = alloca (alloc_size);
order = (size_t *) (results + nresults);
/* Now we definitely need the interface information. */
if (! check_pf_called)
__check_pf (&seen_ipv4, &seen_ipv6, &in6ai, &in6ailen);
/* If we have information about deprecated and temporary addresses
sort the array now. */
if (in6ai != NULL)
qsort (in6ai, in6ailen, sizeof (*in6ai), in6aicmp);
int fd = -1;
int af = AF_UNSPEC;
for (i = 0, q = p; q != NULL; ++i, last = q, q = q->ai_next)
{
results[i].dest_addr = q;
results[i].native = -1;
order[i] = i;
/* If we just looked up the address for a different
protocol, reuse the result. */
if (last != NULL && last->ai_addrlen == q->ai_addrlen
&& memcmp (last->ai_addr, q->ai_addr, q->ai_addrlen) == 0)
{
memcpy (&results[i].source_addr, &results[i - 1].source_addr,
results[i - 1].source_addr_len);
results[i].source_addr_len = results[i - 1].source_addr_len;
results[i].got_source_addr = results[i - 1].got_source_addr;
results[i].source_addr_flags = results[i - 1].source_addr_flags;
results[i].prefixlen = results[i - 1].prefixlen;
results[i].index = results[i - 1].index;
}
else
{
results[i].got_source_addr = false;
results[i].source_addr_flags = 0;
results[i].prefixlen = 0;
results[i].index = 0xffffffffu;
/* We overwrite the type with SOCK_DGRAM since we do not
want connect() to connect to the other side. If we
cannot determine the source address remember this
fact. */
if (fd == -1 || (af == AF_INET && q->ai_family == AF_INET6))
{
if (fd != -1)
close_retry:
close_not_cancel_no_status (fd);
af = q->ai_family;
fd = __socket (af, SOCK_DGRAM, IPPROTO_IP);
}
else
{
/* Reset the connection. */
struct sockaddr sa = { .sa_family = AF_UNSPEC };
__connect (fd, &sa, sizeof (sa));
}
socklen_t sl = sizeof (results[i].source_addr);
if (fd != -1
&& __connect (fd, q->ai_addr, q->ai_addrlen) == 0
&& __getsockname (fd,
(struct sockaddr *) &results[i].source_addr,
&sl) == 0)
{
results[i].source_addr_len = sl;
results[i].got_source_addr = true;
if (in6ai != NULL)
{
/* See whether the source address is on the list of
deprecated or temporary addresses. */
struct in6addrinfo tmp;
if (q->ai_family == AF_INET && af == AF_INET)
{
struct sockaddr_in *sinp
= (struct sockaddr_in *) &results[i].source_addr;
tmp.addr[0] = 0;
tmp.addr[1] = 0;
tmp.addr[2] = htonl (0xffff);
/* Special case for lo interface, the source address
being possibly different than the interface
address. */
if ((ntohl(sinp->sin_addr.s_addr) & 0xff000000)
== 0x7f000000)
tmp.addr[3] = htonl(0x7f000001);
else
tmp.addr[3] = sinp->sin_addr.s_addr;
}
else
{
struct sockaddr_in6 *sin6p
= (struct sockaddr_in6 *) &results[i].source_addr;
memcpy (tmp.addr, &sin6p->sin6_addr, IN6ADDRSZ);
}
struct in6addrinfo *found
= bsearch (&tmp, in6ai, in6ailen, sizeof (*in6ai),
in6aicmp);
if (found != NULL)
{
results[i].source_addr_flags = found->flags;
results[i].prefixlen = found->prefixlen;
results[i].index = found->index;
}
}
if (q->ai_family == AF_INET && af == AF_INET6)
{
/* We have to convert the address. The socket is
IPv6 and the request is for IPv4. */
struct sockaddr_in6 *sin6
= (struct sockaddr_in6 *) &results[i].source_addr;
struct sockaddr_in *sin
= (struct sockaddr_in *) &results[i].source_addr;
assert (IN6_IS_ADDR_V4MAPPED (sin6->sin6_addr.s6_addr32));
sin->sin_family = AF_INET;
/* We do not have to initialize sin_port since this
fields has the same position and size in the IPv6
structure. */
assert (offsetof (struct sockaddr_in, sin_port)
== offsetof (struct sockaddr_in6, sin6_port));
assert (sizeof (sin->sin_port)
== sizeof (sin6->sin6_port));
memcpy (&sin->sin_addr,
&sin6->sin6_addr.s6_addr32[3], INADDRSZ);
results[i].source_addr_len = sizeof (struct sockaddr_in);
}
}
else if (errno == EAFNOSUPPORT && af == AF_INET6
&& q->ai_family == AF_INET)
/* This could mean IPv6 sockets are IPv6-only. */
goto close_retry;
else
/* Just make sure that if we have to process the same
address again we do not copy any memory. */
results[i].source_addr_len = 0;
}
/* Remember the canonical name. */
if (q->ai_canonname != NULL)
{
assert (canonname == NULL);
canonname = q->ai_canonname;
q->ai_canonname = NULL;
}
}
if (fd != -1)
close_not_cancel_no_status (fd);
/* We got all the source addresses we can get, now sort using
the information. */
struct sort_result_combo src
= { .results = results, .nresults = nresults };
if (__glibc_unlikely (gaiconf_reload_flag_ever_set))
{
__libc_lock_define_initialized (static, lock);
__libc_lock_lock (lock);
if (__libc_once_get (old_once) && gaiconf_reload_flag)
gaiconf_reload ();
__qsort_r (order, nresults, sizeof (order[0]), rfc3484_sort, &src);
__libc_lock_unlock (lock);
}
else
__qsort_r (order, nresults, sizeof (order[0]), rfc3484_sort, &src);
/* Queue the results up as they come out of sorting. */
q = p = results[order[0]].dest_addr;
for (i = 1; i < nresults; ++i)
q = q->ai_next = results[order[i]].dest_addr;
q->ai_next = NULL;
/* Fill in the canonical name into the new first entry. */
p->ai_canonname = canonname;
if (malloc_results)
free (results);
}
__free_in6ai (in6ai);
if (p)
{
*pai = p;
return 0;
}
return last_i ? -last_i : EAI_NONAME;
}
libc_hidden_def (getaddrinfo)
nss_interface_function (getaddrinfo)
void
freeaddrinfo (struct addrinfo *ai)
{
struct addrinfo *p;
while (ai != NULL)
{
p = ai;
ai = ai->ai_next;
free (p->ai_canonname);
free (p);
}
}
libc_hidden_def (freeaddrinfo)
| 25.947269 | 79 | 0.597175 | [
"object",
"transform"
] |
43eeeec230cef58fc6b8107957942a0ac68c2c4b | 20,720 | c | C | res/unzip-5.52/windll/windll.c | tsee/p5-Archive-Unzip-Burst | b13db7b97b216cc91bff49636d4c764c10414625 | [
"Info-ZIP"
] | 1 | 2015-01-14T20:11:52.000Z | 2015-01-14T20:11:52.000Z | res/unzip-5.52/windll/windll.c | tsee/p5-Archive-Unzip-Burst | b13db7b97b216cc91bff49636d4c764c10414625 | [
"Info-ZIP"
] | null | null | null | res/unzip-5.52/windll/windll.c | tsee/p5-Archive-Unzip-Burst | b13db7b97b216cc91bff49636d4c764c10414625 | [
"Info-ZIP"
] | null | null | null | /*
Copyright (c) 1990-2005 Info-ZIP. All rights reserved.
See the accompanying file LICENSE, version 2000-Apr-09 or later
(the contents of which are also included in unzip.h) for terms of use.
If, for some reason, all these files are missing, the Info-ZIP license
also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
*/
/* Windows Info-ZIP Unzip DLL module
*
* Author: Mike White
*
* Original: 1996
*
* This module has the entry points for "unzipping" a zip file.
*/
/*---------------------------------------------------------------------------
This file is the WINDLL replacement for the generic ``main program source
file'' unzip.c.
See the general comments in the header part of unzip.c.
Copyrights: see accompanying file "COPYING" in UnZip source distribution.
(This software is free but NOT IN THE PUBLIC DOMAIN. There
are some restrictions on commercial use.)
---------------------------------------------------------------------------*/
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#ifdef __RSXNT__
# include "../win32/rsxntwin.h"
#endif
#ifdef __BORLANDC__
#include <dir.h>
#endif
#define UNZIP_INTERNAL
#include "../unzip.h"
#include "../crypt.h"
#include "../unzvers.h"
#include "../windll/windll.h"
#include "../windll/structs.h"
#include "../consts.h"
/* Added type casts to prevent potential "type mismatch" error messages. */
#ifdef REENTRANT
# undef __G
# undef __G__
# define __G (Uz_Globs *)pG
# define __G__ (Uz_Globs *)pG,
#endif
HANDLE hwildZipFN;
HANDLE hInst; /* current instance */
HANDLE hDCL;
int fNoPrinting = 0;
extern jmp_buf dll_error_return;
/* Helper function to release memory allocated by Wiz_SetOpts() */
static void FreeDllMem(__GPRO);
/* For displaying status messages and error messages */
static int UZ_EXP DllMessagePrint(zvoid *pG, uch *buf, ulg size, int flag);
#if 0 /* currently unused */
/* For displaying files extracted to the display window */
int DllDisplayPrint(zvoid *pG, uch *buf, ulg size, int flag);
#endif /* never */
/* Callback function for status report and/or user interception */
static int UZ_EXP Wiz_StatReportCB(zvoid *pG, int fnflag, ZCONST char *zfn,
ZCONST char *efn, ZCONST zvoid *details);
/* Dummy sound function for those applications that don't use sound */
static void WINAPI DummySound(void);
#ifndef UNZIPLIB
/* DLL Entry Point */
#ifdef __BORLANDC__
#pragma argsused
/* Borland seems to want DllEntryPoint instead of DllMain like MSVC */
#define DllMain DllEntryPoint
#endif
#ifdef WIN32
BOOL WINAPI DllMain( HINSTANCE hInstance,
DWORD dwReason,
LPVOID plvReserved)
#else
int FAR PASCAL LibMain( HINSTANCE hInstance,
WORD wDataSegment,
WORD wHeapSize,
LPSTR lpszCmdLine )
#endif
{
#ifndef WIN32
/* The startup code for the DLL initializes the local heap(if there is one)
* with a call to LocalInit which locks the data segment.
*/
if ( wHeapSize != 0 )
{
UnlockData( 0 );
}
hInst = hInstance;
return 1; /* Indicate that the DLL was initialized successfully. */
#else
BOOL rc = TRUE;
switch( dwReason )
{
case DLL_PROCESS_ATTACH:
// DLL is loaded. Do your initialization here.
// If cannot init, set rc to FALSE.
hInst = hInstance;
break;
case DLL_PROCESS_DETACH:
// DLL is unloaded. Do your cleanup here.
break;
default:
break;
}
return rc;
#endif
}
#ifdef __BORLANDC__
#pragma argsused
#endif
int FAR PASCAL WEP ( int bSystemExit )
{
return 1;
}
#endif /* !UNZIPLIB */
/* DLL calls */
BOOL WINAPI Wiz_Init(pG, lpUserFunc)
zvoid *pG;
LPUSERFUNCTIONS lpUserFunc;
{
G.message = DllMessagePrint;
G.statreportcb = Wiz_StatReportCB;
if (lpUserFunc->sound == NULL)
lpUserFunc->sound = DummySound;
G.lpUserFunctions = lpUserFunc;
SETLOCALE(LC_CTYPE, "");
if (!G.lpUserFunctions->print ||
!G.lpUserFunctions->sound ||
!G.lpUserFunctions->replace)
return FALSE;
return TRUE;
}
/*
ExtractOnlyNewer = true for "update" without interaction
(extract only newer/new files, without queries)
SpaceToUnderscore = true if convert space to underscore
PromptToOverwrite = true if prompt to overwrite is wanted
fQuiet = quiet flag:
0 = all messages, 1 = few messages, 2 = no messages
ncflag = write to stdout if true
ntflag = test zip file
nvflag = verbose listing
nfflag = "freshen" (replace existing files by newer versions)
nzflag = display zip file comment
ndflag = controls (sub)directory recreation during extraction
0 = junk paths from filenames
1 = "safe" usage of paths in filenames (skip "../")
2 = allow also unsafe path components (dir traversal)
noflag = true if you are to always overwrite existing files
naflag = do end-of-line translation
nZIflag = get ZipInfo if TRUE
C_flag = be case insensitive if TRUE
fPrivilege = 1 => restore ACLs in user mode,
2 => try to use privileges for restoring ACLs
lpszZipFN = zip file name
lpszExtractDir = directory to extract to. This should be NULL if you
are extracting to the current directory.
*/
BOOL WINAPI Wiz_SetOpts(pG, lpDCL)
zvoid *pG;
LPDCL lpDCL;
{
uO.qflag = lpDCL->fQuiet; /* Quiet flag */
G.pfnames = (char **)&fnames[0]; /* assign default file name vector */
G.pxnames = (char **)&fnames[1];
uO.jflag = (lpDCL->ndflag == 0);
uO.ddotflag = (lpDCL->ndflag >= 2);
uO.cflag = lpDCL->ncflag;
uO.tflag = lpDCL->ntflag;
uO.vflag = lpDCL->nvflag;
uO.zflag = lpDCL->nzflag;
uO.aflag = lpDCL->naflag;
uO.C_flag = lpDCL->C_flag;
uO.overwrite_all = lpDCL->noflag;
uO.overwrite_none = !(lpDCL->noflag || lpDCL->PromptToOverwrite);
uO.uflag = lpDCL->ExtractOnlyNewer || lpDCL->nfflag;
uO.fflag = lpDCL->nfflag;
#ifdef WIN32
uO.X_flag = lpDCL->fPrivilege;
#endif
uO.sflag = lpDCL->SpaceToUnderscore; /* Translate spaces to underscores? */
if (lpDCL->nZIflag)
{
uO.zipinfo_mode = TRUE;
uO.hflag = TRUE;
uO.lflag = 10;
uO.qflag = 2;
}
else
{
uO.zipinfo_mode = FALSE;
}
G.extract_flag = (!uO.zipinfo_mode &&
!uO.cflag && !uO.tflag && !uO.vflag && !uO.zflag
#ifdef TIMESTAMP
&& !uO.T_flag
#endif
);
if (lpDCL->lpszExtractDir != NULL && G.extract_flag)
{
#ifndef CRTL_CP_IS_ISO
char *pExDirRoot = (char *)malloc(strlen(lpDCL->lpszExtractDir)+1);
if (pExDirRoot == NULL)
return FALSE;
ISO_TO_INTERN(lpDCL->lpszExtractDir, pExDirRoot);
#else
# define pExDirRoot lpDCL->lpszExtractDir
#endif
uO.exdir = pExDirRoot;
}
else
{
uO.exdir = (char *)NULL;
}
/* G.wildzipfn needs to be initialized so that do_wild does not wind
up clearing out the zip file name when it returns in process.c
*/
hwildZipFN = GlobalAlloc(GPTR, FILNAMSIZ);
if (hwildZipFN == (HGLOBAL) NULL)
return FALSE;
G.wildzipfn = GlobalLock(hwildZipFN);
lstrcpy(G.wildzipfn, lpDCL->lpszZipFN);
_ISO_INTERN(G.wildzipfn);
return TRUE; /* set up was OK */
}
static void FreeDllMem(__GPRO)
{
if (G.wildzipfn) {
GlobalUnlock(hwildZipFN);
G.wildzipfn = NULL;
}
if (hwildZipFN)
hwildZipFN = GlobalFree(hwildZipFN);
uO.zipinfo_mode = FALSE;
}
int WINAPI Wiz_Unzip(pG, ifnc, ifnv, xfnc, xfnv)
zvoid *pG;
int ifnc;
char **ifnv;
int xfnc;
char **xfnv;
{
int retcode, f_cnt;
#ifndef CRTL_CP_IS_ISO
char **intern_ifv = NULL, **intern_xfv = NULL;
#endif
if (ifnv == (char **)NULL && ifnc != 0)
ifnc = 0;
else
for (f_cnt = 0; f_cnt < ifnc; f_cnt++)
if (ifnv[f_cnt] == (char *)NULL) {
ifnc = f_cnt;
break;
}
if (xfnv == (char **)NULL && xfnc != 0)
xfnc = 0;
else
for (f_cnt = 0; f_cnt < xfnc; f_cnt++)
if (xfnv[f_cnt] == (char *)NULL) {
xfnc = f_cnt;
break;
}
G.process_all_files = (ifnc == 0 && xfnc == 0); /* for speed */
G.filespecs = ifnc;
G.xfilespecs = xfnc;
if (ifnc > 0) {
#ifdef CRTL_CP_IS_ISO
G.pfnames = ifnv;
#else /* !CRTL_CP_IS_ISO */
unsigned bufsize = 0;
intern_ifv = (char **)malloc((ifnc+1)*sizeof(char **));
if (intern_ifv == (char **)NULL)
{
FreeDllMem(__G);
return PK_BADERR;
}
for (f_cnt = ifnc; --f_cnt >= 0;)
bufsize += strlen(ifnv[f_cnt]) + 1;
intern_ifv[0] = (char *)malloc(bufsize);
if (intern_ifv[0] == (char *)NULL)
{
free(intern_ifv);
FreeDllMem(__G);
return PK_BADERR;
}
for (f_cnt = 0; ; f_cnt++)
{
ISO_TO_INTERN(ifnv[f_cnt], intern_ifv[f_cnt]);
if ((f_cnt+1) >= ifnc)
break;
intern_ifv[f_cnt+1] = intern_ifv[f_cnt] +
(strlen(intern_ifv[f_cnt]) + 1);
}
intern_ifv[ifnc] = (char *)NULL;
G.pfnames = intern_ifv;
#endif /* ?CRTL_CP_IS_ISO */
}
if (xfnc > 0) {
#ifdef CRTL_CP_IS_ISO
G.pxnames = xfnv;
#else /* !CRTL_CP_IS_ISO */
unsigned bufsize = 0;
intern_xfv = (char **)malloc((xfnc+1)*sizeof(char **));
if (intern_xfv == (char **)NULL)
{
if (ifnc > 0)
{
free(intern_ifv[0]);
free(intern_ifv);
}
FreeDllMem(__G);
return PK_BADERR;
}
for (f_cnt = xfnc; --f_cnt >= 0;)
bufsize += strlen(xfnv[f_cnt]) + 1;
intern_xfv[0] = (char *)malloc(bufsize);
if (intern_xfv[0] == (char *)NULL)
{
free(intern_xfv);
if (ifnc > 0)
{
free(intern_ifv[0]);
free(intern_ifv);
}
FreeDllMem(__G);
return PK_BADERR;
}
for (f_cnt = 0; ; f_cnt++)
{
ISO_TO_INTERN(xfnv[f_cnt], intern_xfv[f_cnt]);
if ((f_cnt+1) >= xfnc)
break;
intern_xfv[f_cnt+1] = intern_xfv[f_cnt] +
(strlen(intern_xfv[f_cnt]) + 1);
}
intern_xfv[xfnc] = (char *)NULL;
G.pxnames = intern_xfv;
#endif /* ?CRTL_CP_IS_ISO */
}
/*---------------------------------------------------------------------------
Okey dokey, we have everything we need to get started. Let's roll.
---------------------------------------------------------------------------*/
retcode = setjmp(dll_error_return);
if (retcode)
{
#ifndef CRTL_CP_IS_ISO
if (xfnc > 0)
{
free(intern_xfv[0]);
free(intern_xfv);
}
if (ifnc > 0)
{
free(intern_ifv[0]);
free(intern_ifv);
}
#endif
FreeDllMem(__G);
return PK_BADERR;
}
retcode = process_zipfiles(__G);
#ifndef CRTL_CP_IS_ISO
if (xfnc > 0)
{
free(intern_xfv[0]);
free(intern_xfv);
}
if (ifnc > 0)
{
free(intern_ifv[0]);
free(intern_ifv);
}
#endif
FreeDllMem(__G);
return retcode;
}
int WINAPI Wiz_SingleEntryUnzip(int ifnc, char **ifnv, int xfnc, char **xfnv,
LPDCL lpDCL, LPUSERFUNCTIONS lpUserFunc)
{
int retcode;
CONSTRUCTGLOBALS();
if (!Wiz_Init((zvoid *)&G, lpUserFunc))
{
DESTROYGLOBALS();
return PK_BADERR;
}
if (lpDCL->lpszZipFN == NULL)
{
/* Something has screwed up, we don't have a filename */
DESTROYGLOBALS();
return PK_NOZIP;
}
if (!Wiz_SetOpts((zvoid *)&G, lpDCL))
{
DESTROYGLOBALS();
return PK_MEM;
}
#ifdef SFX
G.zipfn = lpDCL->lpszZipFN;
G.argv0 = lpDCL->lpszZipFN;
#endif
/* Here is the actual call to "unzip" the files (or whatever else you
* are doing.)
*/
retcode = Wiz_Unzip((zvoid *)&G, ifnc, ifnv, xfnc, xfnv);
DESTROYGLOBALS();
return retcode;
}
int win_fprintf(zvoid *pG, FILE *file, unsigned int size, char far *buffer)
{
if ((file != stderr) && (file != stdout))
{
return write(fileno(file),(char far *)(buffer),size);
}
if (!fNoPrinting)
return G.lpUserFunctions->print((LPSTR)buffer, size);
return (int)size;
}
/**********************************
* Function DllMessagePrint() *
* *
* Send messages to status window *
**********************************/
#ifdef __BORLANDC__
#pragma argsused
#endif
static int UZ_EXP DllMessagePrint(pG, buf, size, flag)
zvoid *pG; /* globals struct: always passed */
uch *buf; /* preformatted string to be printed */
ulg size; /* length of string (may include nulls) */
int flag; /* flag bits */
{
if (!fNoPrinting)
return G.lpUserFunctions->print((LPSTR)buf, size);
else
return (int)size;
}
#if 0 /* currently unused */
/********************************
* Function DllDisplayPrint() *
* *
* Send files to display window *
********************************/
#ifdef __BORLANDC__
#pragma argsused
#endif
int DllDisplayPrint(pG, buf, size, flag)
zvoid *pG; /* globals struct: always passed */
uch *buf; /* preformatted string to be printed */
ulg size; /* length of string (may include nulls) */
int flag; /* flag bits */
{
return (!fNoPrinting ? G.lpUserFunctions->print((LPSTR)buf, size) : (int)size);
}
#endif /* never */
/**********************************
* Function UzpPassword() *
* *
* Prompt for decryption password *
**********************************/
#ifdef __BORLANDC__
#pragma argsused
#endif
int UZ_EXP UzpPassword(pG, rcnt, pwbuf, size, zfn, efn)
zvoid *pG; /* globals struct: always passed */
int *rcnt; /* retry counter */
char *pwbuf; /* buffer for password */
int size; /* size of password buffer */
ZCONST char *zfn; /* name of zip archiv */
ZCONST char *efn; /* name of archiv entry being processed */
{
#if CRYPT
LPSTR m;
if (*rcnt == 0) {
*rcnt = 2;
m = "Enter password for: ";
} else {
(*rcnt)--;
m = "Password incorrect--reenter: ";
}
return (*G.lpUserFunctions->password)((LPSTR)pwbuf, size, m, (LPSTR)efn);
#else /* !CRYPT */
return IZ_PW_ERROR; /* internal error, function should never get called */
#endif /* ?CRYPT */
} /* end function UzpPassword() */
/* Turn off all messages to the calling application */
void WINAPI Wiz_NoPrinting(int f)
{
fNoPrinting = f;
}
/* Dummy sound function for those applications that don't use sound */
static void WINAPI DummySound(void)
{
}
/* Interface between WINDLL specific service callback functions and the
generic DLL's "status report & user interception" callback */
#ifdef __BORLANDC__
#pragma argsused
#endif
static int WINAPI Wiz_StatReportCB(zvoid *pG, int fnflag, ZCONST char *zfn,
ZCONST char *efn, ZCONST zvoid *details)
{
int rval = UZ_ST_CONTINUE;
switch (fnflag) {
case UZ_ST_START_EXTRACT:
if (G.lpUserFunctions->sound != NULL)
(*G.lpUserFunctions->sound)();
break;
case UZ_ST_FINISH_MEMBER:
if ((G.lpUserFunctions->ServCallBk != NULL) &&
(*G.lpUserFunctions->ServCallBk)(efn,
(details == NULL ? 0L :
*((unsigned long *)details))))
rval = UZ_ST_BREAK;
break;
case UZ_ST_IN_PROGRESS:
break;
default:
break;
}
return rval;
}
#ifndef SFX
#ifndef __16BIT__
int WINAPI Wiz_UnzipToMemory(LPSTR zip, LPSTR file,
LPUSERFUNCTIONS lpUserFunctions, UzpBuffer *retstr)
{
int r;
#ifndef CRTL_CP_IS_ISO
char *intern_zip, *intern_file;
#endif
CONSTRUCTGLOBALS();
#ifndef CRTL_CP_IS_ISO
intern_zip = (char *)malloc(strlen(zip)+1);
if (intern_zip == NULL) {
DESTROYGLOBALS();
return PK_MEM;
}
intern_file = (char *)malloc(strlen(file)+1);
if (intern_file == NULL) {
DESTROYGLOBALS();
free(intern_zip);
return PK_MEM;
}
ISO_TO_INTERN(zip, intern_zip);
ISO_TO_INTERN(file, intern_file);
# define zip intern_zip
# define file intern_file
#endif
if (!Wiz_Init((zvoid *)&G, lpUserFunctions)) {
DESTROYGLOBALS();
return PK_BADERR;
}
G.redirect_data = 1;
r = (unzipToMemory(__G__ zip, file, retstr) == PK_COOL);
DESTROYGLOBALS();
#ifndef CRTL_CP_IS_ISO
# undef file
# undef zip
free(intern_file);
free(intern_zip);
#endif
if (!r && retstr->strlength) {
free(retstr->strptr);
retstr->strptr = NULL;
}
return r;
}
/* Purpose: Determine if file in archive contains the string szSearch
Parameters: archive = archive name
file = file contained in the archive. This cannot be
a wild card to be meaningful
pattern = string to search for
cmd = 0 - case-insensitive search
1 - case-sensitve search
2 - case-insensitive, whole words only
3 - case-sensitive, whole words only
SkipBin = if true, skip any files that have control
characters other than CR, LF, or tab in the first
100 characters.
Returns: TRUE if a match is found
FALSE if no match is found
-1 on error
Comments: This does not pretend to be as useful as the standard
Unix grep, which returns the strings associated with a
particular pattern, nor does it search past the first
matching occurrence of the pattern.
*/
int WINAPI Wiz_Grep(LPSTR archive, LPSTR file, LPSTR pattern, int cmd,
int SkipBin, LPUSERFUNCTIONS lpUserFunctions)
{
int retcode = FALSE, compare;
ulg i, j, patternLen, buflen;
char * sz, *p;
UzpBuffer retstr;
/* Turn off any windows printing functions, as they may not have been
* identified yet. There is no requirement that we initialize the
* dll with printing stuff for this. */
Wiz_NoPrinting(TRUE);
if (!Wiz_UnzipToMemory(archive, file, lpUserFunctions, &retstr)) {
Wiz_NoPrinting(FALSE);
return -1; /* not enough memory, file not found, or other error */
}
if (SkipBin) {
if (retstr.strlength < 100)
buflen = retstr.strlength;
else
buflen = 100;
for (i = 0; i < buflen; i++) {
if (iscntrl(retstr.strptr[i])) {
if ((retstr.strptr[i] != 0x0A) &&
(retstr.strptr[i] != 0x0D) &&
(retstr.strptr[i] != 0x09))
{
/* OK, we now think we have a binary file of some sort */
free(retstr.strptr);
Wiz_NoPrinting(FALSE);
return FALSE;
}
}
}
}
patternLen = strlen(pattern);
if (retstr.strlength < patternLen) {
free(retstr.strptr);
Wiz_NoPrinting(FALSE);
return FALSE;
}
sz = malloc(patternLen + 3); /* add two in case doing whole words only */
if (cmd > 1) {
strcpy(sz, " ");
strcat(sz, pattern);
strcat(sz, " ");
} else
strcpy(sz, pattern);
if ((cmd == 0) || (cmd == 2)) {
for (i = 0; i < strlen(sz); i++)
sz[i] = toupper(sz[i]);
for (i = 0; i < retstr.strlength; i++)
retstr.strptr[i] = toupper(retstr.strptr[i]);
}
for (i = 0; i < (retstr.strlength - patternLen); i++) {
p = &retstr.strptr[i];
compare = TRUE;
for (j = 0; j < patternLen; j++) {
/* We cannot do strncmp here, as we may be dealing with a
* "binary" file, such as a word processing file, or perhaps
* even a true executable of some sort. */
if (p[j] != sz[j]) {
compare = FALSE;
break;
}
}
if (compare == TRUE) {
retcode = TRUE;
break;
}
}
free(sz);
free(retstr.strptr);
Wiz_NoPrinting(FALSE); /* Turn printing back on */
return retcode;
}
#endif /* !__16BIT__ */
int WINAPI Wiz_Validate(LPSTR archive, int AllCodes)
{
return UzpValidate((char *)archive, AllCodes);
}
#endif /* !SFX */
| 27.049608 | 79 | 0.570415 | [
"vector"
] |
43f35500e1a56063d4c079203f5a51debb72611f | 2,339 | h | C | third_party/WebKit/Source/core/animation/InterpolationEffect.h | Wzzzx/chromium-crosswalk | 768dde8efa71169f1c1113ca6ef322f1e8c9e7de | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 2 | 2019-01-28T08:09:58.000Z | 2021-11-15T15:32:10.000Z | third_party/WebKit/Source/core/animation/InterpolationEffect.h | Wzzzx/chromium-crosswalk | 768dde8efa71169f1c1113ca6ef322f1e8c9e7de | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | third_party/WebKit/Source/core/animation/InterpolationEffect.h | Wzzzx/chromium-crosswalk | 768dde8efa71169f1c1113ca6ef322f1e8c9e7de | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 6 | 2020-09-23T08:56:12.000Z | 2021-11-18T03:40:49.000Z | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef InterpolationEffect_h
#define InterpolationEffect_h
#include "core/CoreExport.h"
#include "core/animation/Interpolation.h"
#include "core/animation/Keyframe.h"
#include "platform/RuntimeEnabledFeatures.h"
#include "platform/animation/TimingFunction.h"
namespace blink {
// Stores all adjacent pairs of keyframes (represented by Interpolations) in a KeyframeEffectModel
// with keyframe offset data preprocessed for more efficient active keyframe pair sampling.
class CORE_EXPORT InterpolationEffect {
DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
public:
InterpolationEffect()
: m_isPopulated(false)
{ }
bool isPopulated() const { return m_isPopulated; }
void setPopulated() { m_isPopulated = true; }
void clear()
{
m_isPopulated = false;
m_interpolations.clear();
}
void getActiveInterpolations(double fraction, double iterationDuration, Vector<RefPtr<Interpolation>>&) const;
void addInterpolation(PassRefPtr<Interpolation> interpolation, PassRefPtr<TimingFunction> easing, double start, double end, double applyFrom, double applyTo)
{
m_interpolations.append(InterpolationRecord(interpolation, easing, start, end, applyFrom, applyTo));
}
void addInterpolationsFromKeyframes(PropertyHandle, const Keyframe::PropertySpecificKeyframe& keyframeA, const Keyframe::PropertySpecificKeyframe& keyframeB, double applyFrom, double applyTo);
private:
struct InterpolationRecord {
InterpolationRecord(PassRefPtr<Interpolation> interpolation, PassRefPtr<TimingFunction> easing, double start, double end, double applyFrom, double applyTo)
: m_interpolation(interpolation)
, m_easing(easing)
, m_start(start)
, m_end(end)
, m_applyFrom(applyFrom)
, m_applyTo(applyTo)
{ }
RefPtr<Interpolation> m_interpolation;
RefPtr<TimingFunction> m_easing;
double m_start;
double m_end;
double m_applyFrom;
double m_applyTo;
};
bool m_isPopulated;
Vector<InterpolationRecord> m_interpolations;
};
} // namespace blink
#endif // InterpolationEffect_h
| 33.898551 | 196 | 0.728089 | [
"vector"
] |
43f3e7c4546785348b28b6f551a66600877589d0 | 679 | h | C | Assignment 5/Assignment 5/Assignment 5/ship.h | justin-harper/cs122 | 83949bc097cf052ffe6b8bd82002377af4d9cede | [
"MIT"
] | null | null | null | Assignment 5/Assignment 5/Assignment 5/ship.h | justin-harper/cs122 | 83949bc097cf052ffe6b8bd82002377af4d9cede | [
"MIT"
] | null | null | null | Assignment 5/Assignment 5/Assignment 5/ship.h | justin-harper/cs122 | 83949bc097cf052ffe6b8bd82002377af4d9cede | [
"MIT"
] | null | null | null | #ifndef ship_h
#define ship_h
#include <vector>
#include <string>
#include <iostream>
#include "gameboard.h"
class Ship
{
public:
//~ship();
Ship();
Ship(int hits, char des, string name);
int getDamage() const;
int getHits() const;
void placeShip(GameBoard *board);
void actualyPlace(GameBoard *board, int x, int y, string dir);
void placeShipRandom(GameBoard *board);
bool check(GameBoard *board, int x, int y, int shipSize, string direction);
protected:
void setHit(int hits);
void increaseDamage(void);
void setDesignator(char des);
private:
int _hitPoints = 0;
int _damage = 0;
char _designator = '\0';
string _name = "";
};
#endif | 13.313725 | 76 | 0.684831 | [
"vector"
] |
43f773511b40c9f0d69016b89e660a4123fd22e9 | 22,017 | h | C | dev/Code/Framework/GridMate/GridMate/Replica/RemoteProcedureCall.h | CJoriginal/cjlumberyard | 2e3184a7d8e59ba05e5707371b8cb6fe40b0ca60 | [
"AML"
] | 8 | 2019-10-07T16:33:47.000Z | 2020-12-07T03:59:58.000Z | dev/Code/Framework/GridMate/GridMate/Replica/RemoteProcedureCall.h | santosh90n/lumberyard-1 | 9608bcf905bb60e9f326bd3fe8297381c22d83a6 | [
"AML"
] | null | null | null | dev/Code/Framework/GridMate/GridMate/Replica/RemoteProcedureCall.h | santosh90n/lumberyard-1 | 9608bcf905bb60e9f326bd3fe8297381c22d83a6 | [
"AML"
] | 5 | 2020-08-27T20:44:18.000Z | 2021-08-21T22:54:11.000Z | /*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#ifndef GM_REPLICA_RPC_H
#define GM_REPLICA_RPC_H
#include <AzCore/std/function/function_fwd.h>
#include <AzCore/Preprocessor/Sequences.h>
#include <AzCore/std/typetraits/is_base_of.h>
#include <AzCore/std/typetraits/remove_const.h>
#include <AzCore/std/typetraits/remove_reference.h>
#include <GridMate/Replica/Replica.h>
#include <GridMate/Replica/ReplicaChunk.h>
#include <GridMate/Replica/ReplicaChunkDescriptor.h>
#include <GridMate/Replica/ReplicaCommon.h>
#include <GridMate/Replica/ReplicaDefs.h>
#include <GridMate/Serialize/Buffer.h>
#include <GridMate/Serialize/DataMarshal.h>
namespace GridMate
{
class ReplicaMarshalTaskBase;
namespace Internal
{
struct RpcRequest;
struct InterfaceResolver;
}
struct RpcDefaultTraits
{
static const bool s_isReliable = true;
static const bool s_isPostAttached = true;
static const bool s_alwaysForwardSourcePeer = false;
static const bool s_allowNonAuthoritativeRequests = true;
static const bool s_allowNonAuthoritativeRequestRelay = true;
};
struct RpcAuthoritativeTraits : public RpcDefaultTraits
{
static const bool s_isReliable = true;
static const bool s_isPostAttached = true;
static const bool s_allowNonAuthoritativeRequests = false;
};
struct RpcUnreliable
: public RpcDefaultTraits
{
static const bool s_isReliable = false;
};
//--------------------------------------------------------------------------
// RpcContext
//--------------------------------------------------------------------------
struct RpcContext
{
unsigned int m_realTime;
unsigned int m_localTime;
AZ::u32 m_timestamp;
// The source peer is derived from the connection id, unless s_alwaysForwardSourcePeer is set for the RPC.
// This will be the 'expected' peer for a direct connection, but if forwarding is involved between
// peers, then the s_alwaysForwardSourcePeer should be set to ensure the source value is propagated
// across the network.
PeerId m_sourcePeer;
RpcContext(unsigned int realTime = 0,
unsigned int localTime = 0,
unsigned int timestamp = 0,
PeerId sourcePeer = InvalidReplicaPeerId)
: m_realTime(realTime)
, m_localTime(localTime)
, m_timestamp(timestamp)
, m_sourcePeer(sourcePeer)
{ }
};
//--------------------------------------------------------------------------
/**
* RPC argument container, used like Rpc<RpcArg<...>, RpcArg<...>>::BindInterface<Class, Method>...
*/
struct RpcArgBase { };
template<class T, class M = Marshaler<typename AZStd::remove_const<typename AZStd::remove_reference<T>::type>::type> >
struct RpcArg
: public RpcArgBase
{
typedef T Type;
typedef M MarshalerType;
};
/**
* RPC base class
*/
class RpcBase
{
friend Replica;
friend ReplicaChunkBase;
friend ReplicaChunkDescriptor;
friend ReplicaMarshalTaskBase;
friend Internal::InterfaceResolver;
protected:
RpcBase(const char* debugName);
public:
virtual ~RpcBase() { }
protected:
virtual void Marshal(WriteBuffer& wb, Internal::RpcRequest* request) = 0;
virtual Internal::RpcRequest* Unmarshal(ReadBuffer& rb) = 0;
virtual bool Invoke(Internal::RpcRequest* rpc) const = 0;
virtual bool IsPostAttached() const = 0; //Requires Data Sets updated before executing RPC
virtual bool IsAllowNonAuthoritativeRequests() const = 0;
virtual bool IsAllowNonAuthoritativeRequestsRelay() const = 0;
PeerId GetSourcePeerId();
void Queue(Internal::RpcRequest* context);
void OnRpcRequest(Internal::RpcRequest* rpc) const;
void OnRpcInvoke(Internal::RpcRequest* rpc) const;
ReplicaChunkBase* m_replicaChunk;
};
namespace Internal
{
// -- Internal RPC data ---------------------------
struct RpcRequest
: public RpcContext
{
GM_CLASS_ALLOCATOR(RpcRequest);
bool m_authoritative;
bool m_processed;
bool m_relayed;
bool m_reliable; // need to save reliability state as unreliable rpcs might be promoted to reliable (e.g. when unreliable rpc, called before reliable on the same frame)
RpcBase* m_rpc;
RpcRequest(RpcBase* rpc, unsigned int timestamp = 0, unsigned int realTime = 0, unsigned int localTime = 0, PeerId sourcePeer = InvalidReplicaPeerId)
: RpcContext(realTime, localTime, timestamp, sourcePeer)
, m_authoritative(false)
, m_processed(false)
, m_relayed(false)
, m_reliable(true)
, m_rpc(rpc)
{
AZ_Assert(m_rpc, "We require a valid RPCBase pointer!");
}
virtual ~RpcRequest() { }
};
// ------------------------------------------------
struct InterfaceResolver
{
template<class C, class T>
static C* GetInterface(T* object)
{
static_assert(AZStd::is_base_of<ReplicaChunkInterface, C>::value, "Class must inherit from ReplicaChunkInterface");
AZ_Assert(object, "Invalid handler");
AZ_Assert(object->m_replicaChunk, "Invalid replica chunk");
return static_cast<C*>(object->m_replicaChunk->GetHandler());
}
};
}
namespace Internal
{
// -- Static integer sequence ---------------------
// Used to unpack all values from a tuple at once
template<size_t ...>
struct StaticSequence { };
template<size_t N, size_t ... Indices>
struct GenerateStaticSequence
: GenerateStaticSequence<N - 1, N - 1, Indices...> { };
template<size_t ... Indices>
struct GenerateStaticSequence<0, Indices...>
{
typedef StaticSequence<Indices...> Type;
};
// ------------------------------------------------
// -- Convenience structures for extracting a type without wrapping it in RpcArg<T,M> ---------------------
template<typename T, typename = void>
struct RpcTypeExtraction;
template<typename T>
struct RpcTypeExtraction<T, typename AZStd::Utils::enable_if_c<AZStd::is_base_of<RpcArgBase, T>::value>::type>
{
using Type = typename T::Type;
using MarshalerType = typename T::MarshalerType;
};
template<typename T>
struct RpcTypeExtraction<T, typename AZStd::Utils::enable_if_c<!AZStd::is_base_of<RpcArgBase, T>::value>::type>
{
using Type = T;
using MarshalerType = Marshaler<T>;
};
// ------------------------------------------------
// -- Storage for Marshalers ---------------------
template<class ... Args>
struct VariadicMarshaler;
template<>
struct VariadicMarshaler<>
{
GM_CLASS_ALLOCATOR(VariadicMarshaler);
VariadicMarshaler() { }
};
template<class This, class ... Rest>
struct VariadicMarshaler<This, Rest...>
: public VariadicMarshaler<Rest...>
{
GM_CLASS_ALLOCATOR(VariadicMarshaler);
using ParentType = VariadicMarshaler<Rest...>;
using MarshalerType = typename RpcTypeExtraction<This>::MarshalerType;
VariadicMarshaler()
: ParentType() { }
template<typename ThisArg, typename ... RestArgs>
VariadicMarshaler(ThisArg&& marshaler, RestArgs&& ... args)
: ParentType(args ...)
, m_marshaler(marshaler) { }
MarshalerType m_marshaler;
};
// ------------------------------------------------
// -- Storage for RPC -----------------------------
template<class ... Args>
struct VariadicStorage;
template<>
struct VariadicStorage<>
: public Internal::RpcRequest
{
GM_CLASS_ALLOCATOR(VariadicStorage);
using MarshalerTuple = VariadicMarshaler<>;
using StaticArgSequence = Internal::GenerateStaticSequence<0>::Type;
VariadicStorage(RpcBase* rpc)
: RpcRequest(rpc) { }
VariadicStorage(RpcBase* rpc, const RpcContext& ctx)
: RpcRequest(rpc, ctx.m_timestamp, ctx.m_realTime, ctx.m_localTime, ctx.m_sourcePeer) { }
bool Marshal(WriteBuffer&, const VariadicMarshaler<>&) const
{
return true;
}
bool Unmarshal(ReadBuffer&, const VariadicMarshaler<>&)
{
return true;
}
};
template<class This, class ... Rest>
struct VariadicStorage<This, Rest...>
: public VariadicStorage<Rest...>
{
GM_CLASS_ALLOCATOR(VariadicStorage);
using ParentType = VariadicStorage<Rest...>;
using ExtractedType = typename RpcTypeExtraction<This>::Type;
using ThisType = typename AZStd::remove_const<typename AZStd::remove_reference<ExtractedType>::type>::type;
using MarshalerTuple = VariadicMarshaler<This, Rest...>;
using StaticArgSequence = typename Internal::GenerateStaticSequence<sizeof ... (Rest) +1>::Type;
VariadicStorage(RpcBase* rpc)
: ParentType(rpc) { }
template<typename ThisArg, typename ... RestArgs>
VariadicStorage(RpcBase* rpc, const RpcContext& ctx, ThisArg&& val, RestArgs&& ... args)
: ParentType(rpc, ctx, args ...)
, m_val(val) { }
void Marshal(WriteBuffer& wb, MarshalerTuple& marshaler)
{
ParentType::Marshal(wb, marshaler);
wb.Write(m_val, marshaler.m_marshaler);
}
bool Unmarshal(ReadBuffer& rb, MarshalerTuple& marshaler)
{
if (!ParentType::Unmarshal(rb, marshaler))
{
return false;
}
return rb.Read(m_val, marshaler.m_marshaler);
}
template<size_t Index, class ... Types>
struct ExtractIndexContainerType;
template<class First, class ... Types>
struct ExtractIndexContainerType<0, First, Types...>
{
typedef VariadicStorage<First, Types...> ContainerType;
};
template<size_t Index, class First, class ... Types>
struct ExtractIndexContainerType<Index, First, Types...>
: ExtractIndexContainerType<Index - 1, Types...>
{ };
template<size_t Index, class First, class ... Types>
struct ExtractIndexReturnType
{
typedef typename ExtractIndexContainerType<Index, This, Rest...>::ContainerType ContainerType;
typedef typename ContainerType::ThisType ThisType;
};
ThisType m_val;
};
// ------------------------------------------------
// -- GetStorageFromIndex -------------------------
template<size_t index, typename Storage, class ... Args>
const typename Storage::template ExtractIndexReturnType<index, Args...>::ThisType & GetStorageFromIndex(const Storage * storage)
{
typedef typename Storage::template ExtractIndexContainerType<index, Args...>::ContainerType ContainerType;
// Cast to Nth parent type to extract the contained value
return static_cast<const ContainerType*>(storage)->m_val;
}
// ------------------------------------------------
// -- Base binding class for common functionality --
template<class Traits, class TypeTuple, class ForwardHandler>
class RpcBindBase
: public RpcBase
{
public:
typedef typename TypeTuple::MarshalerTuple MarshalerSetType;
template<typename ... LocalArgs>
RpcBindBase(const char* debugName, LocalArgs&& ... marshalers)
: RpcBase(debugName)
, m_marshalers(AZStd::forward<LocalArgs>(marshalers) ...) { }
virtual bool InvokeImpl(Internal::RpcRequest* request) const = 0;
bool IsPostAttached() const override { return Traits::s_isPostAttached; }
bool IsAllowNonAuthoritativeRequests() const override { return Traits::s_allowNonAuthoritativeRequests; }
bool IsAllowNonAuthoritativeRequestsRelay() const override { return Traits::s_allowNonAuthoritativeRequestRelay; }
template<typename ... LocalArgs>
void operator()(LocalArgs&& ... args)
{
AZ_Assert(m_replicaChunk, "Cannot call an RPC that is not bound to a ReplicaChunk");
Replica* replica = m_replicaChunk->GetReplica();
ReplicaContext rc = replica ? replica->GetMyContext() : ReplicaContext(nullptr, TimeContext());
PeerId sourcePeerId = GetSourcePeerId();
bool shouldQueue = true;
bool processed = false;
bool isMaster = m_replicaChunk->IsMaster();
if (isMaster)
{
// We are authoritative so execute the RPC immediately, forwarding the args along
RpcRequest localRequest(this, rc.m_realTime, rc.m_realTime, rc.m_localTime);
OnRpcRequest(&localRequest);
OnRpcInvoke(&localRequest);
bool isReplicaActive = replica && replica->IsActive(); // cache this because it could get changed during the RPC call.
bool isForward = static_cast<ForwardHandler*>(this)->Forward(RpcContext(rc.m_realTime, rc.m_localTime, rc.m_realTime, sourcePeerId), AZStd::forward<LocalArgs>(args) ...);
shouldQueue = isForward && isReplicaActive;
processed = true;
}
if (shouldQueue)
{
TypeTuple* storage = aznew TypeTuple(this, RpcContext(rc.m_realTime, rc.m_realTime, rc.m_localTime, sourcePeerId), AZStd::forward<LocalArgs>(args) ...);
storage->m_authoritative = isMaster;
storage->m_processed = processed;
storage->m_reliable = Traits::s_isReliable;
OnRpcRequest(storage);
Queue(storage);
}
}
bool Invoke(Internal::RpcRequest* rpc) const override
{
OnRpcInvoke(rpc);
return InvokeImpl(rpc);
}
protected:
void Marshal(WriteBuffer& wb, Internal::RpcRequest* request) override
{
TypeTuple* storage = static_cast<TypeTuple*>(request);
wb.Write(storage->m_timestamp);
wb.Write(storage->m_authoritative);
if (Traits::s_alwaysForwardSourcePeer)
{
wb.Write(storage->m_sourcePeer);
}
// Pass the marshal onto the storage which unwraps the marshaling of each RPC value
storage->Marshal(wb, m_marshalers);
}
Internal::RpcRequest* Unmarshal(ReadBuffer& rb) override
{
TypeTuple* storage = aznew TypeTuple(this);
rb.Read(storage->m_timestamp);
rb.Read(storage->m_authoritative);
if (Traits::s_alwaysForwardSourcePeer)
{
rb.Read(storage->m_sourcePeer);
}
// Pass the unmarshal onto the storage which unwraps the marshaling of each RPC value
if (!storage->Unmarshal(rb, m_marshalers))
{
delete storage;
return nullptr;
}
return storage;
}
MarshalerSetType m_marshalers; // Set of marshalers, one for each type specified in the RPC
};
// -----------------------------------------
template<class ... Args>
struct RpcBindArgsWrapper
{
/**
* Bind a class method to the RPC
*/
template<class Traits, class TypeTuple, class ThisResolver, class C, bool (C::* FuncPtr)(typename Args::Type..., const RpcContext&)>
class BindInterface
: public RpcBindBase<Traits, TypeTuple, BindInterface<Traits, TypeTuple, ThisResolver, C, FuncPtr> >
{
public:
template<typename ... LocalArgs>
BindInterface(const char* debugName, LocalArgs&& ... marshalers)
: RpcBindBase<Traits, TypeTuple, BindInterface<Traits, TypeTuple, ThisResolver, C, FuncPtr> >(debugName, AZStd::forward<LocalArgs>(marshalers) ...) { }
// Invoke from storage
bool InvokeImpl(Internal::RpcRequest* request) const override
{
TypeTuple* storage = static_cast<TypeTuple*>(request);
return InvokeWithArgs(storage, typename TypeTuple::StaticArgSequence());
}
// Forward from a direct in-place call
template<typename ... LocalArgs>
bool Forward(const RpcContext& context, LocalArgs&& ... args)
{
C* c = ThisResolver::template GetInterface<C>(this);
return (*c.*FuncPtr)(AZStd::forward<LocalArgs>(args) ..., context);
}
protected:
// Invoke and unwrap the args
template<size_t ... Indices>
bool InvokeWithArgs(TypeTuple* storage, Internal::StaticSequence<Indices...>) const
{
C* c = ThisResolver::template GetInterface<C>(this);
if (c)
{
return (*c.*FuncPtr)(GetStorageFromIndex<Indices, TypeTuple, Args...>(storage) ..., *storage);
}
else
{
return false;
}
}
};
/**
* Bind a class method to the RPC (0 args version)
*/
template<class Traits, class TypeTuple, class ThisResolver, class C, bool (C::* FuncPtr)(const RpcContext&)>
class BindInterface0
: public RpcBindBase<Traits, TypeTuple, BindInterface0<Traits, TypeTuple, ThisResolver, C, FuncPtr> >
{
public:
BindInterface0(const char* debugName)
: RpcBindBase<Traits, TypeTuple, BindInterface0<Traits, TypeTuple, ThisResolver, C, FuncPtr> >(debugName) { }
// Invoke from storage
bool InvokeImpl(Internal::RpcRequest* request) const override
{
C* c = ThisResolver::template GetInterface<C>(this);
if (c)
{
TypeTuple* storage = static_cast<TypeTuple*>(request);
return (*c.*FuncPtr)(*storage);
}
else
{
return false;
}
}
// Forward from a direct in-place call
bool Forward(const RpcContext& context)
{
C* c = ThisResolver::template GetInterface<C>(this);
return (*c.*FuncPtr)(context);
}
};
RpcBindArgsWrapper() = delete;
};
}
/**
* Public interface for declaring an RPC
*/
template<typename ... Args>
class Rpc;
/**
* 0 args specialisation
*/
template<>
class Rpc<>
{
typedef Internal::VariadicStorage<> TypeTuple;
public:
template<class C, bool (C::* FuncPtr)(const RpcContext&), class Traits = RpcDefaultTraits>
using BindInterface = Internal::RpcBindArgsWrapper<>::BindInterface0<Traits, TypeTuple, Internal::InterfaceResolver, C, FuncPtr>;
Rpc() = delete;
};
/**
* Any args specialisation
*/
template<typename ... Args>
class Rpc
{
typedef Internal::VariadicStorage<Args...> TypeTuple;
public:
template<class C, bool (C::* FuncPtr)(typename Args::Type..., const RpcContext&), class Traits = RpcDefaultTraits>
struct BindInterface
: public Internal::RpcBindArgsWrapper<Args...>::template BindInterface<Traits, TypeTuple, Internal::InterfaceResolver, C, FuncPtr>
{
template<typename ... LocalArgs>
BindInterface(const char* debugName, LocalArgs&& ... marshalers)
: Internal::RpcBindArgsWrapper<Args...>::template BindInterface<Traits, TypeTuple, Internal::InterfaceResolver, C, FuncPtr>(debugName, AZStd::forward<LocalArgs>(marshalers) ...) { }
};
Rpc() = delete;
};
} // namespace GridMate
#endif // GM_REPLICA_RPC_H
| 38.558669 | 197 | 0.558205 | [
"object"
] |
43ff2e822e26591b2d0901f27739808a876faf39 | 62,759 | h | C | opencv/sources/3rdparty/include/opencl/1.2/CL/cl.h | vrushank-agrawal/opencv-x64-cmake | 3f9486510d706c8ac579ac82f5d58f667f948124 | [
"Apache-2.0"
] | null | null | null | opencv/sources/3rdparty/include/opencl/1.2/CL/cl.h | vrushank-agrawal/opencv-x64-cmake | 3f9486510d706c8ac579ac82f5d58f667f948124 | [
"Apache-2.0"
] | null | null | null | opencv/sources/3rdparty/include/opencl/1.2/CL/cl.h | vrushank-agrawal/opencv-x64-cmake | 3f9486510d706c8ac579ac82f5d58f667f948124 | [
"Apache-2.0"
] | null | null | null | /*******************************************************************************
* Copyright (c) 2008 - 2012 The Khronos Group Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and/or associated documentation files (the
* "Materials"), to deal in the Materials without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Materials, and to
* permit persons to whom the Materials are furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
******************************************************************************/
#ifndef __OPENCL_CL_H
#define __OPENCL_CL_H
#ifdef __APPLE__
#include <OpenCL/cl_platform.h>
#else
#include <CL/cl_platform.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/******************************************************************************/
typedef struct _cl_platform_id * cl_platform_id;
typedef struct _cl_device_id * cl_device_id;
typedef struct _cl_context * cl_context;
typedef struct _cl_command_queue * cl_command_queue;
typedef struct _cl_mem * cl_mem;
typedef struct _cl_program * cl_program;
typedef struct _cl_kernel * cl_kernel;
typedef struct _cl_event * cl_event;
typedef struct _cl_sampler * cl_sampler;
typedef cl_uint cl_bool; /* WARNING! Unlike cl_ types in cl_platform.h, cl_bool is not guaranteed to be the same size as the bool in kernels. */
typedef cl_ulong cl_bitfield;
typedef cl_bitfield cl_device_type;
typedef cl_uint cl_platform_info;
typedef cl_uint cl_device_info;
typedef cl_bitfield cl_device_fp_config;
typedef cl_uint cl_device_mem_cache_type;
typedef cl_uint cl_device_local_mem_type;
typedef cl_bitfield cl_device_exec_capabilities;
typedef cl_bitfield cl_command_queue_properties;
typedef intptr_t cl_device_partition_property;
typedef cl_bitfield cl_device_affinity_domain;
typedef intptr_t cl_context_properties;
typedef cl_uint cl_context_info;
typedef cl_uint cl_command_queue_info;
typedef cl_uint cl_channel_order;
typedef cl_uint cl_channel_type;
typedef cl_bitfield cl_mem_flags;
typedef cl_uint cl_mem_object_type;
typedef cl_uint cl_mem_info;
typedef cl_bitfield cl_mem_migration_flags;
typedef cl_uint cl_image_info;
typedef cl_uint cl_buffer_create_type;
typedef cl_uint cl_addressing_mode;
typedef cl_uint cl_filter_mode;
typedef cl_uint cl_sampler_info;
typedef cl_bitfield cl_map_flags;
typedef cl_uint cl_program_info;
typedef cl_uint cl_program_build_info;
typedef cl_uint cl_program_binary_type;
typedef cl_int cl_build_status;
typedef cl_uint cl_kernel_info;
typedef cl_uint cl_kernel_arg_info;
typedef cl_uint cl_kernel_arg_address_qualifier;
typedef cl_uint cl_kernel_arg_access_qualifier;
typedef cl_bitfield cl_kernel_arg_type_qualifier;
typedef cl_uint cl_kernel_work_group_info;
typedef cl_uint cl_event_info;
typedef cl_uint cl_command_type;
typedef cl_uint cl_profiling_info;
typedef struct _cl_image_format {
cl_channel_order image_channel_order;
cl_channel_type image_channel_data_type;
} cl_image_format;
typedef struct _cl_image_desc {
cl_mem_object_type image_type;
size_t image_width;
size_t image_height;
size_t image_depth;
size_t image_array_size;
size_t image_row_pitch;
size_t image_slice_pitch;
cl_uint num_mip_levels;
cl_uint num_samples;
cl_mem buffer;
} cl_image_desc;
typedef struct _cl_buffer_region {
size_t origin;
size_t size;
} cl_buffer_region;
/******************************************************************************/
/* Error Codes */
#define CL_SUCCESS 0
#define CL_DEVICE_NOT_FOUND -1
#define CL_DEVICE_NOT_AVAILABLE -2
#define CL_COMPILER_NOT_AVAILABLE -3
#define CL_MEM_OBJECT_ALLOCATION_FAILURE -4
#define CL_OUT_OF_RESOURCES -5
#define CL_OUT_OF_HOST_MEMORY -6
#define CL_PROFILING_INFO_NOT_AVAILABLE -7
#define CL_MEM_COPY_OVERLAP -8
#define CL_IMAGE_FORMAT_MISMATCH -9
#define CL_IMAGE_FORMAT_NOT_SUPPORTED -10
#define CL_BUILD_PROGRAM_FAILURE -11
#define CL_MAP_FAILURE -12
#define CL_MISALIGNED_SUB_BUFFER_OFFSET -13
#define CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST -14
#define CL_COMPILE_PROGRAM_FAILURE -15
#define CL_LINKER_NOT_AVAILABLE -16
#define CL_LINK_PROGRAM_FAILURE -17
#define CL_DEVICE_PARTITION_FAILED -18
#define CL_KERNEL_ARG_INFO_NOT_AVAILABLE -19
#define CL_INVALID_VALUE -30
#define CL_INVALID_DEVICE_TYPE -31
#define CL_INVALID_PLATFORM -32
#define CL_INVALID_DEVICE -33
#define CL_INVALID_CONTEXT -34
#define CL_INVALID_QUEUE_PROPERTIES -35
#define CL_INVALID_COMMAND_QUEUE -36
#define CL_INVALID_HOST_PTR -37
#define CL_INVALID_MEM_OBJECT -38
#define CL_INVALID_IMAGE_FORMAT_DESCRIPTOR -39
#define CL_INVALID_IMAGE_SIZE -40
#define CL_INVALID_SAMPLER -41
#define CL_INVALID_BINARY -42
#define CL_INVALID_BUILD_OPTIONS -43
#define CL_INVALID_PROGRAM -44
#define CL_INVALID_PROGRAM_EXECUTABLE -45
#define CL_INVALID_KERNEL_NAME -46
#define CL_INVALID_KERNEL_DEFINITION -47
#define CL_INVALID_KERNEL -48
#define CL_INVALID_ARG_INDEX -49
#define CL_INVALID_ARG_VALUE -50
#define CL_INVALID_ARG_SIZE -51
#define CL_INVALID_KERNEL_ARGS -52
#define CL_INVALID_WORK_DIMENSION -53
#define CL_INVALID_WORK_GROUP_SIZE -54
#define CL_INVALID_WORK_ITEM_SIZE -55
#define CL_INVALID_GLOBAL_OFFSET -56
#define CL_INVALID_EVENT_WAIT_LIST -57
#define CL_INVALID_EVENT -58
#define CL_INVALID_OPERATION -59
#define CL_INVALID_GL_OBJECT -60
#define CL_INVALID_BUFFER_SIZE -61
#define CL_INVALID_MIP_LEVEL -62
#define CL_INVALID_GLOBAL_WORK_SIZE -63
#define CL_INVALID_PROPERTY -64
#define CL_INVALID_IMAGE_DESCRIPTOR -65
#define CL_INVALID_COMPILER_OPTIONS -66
#define CL_INVALID_LINKER_OPTIONS -67
#define CL_INVALID_DEVICE_PARTITION_COUNT -68
/* OpenCL Version */
#define CL_VERSION_1_0 1
#define CL_VERSION_1_1 1
#define CL_VERSION_1_2 1
/* cl_bool */
#define CL_FALSE 0
#define CL_TRUE 1
#define CL_BLOCKING CL_TRUE
#define CL_NON_BLOCKING CL_FALSE
/* cl_platform_info */
#define CL_PLATFORM_PROFILE 0x0900
#define CL_PLATFORM_VERSION 0x0901
#define CL_PLATFORM_NAME 0x0902
#define CL_PLATFORM_VENDOR 0x0903
#define CL_PLATFORM_EXTENSIONS 0x0904
/* cl_device_type - bitfield */
#define CL_DEVICE_TYPE_DEFAULT (1 << 0)
#define CL_DEVICE_TYPE_CPU (1 << 1)
#define CL_DEVICE_TYPE_GPU (1 << 2)
#define CL_DEVICE_TYPE_ACCELERATOR (1 << 3)
#define CL_DEVICE_TYPE_CUSTOM (1 << 4)
#define CL_DEVICE_TYPE_ALL 0xFFFFFFFF
/* cl_device_info */
#define CL_DEVICE_TYPE 0x1000
#define CL_DEVICE_VENDOR_ID 0x1001
#define CL_DEVICE_MAX_COMPUTE_UNITS 0x1002
#define CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS 0x1003
#define CL_DEVICE_MAX_WORK_GROUP_SIZE 0x1004
#define CL_DEVICE_MAX_WORK_ITEM_SIZES 0x1005
#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR 0x1006
#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT 0x1007
#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT 0x1008
#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG 0x1009
#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT 0x100A
#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE 0x100B
#define CL_DEVICE_MAX_CLOCK_FREQUENCY 0x100C
#define CL_DEVICE_ADDRESS_BITS 0x100D
#define CL_DEVICE_MAX_READ_IMAGE_ARGS 0x100E
#define CL_DEVICE_MAX_WRITE_IMAGE_ARGS 0x100F
#define CL_DEVICE_MAX_MEM_ALLOC_SIZE 0x1010
#define CL_DEVICE_IMAGE2D_MAX_WIDTH 0x1011
#define CL_DEVICE_IMAGE2D_MAX_HEIGHT 0x1012
#define CL_DEVICE_IMAGE3D_MAX_WIDTH 0x1013
#define CL_DEVICE_IMAGE3D_MAX_HEIGHT 0x1014
#define CL_DEVICE_IMAGE3D_MAX_DEPTH 0x1015
#define CL_DEVICE_IMAGE_SUPPORT 0x1016
#define CL_DEVICE_MAX_PARAMETER_SIZE 0x1017
#define CL_DEVICE_MAX_SAMPLERS 0x1018
#define CL_DEVICE_MEM_BASE_ADDR_ALIGN 0x1019
#define CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE 0x101A
#define CL_DEVICE_SINGLE_FP_CONFIG 0x101B
#define CL_DEVICE_GLOBAL_MEM_CACHE_TYPE 0x101C
#define CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE 0x101D
#define CL_DEVICE_GLOBAL_MEM_CACHE_SIZE 0x101E
#define CL_DEVICE_GLOBAL_MEM_SIZE 0x101F
#define CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE 0x1020
#define CL_DEVICE_MAX_CONSTANT_ARGS 0x1021
#define CL_DEVICE_LOCAL_MEM_TYPE 0x1022
#define CL_DEVICE_LOCAL_MEM_SIZE 0x1023
#define CL_DEVICE_ERROR_CORRECTION_SUPPORT 0x1024
#define CL_DEVICE_PROFILING_TIMER_RESOLUTION 0x1025
#define CL_DEVICE_ENDIAN_LITTLE 0x1026
#define CL_DEVICE_AVAILABLE 0x1027
#define CL_DEVICE_COMPILER_AVAILABLE 0x1028
#define CL_DEVICE_EXECUTION_CAPABILITIES 0x1029
#define CL_DEVICE_QUEUE_PROPERTIES 0x102A
#define CL_DEVICE_NAME 0x102B
#define CL_DEVICE_VENDOR 0x102C
#define CL_DRIVER_VERSION 0x102D
#define CL_DEVICE_PROFILE 0x102E
#define CL_DEVICE_VERSION 0x102F
#define CL_DEVICE_EXTENSIONS 0x1030
#define CL_DEVICE_PLATFORM 0x1031
#define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032
/* 0x1033 reserved for CL_DEVICE_HALF_FP_CONFIG */
#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF 0x1034
#define CL_DEVICE_HOST_UNIFIED_MEMORY 0x1035
#define CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR 0x1036
#define CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT 0x1037
#define CL_DEVICE_NATIVE_VECTOR_WIDTH_INT 0x1038
#define CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG 0x1039
#define CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT 0x103A
#define CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE 0x103B
#define CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF 0x103C
#define CL_DEVICE_OPENCL_C_VERSION 0x103D
#define CL_DEVICE_LINKER_AVAILABLE 0x103E
#define CL_DEVICE_BUILT_IN_KERNELS 0x103F
#define CL_DEVICE_IMAGE_MAX_BUFFER_SIZE 0x1040
#define CL_DEVICE_IMAGE_MAX_ARRAY_SIZE 0x1041
#define CL_DEVICE_PARENT_DEVICE 0x1042
#define CL_DEVICE_PARTITION_MAX_SUB_DEVICES 0x1043
#define CL_DEVICE_PARTITION_PROPERTIES 0x1044
#define CL_DEVICE_PARTITION_AFFINITY_DOMAIN 0x1045
#define CL_DEVICE_PARTITION_TYPE 0x1046
#define CL_DEVICE_REFERENCE_COUNT 0x1047
#define CL_DEVICE_PREFERRED_INTEROP_USER_SYNC 0x1048
#define CL_DEVICE_PRINTF_BUFFER_SIZE 0x1049
#define CL_DEVICE_IMAGE_PITCH_ALIGNMENT 0x104A
#define CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT 0x104B
/* cl_device_fp_config - bitfield */
#define CL_FP_DENORM (1 << 0)
#define CL_FP_INF_NAN (1 << 1)
#define CL_FP_ROUND_TO_NEAREST (1 << 2)
#define CL_FP_ROUND_TO_ZERO (1 << 3)
#define CL_FP_ROUND_TO_INF (1 << 4)
#define CL_FP_FMA (1 << 5)
#define CL_FP_SOFT_FLOAT (1 << 6)
#define CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT (1 << 7)
/* cl_device_mem_cache_type */
#define CL_NONE 0x0
#define CL_READ_ONLY_CACHE 0x1
#define CL_READ_WRITE_CACHE 0x2
/* cl_device_local_mem_type */
#define CL_LOCAL 0x1
#define CL_GLOBAL 0x2
/* cl_device_exec_capabilities - bitfield */
#define CL_EXEC_KERNEL (1 << 0)
#define CL_EXEC_NATIVE_KERNEL (1 << 1)
/* cl_command_queue_properties - bitfield */
#define CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE (1 << 0)
#define CL_QUEUE_PROFILING_ENABLE (1 << 1)
/* cl_context_info */
#define CL_CONTEXT_REFERENCE_COUNT 0x1080
#define CL_CONTEXT_DEVICES 0x1081
#define CL_CONTEXT_PROPERTIES 0x1082
#define CL_CONTEXT_NUM_DEVICES 0x1083
/* cl_context_properties */
#define CL_CONTEXT_PLATFORM 0x1084
#define CL_CONTEXT_INTEROP_USER_SYNC 0x1085
/* cl_device_partition_property */
#define CL_DEVICE_PARTITION_EQUALLY 0x1086
#define CL_DEVICE_PARTITION_BY_COUNTS 0x1087
#define CL_DEVICE_PARTITION_BY_COUNTS_LIST_END 0x0
#define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN 0x1088
/* cl_device_affinity_domain */
#define CL_DEVICE_AFFINITY_DOMAIN_NUMA (1 << 0)
#define CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE (1 << 1)
#define CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE (1 << 2)
#define CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE (1 << 3)
#define CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE (1 << 4)
#define CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE (1 << 5)
/* cl_command_queue_info */
#define CL_QUEUE_CONTEXT 0x1090
#define CL_QUEUE_DEVICE 0x1091
#define CL_QUEUE_REFERENCE_COUNT 0x1092
#define CL_QUEUE_PROPERTIES 0x1093
/* cl_mem_flags - bitfield */
#define CL_MEM_READ_WRITE (1 << 0)
#define CL_MEM_WRITE_ONLY (1 << 1)
#define CL_MEM_READ_ONLY (1 << 2)
#define CL_MEM_USE_HOST_PTR (1 << 3)
#define CL_MEM_ALLOC_HOST_PTR (1 << 4)
#define CL_MEM_COPY_HOST_PTR (1 << 5)
// reserved (1 << 6)
#define CL_MEM_HOST_WRITE_ONLY (1 << 7)
#define CL_MEM_HOST_READ_ONLY (1 << 8)
#define CL_MEM_HOST_NO_ACCESS (1 << 9)
/* cl_mem_migration_flags - bitfield */
#define CL_MIGRATE_MEM_OBJECT_HOST (1 << 0)
#define CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED (1 << 1)
/* cl_channel_order */
#define CL_R 0x10B0
#define CL_A 0x10B1
#define CL_RG 0x10B2
#define CL_RA 0x10B3
#define CL_RGB 0x10B4
#define CL_RGBA 0x10B5
#define CL_BGRA 0x10B6
#define CL_ARGB 0x10B7
#define CL_INTENSITY 0x10B8
#define CL_LUMINANCE 0x10B9
#define CL_Rx 0x10BA
#define CL_RGx 0x10BB
#define CL_RGBx 0x10BC
#define CL_DEPTH 0x10BD
#define CL_DEPTH_STENCIL 0x10BE
/* cl_channel_type */
#define CL_SNORM_INT8 0x10D0
#define CL_SNORM_INT16 0x10D1
#define CL_UNORM_INT8 0x10D2
#define CL_UNORM_INT16 0x10D3
#define CL_UNORM_SHORT_565 0x10D4
#define CL_UNORM_SHORT_555 0x10D5
#define CL_UNORM_INT_101010 0x10D6
#define CL_SIGNED_INT8 0x10D7
#define CL_SIGNED_INT16 0x10D8
#define CL_SIGNED_INT32 0x10D9
#define CL_UNSIGNED_INT8 0x10DA
#define CL_UNSIGNED_INT16 0x10DB
#define CL_UNSIGNED_INT32 0x10DC
#define CL_HALF_FLOAT 0x10DD
#define CL_FLOAT 0x10DE
#define CL_UNORM_INT24 0x10DF
/* cl_mem_object_type */
#define CL_MEM_OBJECT_BUFFER 0x10F0
#define CL_MEM_OBJECT_IMAGE2D 0x10F1
#define CL_MEM_OBJECT_IMAGE3D 0x10F2
#define CL_MEM_OBJECT_IMAGE2D_ARRAY 0x10F3
#define CL_MEM_OBJECT_IMAGE1D 0x10F4
#define CL_MEM_OBJECT_IMAGE1D_ARRAY 0x10F5
#define CL_MEM_OBJECT_IMAGE1D_BUFFER 0x10F6
/* cl_mem_info */
#define CL_MEM_TYPE 0x1100
#define CL_MEM_FLAGS 0x1101
#define CL_MEM_SIZE 0x1102
#define CL_MEM_HOST_PTR 0x1103
#define CL_MEM_MAP_COUNT 0x1104
#define CL_MEM_REFERENCE_COUNT 0x1105
#define CL_MEM_CONTEXT 0x1106
#define CL_MEM_ASSOCIATED_MEMOBJECT 0x1107
#define CL_MEM_OFFSET 0x1108
/* cl_image_info */
#define CL_IMAGE_FORMAT 0x1110
#define CL_IMAGE_ELEMENT_SIZE 0x1111
#define CL_IMAGE_ROW_PITCH 0x1112
#define CL_IMAGE_SLICE_PITCH 0x1113
#define CL_IMAGE_WIDTH 0x1114
#define CL_IMAGE_HEIGHT 0x1115
#define CL_IMAGE_DEPTH 0x1116
#define CL_IMAGE_ARRAY_SIZE 0x1117
#define CL_IMAGE_BUFFER 0x1118
#define CL_IMAGE_NUM_MIP_LEVELS 0x1119
#define CL_IMAGE_NUM_SAMPLES 0x111A
/* cl_addressing_mode */
#define CL_ADDRESS_NONE 0x1130
#define CL_ADDRESS_CLAMP_TO_EDGE 0x1131
#define CL_ADDRESS_CLAMP 0x1132
#define CL_ADDRESS_REPEAT 0x1133
#define CL_ADDRESS_MIRRORED_REPEAT 0x1134
/* cl_filter_mode */
#define CL_FILTER_NEAREST 0x1140
#define CL_FILTER_LINEAR 0x1141
/* cl_sampler_info */
#define CL_SAMPLER_REFERENCE_COUNT 0x1150
#define CL_SAMPLER_CONTEXT 0x1151
#define CL_SAMPLER_NORMALIZED_COORDS 0x1152
#define CL_SAMPLER_ADDRESSING_MODE 0x1153
#define CL_SAMPLER_FILTER_MODE 0x1154
/* cl_map_flags - bitfield */
#define CL_MAP_READ (1 << 0)
#define CL_MAP_WRITE (1 << 1)
#define CL_MAP_WRITE_INVALIDATE_REGION (1 << 2)
/* cl_program_info */
#define CL_PROGRAM_REFERENCE_COUNT 0x1160
#define CL_PROGRAM_CONTEXT 0x1161
#define CL_PROGRAM_NUM_DEVICES 0x1162
#define CL_PROGRAM_DEVICES 0x1163
#define CL_PROGRAM_SOURCE 0x1164
#define CL_PROGRAM_BINARY_SIZES 0x1165
#define CL_PROGRAM_BINARIES 0x1166
#define CL_PROGRAM_NUM_KERNELS 0x1167
#define CL_PROGRAM_KERNEL_NAMES 0x1168
/* cl_program_build_info */
#define CL_PROGRAM_BUILD_STATUS 0x1181
#define CL_PROGRAM_BUILD_OPTIONS 0x1182
#define CL_PROGRAM_BUILD_LOG 0x1183
#define CL_PROGRAM_BINARY_TYPE 0x1184
/* cl_program_binary_type */
#define CL_PROGRAM_BINARY_TYPE_NONE 0x0
#define CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT 0x1
#define CL_PROGRAM_BINARY_TYPE_LIBRARY 0x2
#define CL_PROGRAM_BINARY_TYPE_EXECUTABLE 0x4
/* cl_build_status */
#define CL_BUILD_SUCCESS 0
#define CL_BUILD_NONE -1
#define CL_BUILD_ERROR -2
#define CL_BUILD_IN_PROGRESS -3
/* cl_kernel_info */
#define CL_KERNEL_FUNCTION_NAME 0x1190
#define CL_KERNEL_NUM_ARGS 0x1191
#define CL_KERNEL_REFERENCE_COUNT 0x1192
#define CL_KERNEL_CONTEXT 0x1193
#define CL_KERNEL_PROGRAM 0x1194
#define CL_KERNEL_ATTRIBUTES 0x1195
/* cl_kernel_arg_info */
#define CL_KERNEL_ARG_ADDRESS_QUALIFIER 0x1196
#define CL_KERNEL_ARG_ACCESS_QUALIFIER 0x1197
#define CL_KERNEL_ARG_TYPE_NAME 0x1198
#define CL_KERNEL_ARG_TYPE_QUALIFIER 0x1199
#define CL_KERNEL_ARG_NAME 0x119A
/* cl_kernel_arg_address_qualifier */
#define CL_KERNEL_ARG_ADDRESS_GLOBAL 0x119B
#define CL_KERNEL_ARG_ADDRESS_LOCAL 0x119C
#define CL_KERNEL_ARG_ADDRESS_CONSTANT 0x119D
#define CL_KERNEL_ARG_ADDRESS_PRIVATE 0x119E
/* cl_kernel_arg_access_qualifier */
#define CL_KERNEL_ARG_ACCESS_READ_ONLY 0x11A0
#define CL_KERNEL_ARG_ACCESS_WRITE_ONLY 0x11A1
#define CL_KERNEL_ARG_ACCESS_READ_WRITE 0x11A2
#define CL_KERNEL_ARG_ACCESS_NONE 0x11A3
/* cl_kernel_arg_type_qualifer */
#define CL_KERNEL_ARG_TYPE_NONE 0
#define CL_KERNEL_ARG_TYPE_CONST (1 << 0)
#define CL_KERNEL_ARG_TYPE_RESTRICT (1 << 1)
#define CL_KERNEL_ARG_TYPE_VOLATILE (1 << 2)
/* cl_kernel_work_group_info */
#define CL_KERNEL_WORK_GROUP_SIZE 0x11B0
#define CL_KERNEL_COMPILE_WORK_GROUP_SIZE 0x11B1
#define CL_KERNEL_LOCAL_MEM_SIZE 0x11B2
#define CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE 0x11B3
#define CL_KERNEL_PRIVATE_MEM_SIZE 0x11B4
#define CL_KERNEL_GLOBAL_WORK_SIZE 0x11B5
/* cl_event_info */
#define CL_EVENT_COMMAND_QUEUE 0x11D0
#define CL_EVENT_COMMAND_TYPE 0x11D1
#define CL_EVENT_REFERENCE_COUNT 0x11D2
#define CL_EVENT_COMMAND_EXECUTION_STATUS 0x11D3
#define CL_EVENT_CONTEXT 0x11D4
/* cl_command_type */
#define CL_COMMAND_NDRANGE_KERNEL 0x11F0
#define CL_COMMAND_TASK 0x11F1
#define CL_COMMAND_NATIVE_KERNEL 0x11F2
#define CL_COMMAND_READ_BUFFER 0x11F3
#define CL_COMMAND_WRITE_BUFFER 0x11F4
#define CL_COMMAND_COPY_BUFFER 0x11F5
#define CL_COMMAND_READ_IMAGE 0x11F6
#define CL_COMMAND_WRITE_IMAGE 0x11F7
#define CL_COMMAND_COPY_IMAGE 0x11F8
#define CL_COMMAND_COPY_IMAGE_TO_BUFFER 0x11F9
#define CL_COMMAND_COPY_BUFFER_TO_IMAGE 0x11FA
#define CL_COMMAND_MAP_BUFFER 0x11FB
#define CL_COMMAND_MAP_IMAGE 0x11FC
#define CL_COMMAND_UNMAP_MEM_OBJECT 0x11FD
#define CL_COMMAND_MARKER 0x11FE
#define CL_COMMAND_ACQUIRE_GL_OBJECTS 0x11FF
#define CL_COMMAND_RELEASE_GL_OBJECTS 0x1200
#define CL_COMMAND_READ_BUFFER_RECT 0x1201
#define CL_COMMAND_WRITE_BUFFER_RECT 0x1202
#define CL_COMMAND_COPY_BUFFER_RECT 0x1203
#define CL_COMMAND_USER 0x1204
#define CL_COMMAND_BARRIER 0x1205
#define CL_COMMAND_MIGRATE_MEM_OBJECTS 0x1206
#define CL_COMMAND_FILL_BUFFER 0x1207
#define CL_COMMAND_FILL_IMAGE 0x1208
/* command execution status */
#define CL_COMPLETE 0x0
#define CL_RUNNING 0x1
#define CL_SUBMITTED 0x2
#define CL_QUEUED 0x3
/* cl_buffer_create_type */
#define CL_BUFFER_CREATE_TYPE_REGION 0x1220
/* cl_profiling_info */
#define CL_PROFILING_COMMAND_QUEUED 0x1280
#define CL_PROFILING_COMMAND_SUBMIT 0x1281
#define CL_PROFILING_COMMAND_START 0x1282
#define CL_PROFILING_COMMAND_END 0x1283
/********************************************************************************************************/
/* Platform API */
extern CL_API_ENTRY cl_int CL_API_CALL
clGetPlatformIDs(cl_uint /* num_entries */,
cl_platform_id * /* platforms */,
cl_uint * /* num_platforms */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetPlatformInfo(cl_platform_id /* platform */,
cl_platform_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
/* Device APIs */
extern CL_API_ENTRY cl_int CL_API_CALL
clGetDeviceIDs(cl_platform_id /* platform */,
cl_device_type /* device_type */,
cl_uint /* num_entries */,
cl_device_id * /* devices */,
cl_uint * /* num_devices */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetDeviceInfo(cl_device_id /* device */,
cl_device_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clCreateSubDevices(cl_device_id /* in_device */,
const cl_device_partition_property * /* properties */,
cl_uint /* num_devices */,
cl_device_id * /* out_devices */,
cl_uint * /* num_devices_ret */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clRetainDevice(cl_device_id /* device */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clReleaseDevice(cl_device_id /* device */) CL_API_SUFFIX__VERSION_1_2;
/* Context APIs */
extern CL_API_ENTRY cl_context CL_API_CALL
clCreateContext(const cl_context_properties * /* properties */,
cl_uint /* num_devices */,
const cl_device_id * /* devices */,
void (CL_CALLBACK * /* pfn_notify */)(const char *, const void *, size_t, void *),
void * /* user_data */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_context CL_API_CALL
clCreateContextFromType(const cl_context_properties * /* properties */,
cl_device_type /* device_type */,
void (CL_CALLBACK * /* pfn_notify*/ )(const char *, const void *, size_t, void *),
void * /* user_data */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clRetainContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clReleaseContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetContextInfo(cl_context /* context */,
cl_context_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
/* Command Queue APIs */
extern CL_API_ENTRY cl_command_queue CL_API_CALL
clCreateCommandQueue(cl_context /* context */,
cl_device_id /* device */,
cl_command_queue_properties /* properties */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clRetainCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clReleaseCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetCommandQueueInfo(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_API_SUFFIX__VERSION_1_0;
/* Memory Object APIs */
extern CL_API_ENTRY cl_mem CL_API_CALL
clCreateBuffer(cl_context /* context */,
cl_mem_flags /* flags */,
size_t /* size */,
void * /* host_ptr */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_mem CL_API_CALL
clCreateSubBuffer(cl_mem /* buffer */,
cl_mem_flags /* flags */,
cl_buffer_create_type /* buffer_create_type */,
const void * /* buffer_create_info */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1;
extern CL_API_ENTRY cl_mem CL_API_CALL
clCreateImage(cl_context /* context */,
cl_mem_flags /* flags */,
const cl_image_format * /* image_format */,
const cl_image_desc * /* image_desc */,
void * /* host_ptr */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clRetainMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clReleaseMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetSupportedImageFormats(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetMemObjectInfo(cl_mem /* memobj */,
cl_mem_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetImageInfo(cl_mem /* image */,
cl_image_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clSetMemObjectDestructorCallback( cl_mem /* memobj */,
void (CL_CALLBACK * /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/),
void * /*user_data */ ) CL_API_SUFFIX__VERSION_1_1;
/* Sampler APIs */
extern CL_API_ENTRY cl_sampler CL_API_CALL
clCreateSampler(cl_context /* context */,
cl_bool /* normalized_coords */,
cl_addressing_mode /* addressing_mode */,
cl_filter_mode /* filter_mode */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clRetainSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clReleaseSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetSamplerInfo(cl_sampler /* sampler */,
cl_sampler_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
/* Program Object APIs */
extern CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithSource(cl_context /* context */,
cl_uint /* count */,
const char ** /* strings */,
const size_t * /* lengths */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithBinary(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithBuiltInKernels(cl_context /* context */,
cl_uint /* num_devices */,
const cl_device_id * /* device_list */,
const char * /* kernel_names */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clRetainProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clReleaseProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clBuildProgram(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clCompileProgram(cl_program /* program */,
cl_uint /* num_devices */,
const cl_device_id * /* device_list */,
const char * /* options */,
cl_uint /* num_input_headers */,
const cl_program * /* input_headers */,
const char ** /* header_include_names */,
void (CL_CALLBACK * /* pfn_notify */)(cl_program /* program */, void * /* user_data */),
void * /* user_data */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_program CL_API_CALL
clLinkProgram(cl_context /* context */,
cl_uint /* num_devices */,
const cl_device_id * /* device_list */,
const char * /* options */,
cl_uint /* num_input_programs */,
const cl_program * /* input_programs */,
void (CL_CALLBACK * /* pfn_notify */)(cl_program /* program */, void * /* user_data */),
void * /* user_data */,
cl_int * /* errcode_ret */ ) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clUnloadPlatformCompiler(cl_platform_id /* platform */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetProgramInfo(cl_program /* program */,
cl_program_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetProgramBuildInfo(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_API_SUFFIX__VERSION_1_0;
/* Kernel Object APIs */
extern CL_API_ENTRY cl_kernel CL_API_CALL
clCreateKernel(cl_program /* program */,
const char * /* kernel_name */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clCreateKernelsInProgram(cl_program /* program */,
cl_uint /* num_kernels */,
cl_kernel * /* kernels */,
cl_uint * /* num_kernels_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clRetainKernel(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clReleaseKernel(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clSetKernelArg(cl_kernel /* kernel */,
cl_uint /* arg_index */,
size_t /* arg_size */,
const void * /* arg_value */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetKernelInfo(cl_kernel /* kernel */,
cl_kernel_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetKernelArgInfo(cl_kernel /* kernel */,
cl_uint /* arg_indx */,
cl_kernel_arg_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetKernelWorkGroupInfo(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_API_SUFFIX__VERSION_1_0;
/* Event Object APIs */
extern CL_API_ENTRY cl_int CL_API_CALL
clWaitForEvents(cl_uint /* num_events */,
const cl_event * /* event_list */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetEventInfo(cl_event /* event */,
cl_event_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_event CL_API_CALL
clCreateUserEvent(cl_context /* context */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1;
extern CL_API_ENTRY cl_int CL_API_CALL
clRetainEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clReleaseEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clSetUserEventStatus(cl_event /* event */,
cl_int /* execution_status */) CL_API_SUFFIX__VERSION_1_1;
extern CL_API_ENTRY cl_int CL_API_CALL
clSetEventCallback( cl_event /* event */,
cl_int /* command_exec_callback_type */,
void (CL_CALLBACK * /* pfn_notify */)(cl_event, cl_int, void *),
void * /* user_data */) CL_API_SUFFIX__VERSION_1_1;
/* Profiling APIs */
extern CL_API_ENTRY cl_int CL_API_CALL
clGetEventProfilingInfo(cl_event /* event */,
cl_profiling_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
/* Flush and Finish APIs */
extern CL_API_ENTRY cl_int CL_API_CALL
clFlush(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clFinish(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0;
/* Enqueued Commands APIs */
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueReadBuffer(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueReadBufferRect(cl_command_queue /* command_queue */,
cl_mem /* buffer */,
cl_bool /* blocking_read */,
const size_t * /* buffer_offset */,
const size_t * /* host_offset */,
const size_t * /* region */,
size_t /* buffer_row_pitch */,
size_t /* buffer_slice_pitch */,
size_t /* host_row_pitch */,
size_t /* host_slice_pitch */,
void * /* ptr */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_1;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueWriteBuffer(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueWriteBufferRect(cl_command_queue /* command_queue */,
cl_mem /* buffer */,
cl_bool /* blocking_write */,
const size_t * /* buffer_offset */,
const size_t * /* host_offset */,
const size_t * /* region */,
size_t /* buffer_row_pitch */,
size_t /* buffer_slice_pitch */,
size_t /* host_row_pitch */,
size_t /* host_slice_pitch */,
const void * /* ptr */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_1;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueFillBuffer(cl_command_queue /* command_queue */,
cl_mem /* buffer */,
const void * /* pattern */,
size_t /* pattern_size */,
size_t /* offset */,
size_t /* size */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyBuffer(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyBufferRect(cl_command_queue /* command_queue */,
cl_mem /* src_buffer */,
cl_mem /* dst_buffer */,
const size_t * /* src_origin */,
const size_t * /* dst_origin */,
const size_t * /* region */,
size_t /* src_row_pitch */,
size_t /* src_slice_pitch */,
size_t /* dst_row_pitch */,
size_t /* dst_slice_pitch */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_1;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueReadImage(cl_command_queue /* command_queue */,
cl_mem /* image */,
cl_bool /* blocking_read */,
const size_t * /* origin[3] */,
const size_t * /* region[3] */,
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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueWriteImage(cl_command_queue /* command_queue */,
cl_mem /* image */,
cl_bool /* blocking_write */,
const size_t * /* origin[3] */,
const size_t * /* region[3] */,
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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueFillImage(cl_command_queue /* command_queue */,
cl_mem /* image */,
const void * /* fill_color */,
const size_t * /* origin[3] */,
const size_t * /* region[3] */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyImage(cl_command_queue /* command_queue */,
cl_mem /* src_image */,
cl_mem /* dst_image */,
const size_t * /* src_origin[3] */,
const size_t * /* dst_origin[3] */,
const size_t * /* region[3] */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyImageToBuffer(cl_command_queue /* command_queue */,
cl_mem /* src_image */,
cl_mem /* dst_buffer */,
const size_t * /* src_origin[3] */,
const size_t * /* region[3] */,
size_t /* dst_offset */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueCopyBufferToImage(cl_command_queue /* command_queue */,
cl_mem /* src_buffer */,
cl_mem /* dst_image */,
size_t /* src_offset */,
const size_t * /* dst_origin[3] */,
const size_t * /* region[3] */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY void * CL_API_CALL
clEnqueueMapBuffer(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY void * CL_API_CALL
clEnqueueMapImage(cl_command_queue /* command_queue */,
cl_mem /* image */,
cl_bool /* blocking_map */,
cl_map_flags /* map_flags */,
const size_t * /* origin[3] */,
const size_t * /* region[3] */,
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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueUnmapMemObject(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueMigrateMemObjects(cl_command_queue /* command_queue */,
cl_uint /* num_mem_objects */,
const cl_mem * /* mem_objects */,
cl_mem_migration_flags /* flags */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueNDRangeKernel(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueTask(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueNativeKernel(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_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueMarkerWithWaitList(cl_command_queue /* command_queue */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueBarrierWithWaitList(cl_command_queue /* command_queue */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_2;
/* Extension function access
*
* Returns the extension function address for the given function name,
* or NULL if a valid function can not be found. The client must
* check to make sure the address is not NULL, before using or
* calling the returned function address.
*/
extern CL_API_ENTRY void * CL_API_CALL
clGetExtensionFunctionAddressForPlatform(cl_platform_id /* platform */,
const char * /* func_name */) CL_API_SUFFIX__VERSION_1_2;
// Deprecated OpenCL 1.1 APIs
extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL
clCreateImage2D(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_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL
clCreateImage3D(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_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL
clEnqueueMarker(cl_command_queue /* command_queue */,
cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL
clEnqueueWaitForEvents(cl_command_queue /* command_queue */,
cl_uint /* num_events */,
const cl_event * /* event_list */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL
clEnqueueBarrier(cl_command_queue /* command_queue */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL
clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED void * CL_API_CALL
clGetExtensionFunctionAddress(const char * /* func_name */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
#ifdef __cplusplus
}
#endif
#endif /* __OPENCL_CL_H */
| 51.653498 | 179 | 0.527908 | [
"object"
] |
43ff3a849fea137c67cc839105da00e2a69c0b8a | 1,290 | h | C | catboost/private/libs/algo/nonsymmetric_index_calcer.h | jochenater/catboost | de2786fbc633b0d6ea6a23b3862496c6151b95c2 | [
"Apache-2.0"
] | 6,989 | 2017-07-18T06:23:18.000Z | 2022-03-31T15:58:36.000Z | catboost/private/libs/algo/nonsymmetric_index_calcer.h | birichie/catboost | de75c6af12cf490700e76c22072fbdc15b35d679 | [
"Apache-2.0"
] | 1,978 | 2017-07-18T09:17:58.000Z | 2022-03-31T14:28:43.000Z | catboost/private/libs/algo/nonsymmetric_index_calcer.h | birichie/catboost | de75c6af12cf490700e76c22072fbdc15b35d679 | [
"Apache-2.0"
] | 1,228 | 2017-07-18T09:03:13.000Z | 2022-03-29T05:57:40.000Z | #pragma once
#include <catboost/libs/data/data_provider.h>
#include <catboost/private/libs/options/restrictions.h>
#include <util/generic/fwd.h>
#include <util/generic/vector.h>
class TFold;
struct TSplitNode;
struct TNonSymmetricTreeStructure;
class TOnlineCtrBase;
namespace NPar {
class ILocalExecutor;
}
void UpdateIndicesWithSplit(
const TSplitNode& node,
const NCB::TTrainingDataProviders& trainingData,
const NCB::TIndexedSubset<ui32>& docsSubset,
const TFold& fold,
NPar::ILocalExecutor* localExecutor,
TArrayRef<TIndexType> indices,
NCB::TIndexedSubset<ui32>* leftIndices,
NCB::TIndexedSubset<ui32>* rightIndices
);
void UpdateIndices(
const TSplitNode& node,
const NCB::TTrainingDataProviders& trainingData,
const NCB::TIndexedSubset<ui32>& docsSubset,
const TFold& fold,
NPar::ILocalExecutor* localExecutor,
TArrayRef<TIndexType> indices
);
void BuildIndicesForDataset(
const TNonSymmetricTreeStructure& tree,
const NCB::TTrainingDataProviders& trainingData,
const TFold& fold,
ui32 sampleCount,
const TVector<const TOnlineCtrBase*>& onlineCtrs,
ui32 objectSubsetIdx, // 0 - learn, 1+ - test (subtract 1 for testIndex)
NPar::ILocalExecutor* localExecutor,
TIndexType* indices);
| 26.326531 | 76 | 0.748062 | [
"vector"
] |
b741f8be7972af08961d617dc6d14412900044ba | 1,010 | h | C | include/il2cpp/NexPlugin/DataStore/GetMetaListCB.h | martmists-gh/BDSP | d6326c5d3ad9697ea65269ed47aa0b63abac2a0a | [
"MIT"
] | 1 | 2022-01-15T20:20:27.000Z | 2022-01-15T20:20:27.000Z | include/il2cpp/NexPlugin/DataStore/GetMetaListCB.h | martmists-gh/BDSP | d6326c5d3ad9697ea65269ed47aa0b63abac2a0a | [
"MIT"
] | null | null | null | include/il2cpp/NexPlugin/DataStore/GetMetaListCB.h | martmists-gh/BDSP | d6326c5d3ad9697ea65269ed47aa0b63abac2a0a | [
"MIT"
] | null | null | null | #pragma once
#include "il2cpp.h"
void NexPlugin_DataStore_GetMetaListCB___ctor (NexPlugin_DataStore_GetMetaListCB_o* __this, Il2CppObject* object, intptr_t method, const MethodInfo* method_info);
void NexPlugin_DataStore_GetMetaListCB__Invoke (NexPlugin_DataStore_GetMetaListCB_o* __this, NexPlugin_AsyncResult_o* asyncResult, System_Collections_Generic_List_DataStoreMetaInfo__o* info, System_Collections_Generic_List_DataStoreResult__o* resultList, const MethodInfo* method_info);
System_IAsyncResult_o* NexPlugin_DataStore_GetMetaListCB__BeginInvoke (NexPlugin_DataStore_GetMetaListCB_o* __this, NexPlugin_AsyncResult_o* asyncResult, System_Collections_Generic_List_DataStoreMetaInfo__o* info, System_Collections_Generic_List_DataStoreResult__o* resultList, System_AsyncCallback_o* callback, Il2CppObject* object, const MethodInfo* method_info);
void NexPlugin_DataStore_GetMetaListCB__EndInvoke (NexPlugin_DataStore_GetMetaListCB_o* __this, System_IAsyncResult_o* result, const MethodInfo* method_info);
| 112.222222 | 365 | 0.894059 | [
"object"
] |
b743bd890bc56ac2a444cc40659d38bc15147e23 | 952 | h | C | src/menuframe.h | Foltik/LunarOrbitSim | fc9d626a27e334cd14b336260a2c991dc9b76382 | [
"WTFPL"
] | 1 | 2017-05-11T10:53:49.000Z | 2017-05-11T10:53:49.000Z | src/menuframe.h | Foltik/Eldorado | fc9d626a27e334cd14b336260a2c991dc9b76382 | [
"WTFPL"
] | null | null | null | src/menuframe.h | Foltik/Eldorado | fc9d626a27e334cd14b336260a2c991dc9b76382 | [
"WTFPL"
] | null | null | null | #pragma once
#include <k5/k5.h>
#include "earthframe.h"
struct Point {
float x;
float y;
};
struct Rect {
Point bl;
Point tl;
Point tr;
Point br;
};
class MenuFrame : public IFrame {
public:
virtual void Init(CEngine* e) override;
virtual void Cleanup() override;
virtual void Pause() override;
virtual void Resume() override;
virtual void ProcessInput(bool* keyboard, bool* mouse, double mxpos, double mypos) override;
virtual void Loop() override;
virtual void Render() override;
static MenuFrame& Instance() {
static MenuFrame instance;
return instance;
}
protected:
MenuFrame() = default;
MenuFrame(const MenuFrame&) = delete;
MenuFrame(MenuFrame&&) = delete;
void operator=(const MenuFrame&) = delete;
void operator=(MenuFrame&&) = delete;
private:
int menuState = 0;
bool showInfo;
Texture** menuTextures;
GLuint vao;
GLuint vbo;
GLuint ebo;
Shader* shader;
TextRenderer* text;
CEngine* engine;
};
| 16.135593 | 93 | 0.711134 | [
"render"
] |
b74496f2dfe6570828a337852cebac974b8e4558 | 2,802 | h | C | Source/VTKExtensions/IO/vtkOmicronModelInputReader.h | developkits/cmb | caaf9cd7ffe0b7c1ac3be9edbce0f9430068d2cb | [
"BSD-3-Clause"
] | null | null | null | Source/VTKExtensions/IO/vtkOmicronModelInputReader.h | developkits/cmb | caaf9cd7ffe0b7c1ac3be9edbce0f9430068d2cb | [
"BSD-3-Clause"
] | null | null | null | Source/VTKExtensions/IO/vtkOmicronModelInputReader.h | developkits/cmb | caaf9cd7ffe0b7c1ac3be9edbce0f9430068d2cb | [
"BSD-3-Clause"
] | null | null | null | //=========================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//=========================================================================
// .NAME vtkOmicronModelInputReader - Reader for Omicron "model" input files
// .SECTION Description
// Reads files of type expexted by Omicron "model" program (ASCII only).
// This is the file output by SceneGen (and also very similar to the
// SceneGen input?). The "important" components of the file which are read
// are the "volume_constraint" (put in field data), each model name and the
// corresponding translation component (which is the "point inside object")
// that the CMB will write out for input into the "mesh" program. All of
// the above is saved as field data, but the point inside coordinates are
// also saved as points to simplify visualization.
#ifndef __OmicronModelInputReader_h
#define __OmicronModelInputReader_h
#include "cmbSystemConfig.h"
#include "vtkCMBIOModule.h" // For export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
class vtkMultiBlockDataSet;
class vtkPolyData;
class VTKCMBIO_EXPORT vtkOmicronModelInputReader : public vtkMultiBlockDataSetAlgorithm
{
public:
static vtkOmicronModelInputReader* New();
vtkTypeMacro(vtkOmicronModelInputReader, vtkMultiBlockDataSetAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent) override;
// Description:
// Name of the file to be read.
vtkSetStringMacro(FileName);
vtkGetStringMacro(FileName);
// Description:
// Flag indicating whether or not to load geometry
vtkBooleanMacro(LoadGeometry, bool);
vtkSetMacro(LoadGeometry, bool);
vtkGetMacro(LoadGeometry, bool);
//BTX
protected:
vtkOmicronModelInputReader();
~vtkOmicronModelInputReader() override;
char* FileName;
bool LoadGeometry;
vtkPolyData* AddBlock(vtkMultiBlockDataSet* output, const char* fileName, double translation[3],
double rotation[3], double scale, double color[3], const char* additionalIdentifier = 0);
int AddROIBlock(vtkMultiBlockDataSet* output, double (*boundaryCoordinates)[2],
vtkPolyData* surface, double translation[3], double bottom);
int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
private:
vtkOmicronModelInputReader(const vtkOmicronModelInputReader&); // Not implemented.
void operator=(const vtkOmicronModelInputReader&); // Not implemented.
//ETX
};
#endif
| 38.916667 | 98 | 0.731263 | [
"mesh",
"geometry",
"object",
"model"
] |
b74a5bcf52ff611d1605e94373345783089bc9ef | 2,949 | h | C | turnpike/src/uDGP.h | shuai-huang/turnpike-beltway | 20b68a48b68c2daad02346b1c076c0dce99c4431 | [
"Apache-2.0"
] | null | null | null | turnpike/src/uDGP.h | shuai-huang/turnpike-beltway | 20b68a48b68c2daad02346b1c076c0dce99c4431 | [
"Apache-2.0"
] | null | null | null | turnpike/src/uDGP.h | shuai-huang/turnpike-beltway | 20b68a48b68c2daad02346b1c076c0dce99c4431 | [
"Apache-2.0"
] | 1 | 2020-01-06T17:17:17.000Z | 2020-01-06T17:17:17.000Z | #ifndef UDGP_H
#define UDGP_H
#include <iostream>
#include <map>
#include <vector>
#include <random>
#include <Eigen/Dense>
#include "DataReader.h"
#include "global.h"
using namespace Eigen;
using Eigen::MatrixXd;
using Eigen::VectorXd;
using namespace std;
typedef std::pair<int,int> mypair;
class uDGP
{
protected:
VectorXd valid_idx_pos;
vector<int> valid_idx_vec;
vector<int> valid_idx_vec_exclude; // exclude the two anchor points
vector< vector<double> > raw_distribution;
vector<int> all_distance; // discretized distance to be considered
vector<int> all_distance_vec; // note that this is distance, not squared distance, distance_grid
vector<double> all_distance_true; // real distances.
vector<int> D_mat_distance_vec;
VectorXd smp_pos_init;
VectorXd smp_pos;
map<int, double> all_distance_diff; // quantized distances between two different points
map<int, double> all_distribution;
map<int, double> est_distribution;
vector<mypair> all_block_count;
map<int, vector<int>> all_partition;
map<int, double> D_mat_norm;
map<int, int> idx_mapping;
char *smp_pos_init_file;
char *output_ite_file;
int M;
int md_p1;
int num_pos; // number of possible locations
double step;
double obj_val;
double max_distance;
double domain_sz;
int anchor_one;
map<int, double> anchor_one_seq;
int anchor_two;
map<int, double> anchor_two_seq;
int num_thread_assign;
int num_nev;
int max_eigs_ite;
double eigs_tol;
double perturb_factor;
public:
uDGP();
void SetOutputFile(char* output_file);
void SetInitFile(char* init_file);
void SetData(DataReader* data_reader);
void SetMeasureMatrix();
void Initialization();
void GradientDescent();
double NormalCdf(double x_val, double mu, double sigma);
double GetObjFun();
double ComputeEstDbt( VectorXd* smp_vec, int distance_val);
void ComputeEstProj(VectorXd* smp_vec, VectorXd* smp_vec_proj, double mut_factor, int distance_val);
VectorXd GetSamplePos();
VectorXd ProjectOntoCvxSet(VectorXd smp_vec, int num_smp_proj);
virtual double ComputeObjFun(VectorXd smp_vec);
virtual void ComputeObjFunMuti(vector<int> all_distance_block, VectorXd* smp_vec_muti, vector<double>* obj_seq_pt, int val_idx );
virtual VectorXd ComputeGradient(VectorXd smp_vec);
virtual void ComputeGradientMuti( vector<int> all_distance_block, VectorXd* smp_vec_muti, VectorXd* smp_der_seq_pt, int val_idx );
virtual ~uDGP();
};
#endif // UDGP_H
| 28.355769 | 138 | 0.638861 | [
"vector"
] |
b75a4574e7f5bc623e1b9cf6732f06eaba53d29f | 12,487 | c | C | third_party/TI/TivaWare_C_Series-2.1.0.12573/examples/boards/ek-tm4c1294xl-boostxl-senshub/pressure_bmp180/pressure_bmp180.c | briancostabile/tiva-bsp | 603187791cac3c28fd8ca77e286f3f68afa9a39a | [
"MIT"
] | null | null | null | third_party/TI/TivaWare_C_Series-2.1.0.12573/examples/boards/ek-tm4c1294xl-boostxl-senshub/pressure_bmp180/pressure_bmp180.c | briancostabile/tiva-bsp | 603187791cac3c28fd8ca77e286f3f68afa9a39a | [
"MIT"
] | null | null | null | third_party/TI/TivaWare_C_Series-2.1.0.12573/examples/boards/ek-tm4c1294xl-boostxl-senshub/pressure_bmp180/pressure_bmp180.c | briancostabile/tiva-bsp | 603187791cac3c28fd8ca77e286f3f68afa9a39a | [
"MIT"
] | 1 | 2019-06-20T09:21:45.000Z | 2019-06-20T09:21:45.000Z | //*****************************************************************************
//
// pressure_bmp180.c - Example to use of the SensorLib with the BMP180.
//
// Copyright (c) 2013-2014 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
// This is part of revision 2.1.0.12573 of the EK-TM4C1294XL Firmware Package.
//
//*****************************************************************************
#include <stdint.h>
#include <stdbool.h>
#include <math.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_ints.h"
#include "driverlib/debug.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/pin_map.h"
#include "driverlib/rom.h"
#include "driverlib/rom_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/systick.h"
#include "driverlib/uart.h"
#include "utils/uartstdio.h"
#include "sensorlib/hw_bmp180.h"
#include "sensorlib/i2cm_drv.h"
#include "sensorlib/bmp180.h"
#include "drivers/pinout.h"
#include "drivers/buttons.h"
//*****************************************************************************
//
//! \addtogroup example_list
//! <h1>Pressure Measurement with the BMP180 (pressure_bmp180)</h1>
//!
//! This example demonstrates the basic use of the Sensor Library, the
//! EK-TM4C1294XL LaunchPad, and the SensHub BoosterPack to obtain air pressure
//! and temperature measurements with the BMP180 sensor.
//!
//! SensHub BoosterPack (BOOSTXL-SENSHUB) must be installed on BoosterPack 1
//! interface headers.
//!
//! Instructions for use of SensorHub on BoosterPack 2 headers are in the code
//! comments.
//!
//! Connect a serial terminal program to the LaunchPad's ICDI virtual serial
//! port at 115,200 baud. Use eight bits per byte, no parity and one stop bit.
//! The raw sensor measurements are printed to the terminal. The LED
//! blinks at 1 Hz once the initialization is complete and the example is
//! running.
//
//*****************************************************************************
//*****************************************************************************
//
// Define BMP180 I2C Address.
//
//*****************************************************************************
#define BMP180_I2C_ADDRESS 0x77
//*****************************************************************************
//
// Global instance structure for the I2C master driver.
//
//*****************************************************************************
tI2CMInstance g_sI2CInst;
//*****************************************************************************
//
// Global instance structure for the BMP180 sensor driver.
//
//*****************************************************************************
tBMP180 g_sBMP180Inst;
//*****************************************************************************
//
// Global new data flag to alert main that BMP180 data is ready.
//
//*****************************************************************************
volatile uint_fast8_t g_vui8DataFlag;
//*****************************************************************************
//
// The error routine that is called if the driver library encounters an error.
//
//*****************************************************************************
#ifdef DEBUG
void
__error__(char *pcFilename, uint32_t ui32Line)
{
}
#endif
//*****************************************************************************
//
// BMP180 Sensor callback function. Called at the end of BMP180 sensor driver
// transactions. This is called from I2C interrupt context. Therefore, we just
// set a flag and let main do the bulk of the computations and display.
//
//*****************************************************************************
void BMP180AppCallback(void* pvCallbackData, uint_fast8_t ui8Status)
{
//
// If the transaction was successful then set the data ready flag.
if(ui8Status == I2CM_STATUS_SUCCESS)
{
g_vui8DataFlag = 1;
}
//
// Turn off the LED to show read is complete.
//
LEDWrite(CLP_D1 | CLP_D2, 0);
}
//*****************************************************************************
//
// Called by the NVIC as a result of I2C7 Interrupt. I2C7 is the I2C connection
// to the BMP180.
//
// This handler is installed in the vector table for I2C7 by default. To use
// the SensHub on BoosterPack 2 interface change the startup file to place this
// interrupt in I2C8 vector location.
//
//*****************************************************************************
void
BMP180I2CIntHandler(void)
{
//
// Pass through to the I2CM interrupt handler provided by sensor library.
// This is required to be at application level so that I2CMIntHandler can
// receive the instance structure pointer as an argument.
//
I2CMIntHandler(&g_sI2CInst);
}
//*****************************************************************************
//
// Called by the NVIC as a SysTick interrupt, which is used to generate the
// sample interval.
//
//*****************************************************************************
void
SysTickIntHandler()
{
//
// Turn on the LED to indicate we are reading.
//
LEDWrite(CLP_D1 | CLP_D2, CLP_D2);
//
// Start a read of data from the pressure sensor. BMP180AppCallback is
// called when the read is complete.
//
BMP180DataRead(&g_sBMP180Inst, BMP180AppCallback, &g_sBMP180Inst);
}
//*****************************************************************************
//
// Main 'C' Language entry point.
//
//*****************************************************************************
int
main(void)
{
float fTemperature, fPressure, fAltitude;
int32_t i32IntegerPart;
int32_t i32FractionPart;
uint32_t ui32SysClock;
//
// Configure the system frequency.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins for this board.
// This application does not use Ethernet or USB.
//
PinoutSet(false, false);
//
// Enable UART0
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Initialize the UART for console I/O.
//
UARTStdioConfig(0, 115200, ui32SysClock);
//
// Clear the terminal and print the welcome message.
//
UARTprintf("\033[2J\033[H");
UARTprintf("BMP180 Example\n");
//
// The I2C7 peripheral must be enabled before use.
//
// For BoosterPack 2 interface change this to I2C8.
// Change the GPIO port to GPIO port A.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C7);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//
// Configure the pin muxing for I2C7 functions on port D0 and D1.
// This step is not necessary if your part does not support pin muxing.
//
// For BoosterPack 2 interface change these to PA3_I2C8SDA and PA2_I2C8SCL.
//
ROM_GPIOPinConfigure(GPIO_PD0_I2C7SCL);
ROM_GPIOPinConfigure(GPIO_PD1_I2C7SDA);
//
// Select the I2C function for these pins. This function will also
// configure the GPIO pins for I2C operation, setting them to
// open-drain operation with weak pull-ups. Consult the data sheet
// to see which functions are allocated per pin.
//
// For BoosterPack 2 interface change these to PA2 (SCL) and PA3 (SDA).
//
GPIOPinTypeI2CSCL(GPIO_PORTD_BASE, GPIO_PIN_0);
ROM_GPIOPinTypeI2C(GPIO_PORTD_BASE, GPIO_PIN_1);
//
// Enable interrupts to the processor.
//
ROM_IntMasterEnable();
//
// Initialize I2C7 peripheral.
//
// For BoosterPack 2 change these to I2C8.
//
I2CMInit(&g_sI2CInst, I2C7_BASE, INT_I2C7, 0xff, 0xff, ui32SysClock);
//
// Turn on the LED to indicate we are performing BMP180 init.
// Turned off automatically inside the application callback for the BMP180
// init is when complete.
//
LEDWrite(CLP_D1 | CLP_D2, CLP_D2);
//
// Initialize the BMP180.
//
BMP180Init(&g_sBMP180Inst, &g_sI2CInst, BMP180_I2C_ADDRESS,
BMP180AppCallback, &g_sBMP180Inst);
//
// Wait for initialization callback to indicate reset request is complete.
//
while(g_vui8DataFlag == 0)
{
//
// Wait for I2C transactions to complete.
//
}
//
// Reset the data ready flag.
//
g_vui8DataFlag = 0;
//
// Enable the system ticks at 10 Hz.
//
ROM_SysTickPeriodSet(ui32SysClock / (10 * 3));
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Begin the data collection and printing. Loop Forever.
//
while(1)
{
//
// The reads are started by SysTick Interrupt, we poll here to detect
// when a read is complete.
//
while(g_vui8DataFlag == 0)
{
//
// Wait for the new data set to be available.
//
}
//
// Reset the data ready flag.
//
g_vui8DataFlag = 0;
//
// Get a local copy of the latest temperature and pressure data in
// float format.
//
BMP180DataTemperatureGetFloat(&g_sBMP180Inst, &fTemperature);
BMP180DataPressureGetFloat(&g_sBMP180Inst, &fPressure);
//
// Convert the temperature to an integer part and fraction part for
// easy print.
//
i32IntegerPart = (int32_t) fTemperature;
i32FractionPart =(int32_t) (fTemperature * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print temperature with three digits of decimal precision.
//
UARTprintf("Temperature %3d.%03d\t\t", i32IntegerPart,
i32FractionPart);
//
// Convert the pressure to an integer part and fraction part for
// easy print.
//
i32IntegerPart = (int32_t) fPressure;
i32FractionPart =(int32_t) (fPressure * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print Pressure with three digits of decimal precision.
//
UARTprintf("Pressure %3d.%03d\t\t", i32IntegerPart, i32FractionPart);
//
// Calculate the altitude.
//
fAltitude = 44330.0f * (1.0f - powf(fPressure / 101325.0f,
1.0f / 5.255f));
//
// Convert the altitude to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fAltitude;
i32FractionPart =(int32_t) (fAltitude * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print altitude with three digits of decimal precision.
//
UARTprintf("Altitude %3d.%03d", i32IntegerPart, i32FractionPart);
//
// Print new line.
//
UARTprintf("\n");
}//while end
}
| 32.518229 | 81 | 0.53832 | [
"vector",
"3d"
] |
b761e36679fa4dbb89551789bbf07b006f80f923 | 2,059 | h | C | rr_muplay/src/MuplayLinker.h | Programming-Systems-Lab/ATTUNE | cd4ed3d460e82af2a6e255fa2267e4d08ecb4259 | [
"MIT"
] | null | null | null | rr_muplay/src/MuplayLinker.h | Programming-Systems-Lab/ATTUNE | cd4ed3d460e82af2a6e255fa2267e4d08ecb4259 | [
"MIT"
] | null | null | null | rr_muplay/src/MuplayLinker.h | Programming-Systems-Lab/ATTUNE | cd4ed3d460e82af2a6e255fa2267e4d08ecb4259 | [
"MIT"
] | null | null | null | #ifndef RR_MUPLAY_LINKER_H_
#define RR_MUPLAY_LINKER_H_
#include <memory>
#include "MuplayElf.h"
#include "MuplaySession.h"
namespace rr {
/* Some functions can read either the old or the modified elf. This is a
flag that specifies which one you want */
enum MUPLAY_READER_TYPE { OLD, MOD };
/* Once the new code has been loaded need to link it in the
context of the original executable. This means both
the relocation entries and the global variable references */
class MuplayLinker{
public:
/* Constructors */
MuplayLinker(MuplayElf& old_elf,
MuplayElf& mod_elf,
std::vector<CustomLoadedSegment>& custom_segments,
std::vector<MuplayBinaryModificationSummary>& summaries,
Task* curr);
/* Fields */
MuplayElf old_elf; /* The exe that is recorded */
MuplayElf mod_elf; /* exe with the modifications */
std::vector<CustomLoadedSegment> custom_segments;
std::vector<MuplayBinaryModificationSummary> summaries;
Task* curr; /*Task that is being traced and will be overwritten */
MuplayElfReader old_elf_reader;
MuplayElfReader mod_elf_reader;
/* Functions */
/* Do the standard relocations as required by the modified elf file */
void do_standard_relocations();
/* Do a single standard relocation */
void do_standard_relocation(Elf64_Rela rela, Elf64_Shdr rel_shdr);
/* Do all the relocations required by the patched file */
void do_all_relocations();
/* gets the symbol name for a given relocation entry */
std::string get_mod_sym_name(Elf64_Rela rela, Elf64_Shdr rel_shdr, MUPLAY_READER_TYPE read_type);
/* Reads the index in symtab from the rela entry */
int read_rela_sym(Elf64_Rela rela);
/* Reads the relocation info and extracts relocation type */
int read_rela_type(Elf64_Rela rela);
/*encapsulate write_mem function*/
template <typename T>
void over_write(remote_code_ptr addr, int size, T buf, Task *curr);
};
} // namespace rr
#endif
| 30.279412 | 101 | 0.702283 | [
"vector"
] |
b762e754efc82417747f184d90bb0eb95eb9fda7 | 865 | h | C | GeminiSDK/libs/Gemini/GemTransistion.h | indiejames/GeminiSDK | 4f28aa7e9a4b62ac486337d34dc42cd514b7f37b | [
"MIT",
"Unlicense"
] | 1 | 2015-09-01T12:42:11.000Z | 2015-09-01T12:42:11.000Z | GeminiSDK/libs/Gemini/GemTransistion.h | indiejames/GeminiSDK | 4f28aa7e9a4b62ac486337d34dc42cd514b7f37b | [
"MIT",
"Unlicense"
] | null | null | null | GeminiSDK/libs/Gemini/GemTransistion.h | indiejames/GeminiSDK | 4f28aa7e9a4b62ac486337d34dc42cd514b7f37b | [
"MIT",
"Unlicense"
] | null | null | null | //
// GeminiTransistion.h
// Gemini
//
// Created by James Norton on 5/27/12.
// Copyright (c) 2012 __MyCompanyName__. All rights reserved.
//
#import <Foundation/Foundation.h>
#import "GemDisplayObject.h"
#import "LGeminiLuaSupport.h"
typedef enum {
GEM_LINEAR_EASING,
GEM_NONLINEAR_EASING
} GemEasingType;
@interface GemTransistion : NSObject {
double elapsedTime;
double duration;
double delay;
int onStart; // ref to lua method
int onComplete; // ref to lua method
lua_State *L;
NSMutableDictionary *finalParamValues;
NSMutableDictionary *initialParamValues;
GemEasingType easing;
GemDisplayObject *obj;
}
-(id)initWithLuaState:(lua_State *)lua_state Object:(GemDisplayObject *)object Data:(NSDictionary *)data To:(BOOL)to;
-(void)update:(double)secondsSinceLastUpdate;
-(BOOL)isActive;
@end
| 21.625 | 117 | 0.720231 | [
"object"
] |
b7639187cecd4212ed2fac1fd1e064da1201129b | 7,234 | h | C | tracker_ws/devel/include/gb_visual_detection_3d_msgs/BoundingBox3d.h | JisuHann/Point-Cloud--Grasp | 083244632412709dbc29ac7841b6a837e4ed3cb6 | [
"BSD-2-Clause"
] | null | null | null | tracker_ws/devel/include/gb_visual_detection_3d_msgs/BoundingBox3d.h | JisuHann/Point-Cloud--Grasp | 083244632412709dbc29ac7841b6a837e4ed3cb6 | [
"BSD-2-Clause"
] | null | null | null | tracker_ws/devel/include/gb_visual_detection_3d_msgs/BoundingBox3d.h | JisuHann/Point-Cloud--Grasp | 083244632412709dbc29ac7841b6a837e4ed3cb6 | [
"BSD-2-Clause"
] | 1 | 2021-03-31T06:27:31.000Z | 2021-03-31T06:27:31.000Z | // Generated by gencpp from file gb_visual_detection_3d_msgs/BoundingBox3d.msg
// DO NOT EDIT!
#ifndef GB_VISUAL_DETECTION_3D_MSGS_MESSAGE_BOUNDINGBOX3D_H
#define GB_VISUAL_DETECTION_3D_MSGS_MESSAGE_BOUNDINGBOX3D_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace gb_visual_detection_3d_msgs
{
template <class ContainerAllocator>
struct BoundingBox3d_
{
typedef BoundingBox3d_<ContainerAllocator> Type;
BoundingBox3d_()
: Class()
, probability(0.0)
, xmin(0.0)
, ymin(0.0)
, xmax(0.0)
, ymax(0.0)
, zmin(0.0)
, zmax(0.0) {
}
BoundingBox3d_(const ContainerAllocator& _alloc)
: Class(_alloc)
, probability(0.0)
, xmin(0.0)
, ymin(0.0)
, xmax(0.0)
, ymax(0.0)
, zmin(0.0)
, zmax(0.0) {
(void)_alloc;
}
typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _Class_type;
_Class_type Class;
typedef double _probability_type;
_probability_type probability;
typedef double _xmin_type;
_xmin_type xmin;
typedef double _ymin_type;
_ymin_type ymin;
typedef double _xmax_type;
_xmax_type xmax;
typedef double _ymax_type;
_ymax_type ymax;
typedef double _zmin_type;
_zmin_type zmin;
typedef double _zmax_type;
_zmax_type zmax;
typedef boost::shared_ptr< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> const> ConstPtr;
}; // struct BoundingBox3d_
typedef ::gb_visual_detection_3d_msgs::BoundingBox3d_<std::allocator<void> > BoundingBox3d;
typedef boost::shared_ptr< ::gb_visual_detection_3d_msgs::BoundingBox3d > BoundingBox3dPtr;
typedef boost::shared_ptr< ::gb_visual_detection_3d_msgs::BoundingBox3d const> BoundingBox3dConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator1> & lhs, const ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator2> & rhs)
{
return lhs.Class == rhs.Class &&
lhs.probability == rhs.probability &&
lhs.xmin == rhs.xmin &&
lhs.ymin == rhs.ymin &&
lhs.xmax == rhs.xmax &&
lhs.ymax == rhs.ymax &&
lhs.zmin == rhs.zmin &&
lhs.zmax == rhs.zmax;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator1> & lhs, const ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace gb_visual_detection_3d_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsFixedSize< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct IsMessage< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> >
{
static const char* value()
{
return "6e20dcf06c2cb2c3714e76bbf196e60c";
}
static const char* value(const ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x6e20dcf06c2cb2c3ULL;
static const uint64_t static_value2 = 0x714e76bbf196e60cULL;
};
template<class ContainerAllocator>
struct DataType< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> >
{
static const char* value()
{
return "gb_visual_detection_3d_msgs/BoundingBox3d";
}
static const char* value(const ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> >
{
static const char* value()
{
return "string Class\n"
"float64 probability\n"
"float64 xmin\n"
"float64 ymin\n"
"float64 xmax\n"
"float64 ymax\n"
"float64 zmin\n"
"float64 zmax\n"
;
}
static const char* value(const ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.Class);
stream.next(m.probability);
stream.next(m.xmin);
stream.next(m.ymin);
stream.next(m.xmax);
stream.next(m.ymax);
stream.next(m.zmin);
stream.next(m.zmax);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct BoundingBox3d_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::gb_visual_detection_3d_msgs::BoundingBox3d_<ContainerAllocator>& v)
{
s << indent << "Class: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.Class);
s << indent << "probability: ";
Printer<double>::stream(s, indent + " ", v.probability);
s << indent << "xmin: ";
Printer<double>::stream(s, indent + " ", v.xmin);
s << indent << "ymin: ";
Printer<double>::stream(s, indent + " ", v.ymin);
s << indent << "xmax: ";
Printer<double>::stream(s, indent + " ", v.xmax);
s << indent << "ymax: ";
Printer<double>::stream(s, indent + " ", v.ymax);
s << indent << "zmin: ";
Printer<double>::stream(s, indent + " ", v.zmin);
s << indent << "zmax: ";
Printer<double>::stream(s, indent + " ", v.zmax);
}
};
} // namespace message_operations
} // namespace ros
#endif // GB_VISUAL_DETECTION_3D_MSGS_MESSAGE_BOUNDINGBOX3D_H
| 27.195489 | 175 | 0.732375 | [
"vector"
] |
b767ce97cd917af834276bcdbe2344dc40f6b6be | 43,447 | c | C | lvgl/src/lv_font/lv_font_eurostyle_bold_18.c | HX2003/scifi_lvgl_codeblocks_simulator | c7eeec69c49694727e10d8d674ec78ef5ce7e493 | [
"MIT"
] | 1 | 2021-01-08T03:09:49.000Z | 2021-01-08T03:09:49.000Z | lvgl/src/lv_font/lv_font_eurostyle_bold_18.c | HX2003/scifi_lvgl_codeblocks_simulator | c7eeec69c49694727e10d8d674ec78ef5ce7e493 | [
"MIT"
] | null | null | null | lvgl/src/lv_font/lv_font_eurostyle_bold_18.c | HX2003/scifi_lvgl_codeblocks_simulator | c7eeec69c49694727e10d8d674ec78ef5ce7e493 | [
"MIT"
] | null | null | null | #include "lvgl/lvgl.h"
/*******************************************************************************
* Size: 18 px
* Bpp: 4
* Opts:
******************************************************************************/
#ifndef LV_FONT_EUROSTYLE_BOLD_18
#define LV_FONT_EUROSTYLE_BOLD_18 1
#endif
#if LV_FONT_EUROSTYLE_BOLD_18
/*-----------------
* BITMAPS
*----------------*/
/*Store the image of the glyphs*/
static LV_ATTRIBUTE_LARGE_CONST const uint8_t gylph_bitmap[] = {
/* U+20 " " */
/* U+21 "!" */
0xbf, 0x7b, 0xf7, 0xbf, 0x7a, 0xf6, 0xaf, 0x6a,
0xf6, 0xaf, 0x69, 0xf5, 0x47, 0x20, 0x0, 0x24,
0x19, 0xf6, 0x9f, 0x60,
/* U+22 "\"" */
0x2f, 0xa0, 0xfd, 0x1f, 0x90, 0xfc, 0x1f, 0x90,
0xeb, 0xf, 0x80, 0xda, 0xf, 0x70, 0xc9, 0x0,
0x0, 0x0,
/* U+23 "#" */
0x0, 0x2, 0xf5, 0x4, 0xf4, 0x0, 0x0, 0x5f,
0x30, 0x6f, 0x20, 0x0, 0x7, 0xf0, 0x8, 0xf0,
0x0, 0x0, 0x9e, 0x0, 0xad, 0x0, 0xa, 0xff,
0xff, 0xff, 0xff, 0xa0, 0x67, 0xfc, 0x77, 0xfc,
0x74, 0x0, 0xf, 0x70, 0x1f, 0x60, 0x0, 0x24,
0xf6, 0x26, 0xf5, 0x20, 0x4f, 0xff, 0xff, 0xff,
0xff, 0x2, 0x5a, 0xf5, 0x5b, 0xf5, 0x50, 0x0,
0xad, 0x0, 0xbc, 0x0, 0x0, 0xc, 0xb0, 0xe,
0xa0, 0x0, 0x0, 0xf9, 0x0, 0xf8, 0x0, 0x0,
/* U+24 "$" */
0x0, 0x0, 0x1f, 0x50, 0x0, 0x0, 0x3a, 0xef,
0xff, 0xec, 0x40, 0xe, 0xff, 0xff, 0xff, 0xff,
0x25, 0xff, 0x51, 0xf5, 0x2e, 0xf6, 0x6f, 0xc0,
0x1f, 0x50, 0x9f, 0x86, 0xfc, 0x1, 0xf5, 0x0,
0x0, 0x4f, 0xf5, 0x1f, 0x50, 0x0, 0x0, 0xdf,
0xff, 0xff, 0xfd, 0x90, 0x1, 0x7b, 0xcf, 0xee,
0xff, 0x90, 0x0, 0x1, 0xf5, 0x8, 0xfd, 0x8e,
0x80, 0x1f, 0x50, 0x4f, 0xd7, 0xfd, 0x1, 0xf5,
0xb, 0xfc, 0x2f, 0xff, 0xff, 0xff, 0xff, 0x70,
0x4c, 0xff, 0xff, 0xfd, 0x70, 0x0, 0x0, 0x1f,
0x50, 0x0, 0x0, 0x0, 0x0, 0x93, 0x0, 0x0,
/* U+25 "%" */
0x1c, 0xff, 0xc1, 0x0, 0x0, 0xe4, 0x0, 0x6d,
0x22, 0xd6, 0x0, 0x8, 0xa0, 0x0, 0x8a, 0x0,
0xa8, 0x0, 0x2e, 0x10, 0x0, 0x9a, 0x0, 0xa8,
0x0, 0xa8, 0x0, 0x0, 0x9a, 0x0, 0xa8, 0x4,
0xe0, 0x0, 0x0, 0x7c, 0x0, 0xd6, 0xd, 0x50,
0x0, 0x0, 0x1d, 0xff, 0xe2, 0x6c, 0x0, 0x0,
0x0, 0x0, 0x11, 0x1, 0xe2, 0x8, 0xee, 0xd5,
0x0, 0x0, 0x9, 0x90, 0x1f, 0x42, 0x8c, 0x0,
0x0, 0x2e, 0x10, 0x3f, 0x0, 0x4e, 0x0, 0x0,
0xb6, 0x0, 0x3f, 0x0, 0x4e, 0x0, 0x5, 0xd0,
0x0, 0x2f, 0x21, 0x9c, 0x0, 0xd, 0x40, 0x0,
0x9, 0xff, 0xe6,
/* U+26 "&" */
0x0, 0x8, 0xdf, 0xfe, 0x90, 0x0, 0x0, 0x7,
0xff, 0xed, 0xff, 0x80, 0x0, 0x0, 0xbf, 0xa0,
0x5, 0xfc, 0x0, 0x0, 0xa, 0xf7, 0x0, 0x2f,
0xd0, 0x0, 0x0, 0x6f, 0xe1, 0x0, 0x0, 0x0,
0x0, 0x3, 0xff, 0xc1, 0x0, 0x0, 0x0, 0x6,
0xff, 0xef, 0xd1, 0x6, 0x50, 0x0, 0xdf, 0x70,
0xbf, 0xd2, 0xfe, 0x0, 0xf, 0xf2, 0x0, 0x9f,
0xef, 0xd0, 0x0, 0xff, 0x20, 0x0, 0x8f, 0xfb,
0x0, 0xe, 0xf6, 0x0, 0x0, 0xdf, 0xf4, 0x0,
0x8f, 0xfe, 0xdd, 0xff, 0xef, 0xf2, 0x0, 0x7c,
0xef, 0xfe, 0xa2, 0x39, 0x0,
/* U+27 "'" */
0x2f, 0xa1, 0xf9, 0x1f, 0x90, 0xf8, 0xf, 0x70,
0x0,
/* U+28 "(" */
0x1, 0xae, 0xa0, 0xaf, 0xfa, 0xd, 0xf8, 0x0,
0xff, 0x30, 0xf, 0xf2, 0x1, 0xff, 0x20, 0x1f,
0xf2, 0x1, 0xff, 0x20, 0x1f, 0xf2, 0x1, 0xff,
0x20, 0x1f, 0xf2, 0x1, 0xff, 0x20, 0xf, 0xf2,
0x0, 0xff, 0x30, 0xd, 0xf8, 0x0, 0xaf, 0xfa,
0x1, 0xae, 0xa0,
/* U+29 ")" */
0x1f, 0xd6, 0x1, 0xff, 0xf3, 0x2, 0xef, 0x60,
0xa, 0xf8, 0x0, 0x9f, 0x90, 0x9, 0xfa, 0x0,
0x9f, 0xa0, 0x9, 0xfa, 0x0, 0x9f, 0xa0, 0x9,
0xfa, 0x0, 0x9f, 0xa0, 0x9, 0xfa, 0x0, 0x9f,
0x90, 0xa, 0xf8, 0x2, 0xef, 0x61, 0xff, 0xf3,
0x1f, 0xd6, 0x0,
/* U+2A "*" */
0x0, 0xf, 0x30, 0x1, 0x10, 0xf3, 0x2, 0x7f,
0xbf, 0xbf, 0xb0, 0x4c, 0xfe, 0x61, 0x0, 0xdc,
0xf2, 0x0, 0x8d, 0x9, 0xb0, 0x1, 0x20, 0x12,
0x0,
/* U+2B "+" */
0x0, 0x2, 0x64, 0x0, 0x0, 0x0, 0x6, 0xfa,
0x0, 0x0, 0x0, 0x6, 0xfa, 0x0, 0x0, 0x0,
0x6, 0xfa, 0x0, 0x0, 0xcf, 0xff, 0xff, 0xff,
0xf1, 0xdf, 0xff, 0xff, 0xff, 0xf1, 0x0, 0x6,
0xfa, 0x0, 0x0, 0x0, 0x6, 0xfa, 0x0, 0x0,
0x0, 0x6, 0xfa, 0x0, 0x0, 0x0, 0x6, 0xfa,
0x0, 0x0,
/* U+2C "," */
0x4, 0x40, 0xff, 0xf, 0xf0, 0x6e, 0x3f, 0x60,
/* U+2D "-" */
0x0, 0x0, 0xf, 0xff, 0xf0, 0xff, 0xff, 0x0,
/* U+2E "." */
0x4, 0x41, 0xfe, 0x1f, 0xe0,
/* U+2F "/" */
0x0, 0x0, 0x0, 0x0, 0xe, 0x80, 0x0, 0x0,
0x0, 0x8, 0xe1, 0x0, 0x0, 0x0, 0x1, 0xf7,
0x0, 0x0, 0x0, 0x0, 0x9e, 0x0, 0x0, 0x0,
0x0, 0x2f, 0x50, 0x0, 0x0, 0x0, 0xb, 0xc0,
0x0, 0x0, 0x0, 0x3, 0xf4, 0x0, 0x0, 0x0,
0x0, 0xcb, 0x0, 0x0, 0x0, 0x0, 0x5f, 0x30,
0x0, 0x0, 0x0, 0xd, 0xa0, 0x0, 0x0, 0x0,
0x6, 0xf2, 0x0, 0x0, 0x0, 0x0, 0xe8, 0x0,
0x0, 0x0, 0x0, 0x8e, 0x10, 0x0, 0x0, 0x0,
0x1f, 0x70, 0x0, 0x0, 0x0, 0x9, 0xe0, 0x0,
0x0, 0x0, 0x2, 0xf6, 0x0, 0x0, 0x0, 0x0,
0xad, 0x0, 0x0, 0x0, 0x0, 0x0,
/* U+30 "0" */
0x1, 0x8d, 0xff, 0xfd, 0xa2, 0x0, 0xaf, 0xff,
0xff, 0xff, 0xe0, 0xe, 0xf9, 0x21, 0x16, 0xff,
0x31, 0xff, 0x20, 0x0, 0xe, 0xf5, 0x2f, 0xf1,
0x0, 0x0, 0xcf, 0x72, 0xff, 0x0, 0x0, 0xc,
0xf7, 0x3f, 0xf0, 0x0, 0x0, 0xcf, 0x72, 0xff,
0x0, 0x0, 0xc, 0xf7, 0x2f, 0xf1, 0x0, 0x0,
0xdf, 0x71, 0xff, 0x20, 0x0, 0xe, 0xf5, 0xe,
0xf9, 0x21, 0x17, 0xff, 0x30, 0xaf, 0xff, 0xff,
0xff, 0xe0, 0x1, 0x9d, 0xff, 0xfe, 0xa2, 0x0,
/* U+31 "1" */
0x0, 0x6, 0xff, 0xf0, 0x6, 0xff, 0xff, 0x6,
0xff, 0xaf, 0xf6, 0xff, 0x65, 0xff, 0x4f, 0x70,
0x5f, 0xf0, 0x30, 0x5, 0xff, 0x0, 0x0, 0x5f,
0xf0, 0x0, 0x5, 0xff, 0x0, 0x0, 0x5f, 0xf0,
0x0, 0x5, 0xff, 0x0, 0x0, 0x5f, 0xf0, 0x0,
0x5, 0xff, 0x0, 0x0, 0x5f, 0xf0,
/* U+32 "2" */
0x7, 0xcf, 0xff, 0xd8, 0x0, 0x7f, 0xff, 0xff,
0xff, 0x90, 0xcf, 0x90, 0x0, 0x8f, 0xe0, 0xef,
0x50, 0x0, 0x3f, 0xf0, 0x9a, 0x20, 0x0, 0x2f,
0xf1, 0x0, 0x0, 0x0, 0x7f, 0xf0, 0x0, 0x26,
0xae, 0xff, 0xb0, 0x2d, 0xff, 0xff, 0xfa, 0x10,
0xbf, 0xfc, 0x84, 0x0, 0x0, 0xef, 0x70, 0x0,
0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0xff,
0xee, 0xee, 0xee, 0xe1, 0xff, 0xff, 0xff, 0xff,
0xf1,
/* U+33 "3" */
0x0, 0x9d, 0xff, 0xfd, 0x91, 0x0, 0x9f, 0xff,
0xff, 0xff, 0xa0, 0xe, 0xf8, 0x0, 0x7, 0xff,
0x0, 0xff, 0x40, 0x0, 0x3f, 0xf0, 0x0, 0x0,
0x0, 0x6, 0xfc, 0x0, 0x0, 0x4, 0xde, 0xfd,
0x30, 0x0, 0x0, 0x5f, 0xff, 0xc3, 0x0, 0x0,
0x0, 0x0, 0x6f, 0xe0, 0x1a, 0xa0, 0x0, 0x1,
0xff, 0x22, 0xff, 0x20, 0x0, 0x1f, 0xf3, 0xf,
0xf7, 0x0, 0x6, 0xff, 0x10, 0xaf, 0xff, 0xff,
0xff, 0xb0, 0x0, 0x8d, 0xff, 0xfd, 0x91, 0x0,
/* U+34 "4" */
0x0, 0x0, 0xa, 0xff, 0xf3, 0x0, 0x0, 0x6,
0xff, 0xff, 0x30, 0x0, 0x2, 0xff, 0x7f, 0xf3,
0x0, 0x0, 0xcf, 0xa1, 0xff, 0x30, 0x0, 0x8f,
0xe1, 0x1f, 0xf3, 0x0, 0x4f, 0xf3, 0x1, 0xff,
0x30, 0x1e, 0xf8, 0x0, 0x1f, 0xf3, 0x7, 0xfc,
0x0, 0x1, 0xff, 0x30, 0x8f, 0xed, 0xdd, 0xdf,
0xfe, 0x88, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0,
0x0, 0x0, 0x1f, 0xf3, 0x0, 0x0, 0x0, 0x1,
0xff, 0x30, 0x0, 0x0, 0x0, 0x1f, 0xf3, 0x0,
/* U+35 "5" */
0xaf, 0xff, 0xff, 0xff, 0xc0, 0xaf, 0xfe, 0xee,
0xee, 0xa0, 0xaf, 0x70, 0x0, 0x0, 0x0, 0xaf,
0x60, 0x0, 0x0, 0x0, 0xaf, 0x9b, 0xff, 0xe9,
0x10, 0xaf, 0xff, 0xff, 0xff, 0xb0, 0x8d, 0x91,
0x0, 0x6f, 0xf1, 0x0, 0x0, 0x0, 0xf, 0xf3,
0x0, 0x0, 0x0, 0xf, 0xf4, 0xbd, 0x40, 0x0,
0xf, 0xf3, 0xcf, 0xa0, 0x0, 0x5f, 0xf1, 0x7f,
0xff, 0xff, 0xff, 0xa0, 0x7, 0xcf, 0xff, 0xd8,
0x0,
/* U+36 "6" */
0x0, 0x7c, 0xef, 0xfd, 0x91, 0x0, 0x7f, 0xff,
0xff, 0xff, 0xc0, 0xc, 0xf9, 0x0, 0x6, 0xff,
0x10, 0xef, 0x40, 0x0, 0x1a, 0xa1, 0xf, 0xf4,
0x0, 0x0, 0x0, 0x0, 0xff, 0x6a, 0xde, 0xd9,
0x10, 0xf, 0xff, 0xff, 0xff, 0xfd, 0x0, 0xff,
0x91, 0x0, 0x6f, 0xf2, 0xf, 0xf3, 0x0, 0x0,
0xff, 0x30, 0xef, 0x30, 0x0, 0xf, 0xf3, 0xc,
0xf9, 0x0, 0x5, 0xff, 0x10, 0x7f, 0xff, 0xff,
0xff, 0xc0, 0x0, 0x7c, 0xef, 0xfd, 0x91, 0x0,
/* U+37 "7" */
0x2f, 0xff, 0xff, 0xff, 0xfc, 0x2f, 0xff, 0xff,
0xff, 0xfc, 0x0, 0x0, 0x0, 0xc, 0xfa, 0x0,
0x0, 0x0, 0x3f, 0xf3, 0x0, 0x0, 0x0, 0xaf,
0xc0, 0x0, 0x0, 0x2, 0xff, 0x40, 0x0, 0x0,
0x9, 0xfd, 0x0, 0x0, 0x0, 0x1f, 0xf6, 0x0,
0x0, 0x0, 0x8f, 0xe0, 0x0, 0x0, 0x0, 0xff,
0x80, 0x0, 0x0, 0x7, 0xff, 0x10, 0x0, 0x0,
0xe, 0xf9, 0x0, 0x0, 0x0, 0x6f, 0xf2, 0x0,
0x0,
/* U+38 "8" */
0x0, 0x9d, 0xff, 0xfd, 0xa2, 0x0, 0x9f, 0xff,
0xff, 0xff, 0xc0, 0xd, 0xf8, 0x0, 0x5, 0xff,
0x10, 0xef, 0x50, 0x0, 0x2f, 0xf1, 0xc, 0xf8,
0x0, 0x5, 0xff, 0x0, 0x3d, 0xff, 0xee, 0xff,
0x60, 0x2, 0xcf, 0xff, 0xff, 0xb1, 0x0, 0xcf,
0x80, 0x0, 0x6f, 0xd0, 0xf, 0xf2, 0x0, 0x0,
0xff, 0x21, 0xff, 0x20, 0x0, 0xf, 0xf4, 0xf,
0xf7, 0x0, 0x5, 0xff, 0x20, 0xaf, 0xff, 0xff,
0xff, 0xd0, 0x1, 0x8d, 0xff, 0xfd, 0xa2, 0x0,
/* U+39 "9" */
0x0, 0x8d, 0xff, 0xfd, 0x80, 0x0, 0x9f, 0xff,
0xff, 0xff, 0x90, 0xe, 0xf8, 0x0, 0x7, 0xfe,
0x0, 0xff, 0x30, 0x0, 0x1f, 0xf0, 0xf, 0xf3,
0x0, 0x1, 0xff, 0x10, 0xff, 0x80, 0x0, 0x7f,
0xf2, 0xa, 0xff, 0xff, 0xff, 0xff, 0x20, 0x19,
0xde, 0xeb, 0x4f, 0xf2, 0x0, 0x0, 0x0, 0x1,
0xff, 0x11, 0xbb, 0x10, 0x0, 0x2f, 0xf0, 0x1f,
0xf5, 0x0, 0x7, 0xfe, 0x0, 0xcf, 0xff, 0xff,
0xff, 0x90, 0x1, 0xad, 0xff, 0xfd, 0x80, 0x0,
/* U+3A ":" */
0x1f, 0xe1, 0xfe, 0x4, 0x40, 0x0, 0x0, 0x0,
0x0, 0x4, 0x41, 0xfe, 0x1f, 0xe0,
/* U+3B ";" */
0x4f, 0xc4, 0xfc, 0x14, 0x30, 0x0, 0x0, 0x0,
0x0, 0x4, 0x33, 0xfc, 0x3f, 0xc0, 0x9b, 0x6e,
0x30,
/* U+3C "<" */
0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x3, 0xcc,
0x0, 0x2, 0xbf, 0xfb, 0x2, 0xaf, 0xfd, 0x50,
0x9f, 0xfd, 0x50, 0x0, 0xff, 0x90, 0x0, 0x0,
0xbf, 0xfb, 0x30, 0x0, 0x3, 0xcf, 0xfb, 0x30,
0x0, 0x4, 0xcf, 0xf9, 0x0, 0x0, 0x5, 0xdc,
0x0, 0x0, 0x0, 0x4,
/* U+3D "=" */
0xdf, 0xff, 0xff, 0xff, 0xf1, 0xcf, 0xff, 0xff,
0xff, 0xf1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0xdf, 0xff, 0xff, 0xff,
0xf1, 0xbe, 0xee, 0xee, 0xee, 0xe1,
/* U+3E ">" */
0x20, 0x0, 0x0, 0x0, 0xfa, 0x20, 0x0, 0x0,
0xef, 0xf9, 0x10, 0x0, 0x6, 0xef, 0xf8, 0x10,
0x0, 0x7, 0xef, 0xf7, 0x0, 0x0, 0xc, 0xfc,
0x0, 0x5, 0xdf, 0xf8, 0x5, 0xdf, 0xfa, 0x20,
0xdf, 0xfb, 0x30, 0x0, 0xfc, 0x30, 0x0, 0x0,
0x40, 0x0, 0x0, 0x0,
/* U+3F "?" */
0x2, 0xae, 0xff, 0xd7, 0x0, 0xcf, 0xfd, 0xdf,
0xf5, 0xf, 0xf1, 0x0, 0x6f, 0x91, 0xfd, 0x0,
0x3, 0xfa, 0x0, 0x0, 0x0, 0x6f, 0xa0, 0x0,
0x1, 0x8f, 0xf6, 0x0, 0x3, 0xef, 0xf7, 0x0,
0x0, 0xaf, 0xc1, 0x0, 0x0, 0xa, 0xe4, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3, 0x41,
0x0, 0x0, 0x0, 0xbf, 0x40, 0x0, 0x0, 0xb,
0xf4, 0x0, 0x0,
/* U+40 "@" */
0x0, 0x5a, 0xdf, 0xff, 0xeb, 0x50, 0x6, 0xe7,
0x43, 0x23, 0x47, 0xf3, 0xd, 0x40, 0x0, 0x0,
0x0, 0x98, 0xf, 0x0, 0xbf, 0xea, 0xf0, 0x6a,
0x1f, 0x5, 0xf5, 0x3c, 0xf0, 0x5b, 0x2e, 0x7,
0xe0, 0x6, 0xf0, 0x6b, 0x2f, 0x7, 0xe0, 0x6,
0xf0, 0x7a, 0x1f, 0x6, 0xf2, 0xa, 0xf3, 0xb7,
0xf, 0x11, 0xdf, 0xf8, 0xef, 0xe1, 0xd, 0x50,
0x2, 0x10, 0x2, 0x0, 0x7, 0xe7, 0x43, 0x23,
0x5b, 0x30, 0x0, 0x6b, 0xef, 0xfe, 0xc7, 0x0,
/* U+41 "A" */
0x0, 0x0, 0x2f, 0xff, 0x80, 0x0, 0x0, 0x0,
0x7, 0xff, 0xfd, 0x0, 0x0, 0x0, 0x0, 0xcf,
0xbf, 0xf2, 0x0, 0x0, 0x0, 0x1f, 0xf4, 0xdf,
0x70, 0x0, 0x0, 0x6, 0xff, 0x8, 0xfc, 0x0,
0x0, 0x0, 0xbf, 0xb0, 0x4f, 0xf1, 0x0, 0x0,
0xf, 0xf6, 0x0, 0xff, 0x60, 0x0, 0x5, 0xff,
0x10, 0xa, 0xfb, 0x0, 0x0, 0xaf, 0xd0, 0x0,
0x5f, 0xf0, 0x0, 0xe, 0xff, 0xff, 0xff, 0xff,
0x50, 0x4, 0xff, 0xcc, 0xcc, 0xce, 0xfa, 0x0,
0x8f, 0xe0, 0x0, 0x0, 0x7f, 0xf0, 0xd, 0xf8,
0x0, 0x0, 0x1, 0xff, 0x40,
/* U+42 "B" */
0xff, 0xff, 0xff, 0xfd, 0x60, 0xff, 0xff, 0xff,
0xff, 0xf3, 0xff, 0x50, 0x0, 0x5f, 0xf7, 0xff,
0x50, 0x0, 0xd, 0xf8, 0xff, 0x50, 0x0, 0xd,
0xf7, 0xff, 0x50, 0x0, 0x3f, 0xf3, 0xff, 0xff,
0xff, 0xff, 0x60, 0xff, 0xdc, 0xcc, 0xdf, 0xd2,
0xff, 0x50, 0x0, 0xa, 0xf9, 0xff, 0x50, 0x0,
0x8, 0xfc, 0xff, 0x50, 0x0, 0x2c, 0xfb, 0xff,
0xff, 0xff, 0xff, 0xf7, 0xff, 0xff, 0xff, 0xfe,
0x90,
/* U+43 "C" */
0x0, 0x6b, 0xef, 0xfe, 0xc5, 0x0, 0xaf, 0xff,
0xff, 0xff, 0xf3, 0x1f, 0xf9, 0x21, 0x14, 0xff,
0x84, 0xff, 0x10, 0x0, 0xb, 0xf9, 0x5f, 0xf0,
0x0, 0x0, 0x35, 0x36, 0xfe, 0x0, 0x0, 0x0,
0x0, 0x6f, 0xe0, 0x0, 0x0, 0x0, 0x5, 0xff,
0x0, 0x0, 0x0, 0x0, 0x4f, 0xf0, 0x0, 0x0,
0x5a, 0x82, 0xff, 0x10, 0x0, 0x9, 0xfb, 0xf,
0xf9, 0x21, 0x14, 0xef, 0x90, 0xaf, 0xff, 0xff,
0xff, 0xf4, 0x0, 0x8c, 0xff, 0xfe, 0xc6, 0x0,
/* U+44 "D" */
0xff, 0xff, 0xff, 0xfd, 0x80, 0xf, 0xff, 0xff,
0xff, 0xff, 0xa0, 0xff, 0x50, 0x0, 0x19, 0xff,
0x1f, 0xf5, 0x0, 0x0, 0x1f, 0xf5, 0xff, 0x50,
0x0, 0x0, 0xef, 0x7f, 0xf5, 0x0, 0x0, 0xd,
0xf7, 0xff, 0x50, 0x0, 0x0, 0xdf, 0x7f, 0xf5,
0x0, 0x0, 0xd, 0xf6, 0xff, 0x50, 0x0, 0x0,
0xef, 0x5f, 0xf5, 0x0, 0x0, 0x1f, 0xf3, 0xff,
0x50, 0x0, 0x2a, 0xff, 0x1f, 0xff, 0xff, 0xff,
0xff, 0xa0, 0xff, 0xff, 0xff, 0xfd, 0x80, 0x0,
/* U+45 "E" */
0x3f, 0xff, 0xff, 0xff, 0xf0, 0x3f, 0xff, 0xff,
0xff, 0xf0, 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x3f,
0xf1, 0x0, 0x0, 0x0, 0x3f, 0xf1, 0x0, 0x0,
0x0, 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x3f, 0xff,
0xff, 0xff, 0xb0, 0x3f, 0xfc, 0xcc, 0xcc, 0x80,
0x3f, 0xf1, 0x0, 0x0, 0x0, 0x3f, 0xf1, 0x0,
0x0, 0x0, 0x3f, 0xf1, 0x0, 0x0, 0x0, 0x3f,
0xff, 0xff, 0xff, 0xf1, 0x3f, 0xff, 0xff, 0xff,
0xf1,
/* U+46 "F" */
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0x50, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0xff, 0x50, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0xff, 0xff, 0xff, 0xfb, 0xff, 0xff, 0xff, 0xfb,
0xff, 0x50, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0xff, 0x50, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0xff, 0x50, 0x0, 0x0,
/* U+47 "G" */
0x0, 0x7c, 0xef, 0xff, 0xd8, 0x0, 0x8, 0xff,
0xff, 0xff, 0xff, 0xa0, 0xf, 0xfa, 0x21, 0x12,
0xbf, 0xe0, 0x3f, 0xf1, 0x0, 0x0, 0x5f, 0xf0,
0x4f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0xe0,
0x0, 0x0, 0x0, 0x0, 0x6f, 0xe0, 0x2, 0xcc,
0xcc, 0xc0, 0x6f, 0xe0, 0x3, 0xff, 0xff, 0xf1,
0x5f, 0xf0, 0x0, 0x0, 0x3f, 0xf1, 0x4f, 0xf1,
0x0, 0x0, 0x4f, 0xf0, 0x1f, 0xf9, 0x21, 0x13,
0xcf, 0xe0, 0xa, 0xff, 0xff, 0xff, 0xff, 0x90,
0x0, 0x7c, 0xff, 0xfe, 0xc8, 0x0,
/* U+48 "H" */
0xff, 0x50, 0x0, 0x0, 0xff, 0x3f, 0xf5, 0x0,
0x0, 0xf, 0xf3, 0xff, 0x50, 0x0, 0x0, 0xff,
0x3f, 0xf5, 0x0, 0x0, 0xf, 0xf3, 0xff, 0x50,
0x0, 0x0, 0xff, 0x3f, 0xf5, 0x0, 0x0, 0xf,
0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff,
0xff, 0xff, 0xff, 0xf3, 0xff, 0x50, 0x0, 0x0,
0xff, 0x3f, 0xf5, 0x0, 0x0, 0xf, 0xf3, 0xff,
0x50, 0x0, 0x0, 0xff, 0x3f, 0xf5, 0x0, 0x0,
0xf, 0xf3, 0xff, 0x50, 0x0, 0x0, 0xff, 0x30,
/* U+49 "I" */
0xff, 0x5f, 0xf5, 0xff, 0x5f, 0xf5, 0xff, 0x5f,
0xf5, 0xff, 0x5f, 0xf5, 0xff, 0x5f, 0xf5, 0xff,
0x5f, 0xf5, 0xff, 0x50,
/* U+4A "J" */
0x0, 0x0, 0x0, 0xff, 0x40, 0x0, 0x0, 0xf,
0xf4, 0x0, 0x0, 0x0, 0xff, 0x40, 0x0, 0x0,
0xf, 0xf4, 0x0, 0x0, 0x0, 0xff, 0x40, 0x0,
0x0, 0xf, 0xf4, 0x0, 0x0, 0x0, 0xff, 0x41,
0x21, 0x0, 0xf, 0xf4, 0x9f, 0x90, 0x0, 0xff,
0x39, 0xfa, 0x0, 0x1f, 0xf3, 0x7f, 0xe3, 0x17,
0xff, 0x24, 0xff, 0xff, 0xff, 0xd0, 0x7, 0xdf,
0xfe, 0xb3, 0x0,
/* U+4B "K" */
0xff, 0x50, 0x0, 0x1e, 0xfc, 0xf, 0xf5, 0x0,
0xc, 0xfe, 0x10, 0xff, 0x50, 0x9, 0xff, 0x30,
0xf, 0xf5, 0x6, 0xff, 0x60, 0x0, 0xff, 0x53,
0xff, 0x90, 0x0, 0xf, 0xff, 0xff, 0xc0, 0x0,
0x0, 0xff, 0xff, 0xfb, 0x0, 0x0, 0xf, 0xf5,
0x4f, 0xf8, 0x0, 0x0, 0xff, 0x50, 0x8f, 0xf4,
0x0, 0xf, 0xf5, 0x0, 0xcf, 0xe1, 0x0, 0xff,
0x50, 0x1, 0xef, 0xc0, 0xf, 0xf5, 0x0, 0x4,
0xff, 0x90, 0xff, 0x50, 0x0, 0x8, 0xff, 0x50,
/* U+4C "L" */
0xff, 0x50, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0xff, 0x50, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0xff, 0x50, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0xff, 0x50, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0xff, 0x50, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0xff, 0x62, 0x22, 0x22, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff,
/* U+4D "M" */
0xff, 0xfe, 0x0, 0x0, 0x0, 0xdf, 0xff, 0x1f,
0xff, 0xf4, 0x0, 0x0, 0x3f, 0xff, 0xf1, 0xff,
0xdf, 0xa0, 0x0, 0x9, 0xfd, 0xff, 0x1f, 0xf9,
0xff, 0x0, 0x0, 0xef, 0x9f, 0xf1, 0xff, 0x5f,
0xf5, 0x0, 0x4f, 0xf4, 0xff, 0x1f, 0xf5, 0xaf,
0xb0, 0xa, 0xfd, 0x2f, 0xf1, 0xff, 0x55, 0xff,
0x10, 0xff, 0x73, 0xff, 0x1f, 0xf5, 0xe, 0xf6,
0x4f, 0xf1, 0x3f, 0xf1, 0xff, 0x50, 0x9f, 0xa9,
0xfb, 0x3, 0xff, 0x1f, 0xf5, 0x3, 0xff, 0xef,
0x60, 0x3f, 0xf1, 0xff, 0x50, 0xd, 0xff, 0xf0,
0x3, 0xff, 0x1f, 0xf5, 0x0, 0x8f, 0xfa, 0x0,
0x3f, 0xf1, 0xff, 0x50, 0x2, 0xff, 0x40, 0x3,
0xff, 0x10,
/* U+4E "N" */
0xff, 0xff, 0x20, 0x0, 0x1f, 0xf3, 0xff, 0xff,
0x90, 0x0, 0x1f, 0xf3, 0xff, 0xcf, 0xf1, 0x0,
0x1f, 0xf3, 0xff, 0x6f, 0xf9, 0x0, 0x1f, 0xf3,
0xff, 0x5a, 0xff, 0x10, 0x1f, 0xf3, 0xff, 0x54,
0xff, 0x80, 0x1f, 0xf3, 0xff, 0x50, 0xcf, 0xe0,
0x1f, 0xf3, 0xff, 0x50, 0x5f, 0xf7, 0x1f, 0xf3,
0xff, 0x50, 0xd, 0xfe, 0x1f, 0xf3, 0xff, 0x50,
0x5, 0xff, 0x6f, 0xf3, 0xff, 0x50, 0x0, 0xdf,
0xcf, 0xf3, 0xff, 0x50, 0x0, 0x6f, 0xff, 0xf3,
0xff, 0x50, 0x0, 0xe, 0xff, 0xf3,
/* U+4F "O" */
0x0, 0x8c, 0xef, 0xfe, 0xb5, 0x0, 0xb, 0xff,
0xff, 0xff, 0xff, 0x60, 0x1f, 0xf8, 0x21, 0x13,
0xbf, 0xd0, 0x5f, 0xf0, 0x0, 0x0, 0x4f, 0xf0,
0x6f, 0xd0, 0x0, 0x0, 0x3f, 0xf1, 0x7f, 0xd0,
0x0, 0x0, 0x2f, 0xf2, 0x8f, 0xc0, 0x0, 0x0,
0x2f, 0xf2, 0x7f, 0xc0, 0x0, 0x0, 0x2f, 0xf2,
0x7f, 0xd0, 0x0, 0x0, 0x3f, 0xf1, 0x5f, 0xf0,
0x0, 0x0, 0x4f, 0xf0, 0x2f, 0xf8, 0x21, 0x13,
0xcf, 0xc0, 0xc, 0xff, 0xff, 0xff, 0xff, 0x60,
0x1, 0x8c, 0xff, 0xfe, 0xb5, 0x0,
/* U+50 "P" */
0xff, 0xff, 0xff, 0xeb, 0x40, 0xff, 0xff, 0xff,
0xff, 0xf1, 0xff, 0x50, 0x0, 0x3f, 0xf6, 0xff,
0x50, 0x0, 0xb, 0xf9, 0xff, 0x50, 0x0, 0xb,
0xf9, 0xff, 0x50, 0x0, 0xb, 0xf9, 0xff, 0x50,
0x0, 0x4f, 0xf7, 0xff, 0xff, 0xff, 0xff, 0xf2,
0xff, 0xff, 0xff, 0xfc, 0x50, 0xff, 0x50, 0x0,
0x0, 0x0, 0xff, 0x50, 0x0, 0x0, 0x0, 0xff,
0x50, 0x0, 0x0, 0x0, 0xff, 0x50, 0x0, 0x0,
0x0,
/* U+51 "Q" */
0x0, 0x8c, 0xef, 0xfe, 0xb5, 0x0, 0x0, 0xbf,
0xff, 0xff, 0xff, 0xf6, 0x0, 0x1f, 0xf8, 0x21,
0x13, 0xcf, 0xd0, 0x4, 0xff, 0x0, 0x0, 0x4,
0xff, 0x0, 0x6f, 0xd0, 0x0, 0x0, 0x2f, 0xf1,
0x7, 0xfd, 0x0, 0x0, 0x2, 0xff, 0x20, 0x8f,
0xc0, 0x0, 0x0, 0x2f, 0xf2, 0x7, 0xfc, 0x0,
0x1d, 0x42, 0xff, 0x20, 0x7f, 0xd0, 0x5, 0xff,
0xaf, 0xf2, 0x5, 0xff, 0x0, 0x2, 0xdf, 0xff,
0x0, 0x2f, 0xf8, 0x21, 0x15, 0xff, 0xf5, 0x0,
0xcf, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x1, 0x8c,
0xef, 0xfe, 0xa4, 0x24, 0x0,
/* U+52 "R" */
0xff, 0xff, 0xff, 0xfd, 0x70, 0xff, 0xff, 0xff,
0xff, 0xf6, 0xff, 0x50, 0x0, 0x2d, 0xfb, 0xff,
0x50, 0x0, 0x8, 0xfd, 0xff, 0x50, 0x0, 0x7,
0xfd, 0xff, 0x50, 0x0, 0x9, 0xfc, 0xff, 0x50,
0x0, 0x3e, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x90,
0xff, 0xff, 0xff, 0xff, 0xc1, 0xff, 0x50, 0x0,
0x3e, 0xf9, 0xff, 0x50, 0x0, 0x9, 0xfb, 0xff,
0x50, 0x0, 0x9, 0xfb, 0xff, 0x50, 0x0, 0x9,
0xfb,
/* U+53 "S" */
0x3, 0xae, 0xff, 0xfd, 0x91, 0x0, 0xff, 0xff,
0xff, 0xff, 0xa0, 0x4f, 0xf4, 0x0, 0x9, 0xfe,
0x6, 0xff, 0x0, 0x0, 0x3a, 0x90, 0x5f, 0xf3,
0x0, 0x0, 0x0, 0x2, 0xff, 0xff, 0xfe, 0xda,
0x30, 0x5, 0xce, 0xff, 0xff, 0xfe, 0x0, 0x0,
0x0, 0x0, 0x5f, 0xf2, 0x26, 0x50, 0x0, 0x0,
0xff, 0x36, 0xfd, 0x0, 0x0, 0xf, 0xf3, 0x4f,
0xf2, 0x0, 0x6, 0xff, 0x10, 0xff, 0xff, 0xff,
0xff, 0xc0, 0x3, 0xbe, 0xff, 0xfd, 0x91, 0x0,
/* U+54 "T" */
0xef, 0xff, 0xff, 0xff, 0xf6, 0xef, 0xff, 0xff,
0xff, 0xf6, 0x22, 0x28, 0xfd, 0x22, 0x20, 0x0,
0x7, 0xfd, 0x0, 0x0, 0x0, 0x7, 0xfd, 0x0,
0x0, 0x0, 0x7, 0xfd, 0x0, 0x0, 0x0, 0x7,
0xfd, 0x0, 0x0, 0x0, 0x7, 0xfd, 0x0, 0x0,
0x0, 0x7, 0xfd, 0x0, 0x0, 0x0, 0x7, 0xfd,
0x0, 0x0, 0x0, 0x7, 0xfd, 0x0, 0x0, 0x0,
0x7, 0xfd, 0x0, 0x0, 0x0, 0x7, 0xfd, 0x0,
0x0,
/* U+55 "U" */
0xff, 0x50, 0x0, 0x3, 0xff, 0xf, 0xf5, 0x0,
0x0, 0x3f, 0xf0, 0xff, 0x50, 0x0, 0x3, 0xff,
0xf, 0xf5, 0x0, 0x0, 0x3f, 0xf0, 0xff, 0x50,
0x0, 0x3, 0xff, 0xf, 0xf5, 0x0, 0x0, 0x3f,
0xf0, 0xff, 0x50, 0x0, 0x3, 0xff, 0xf, 0xf5,
0x0, 0x0, 0x3f, 0xf0, 0xef, 0x50, 0x0, 0x3,
0xff, 0xe, 0xf6, 0x0, 0x0, 0x4f, 0xf0, 0xcf,
0xc3, 0x11, 0x2b, 0xfd, 0x6, 0xff, 0xff, 0xff,
0xff, 0x80, 0x6, 0xce, 0xff, 0xec, 0x70, 0x0,
/* U+56 "V" */
0xe, 0xf7, 0x0, 0x0, 0x6, 0xff, 0x0, 0x9f,
0xc0, 0x0, 0x0, 0xbf, 0xb0, 0x5, 0xff, 0x10,
0x0, 0xf, 0xf6, 0x0, 0xf, 0xf6, 0x0, 0x5,
0xff, 0x10, 0x0, 0xbf, 0xb0, 0x0, 0x9f, 0xc0,
0x0, 0x6, 0xff, 0x0, 0xe, 0xf8, 0x0, 0x0,
0x2f, 0xf4, 0x3, 0xff, 0x30, 0x0, 0x0, 0xdf,
0x90, 0x8f, 0xe0, 0x0, 0x0, 0x8, 0xfe, 0xc,
0xf9, 0x0, 0x0, 0x0, 0x4f, 0xf3, 0xff, 0x50,
0x0, 0x0, 0x0, 0xff, 0xbf, 0xf0, 0x0, 0x0,
0x0, 0xa, 0xff, 0xfb, 0x0, 0x0, 0x0, 0x0,
0x5f, 0xff, 0x60, 0x0, 0x0,
/* U+57 "W" */
0xef, 0x70, 0x0, 0x8, 0xff, 0x60, 0x0, 0x8,
0xfc, 0xaf, 0xb0, 0x0, 0xc, 0xff, 0xa0, 0x0,
0xc, 0xf8, 0x6f, 0xe0, 0x0, 0xf, 0xff, 0xe0,
0x0, 0xf, 0xf4, 0x2f, 0xf2, 0x0, 0x4f, 0xdf,
0xf2, 0x0, 0x4f, 0xf1, 0xe, 0xf6, 0x0, 0x8f,
0x9b, 0xf6, 0x0, 0x8f, 0xc0, 0xa, 0xfa, 0x0,
0xcf, 0x58, 0xfa, 0x0, 0xcf, 0x90, 0x7, 0xfe,
0x1, 0xff, 0x14, 0xfe, 0x0, 0xff, 0x50, 0x3,
0xff, 0x25, 0xfd, 0x0, 0xff, 0x24, 0xff, 0x10,
0x0, 0xff, 0x59, 0xf9, 0x0, 0xcf, 0x67, 0xfd,
0x0, 0x0, 0xbf, 0x8c, 0xf5, 0x0, 0x8f, 0xaa,
0xf9, 0x0, 0x0, 0x7f, 0xcf, 0xf1, 0x0, 0x4f,
0xde, 0xf5, 0x0, 0x0, 0x4f, 0xff, 0xd0, 0x0,
0xf, 0xff, 0xf1, 0x0, 0x0, 0xf, 0xff, 0x90,
0x0, 0xc, 0xff, 0xd0, 0x0,
/* U+58 "X" */
0x7, 0xff, 0x30, 0x0, 0xc, 0xfd, 0x0, 0xd,
0xfc, 0x0, 0x5, 0xff, 0x40, 0x0, 0x5f, 0xf5,
0x0, 0xef, 0xb0, 0x0, 0x0, 0xbf, 0xd0, 0x7f,
0xf2, 0x0, 0x0, 0x2, 0xff, 0x6e, 0xf9, 0x0,
0x0, 0x0, 0x9, 0xff, 0xfe, 0x10, 0x0, 0x0,
0x0, 0x4f, 0xff, 0xb0, 0x0, 0x0, 0x0, 0xc,
0xfc, 0xff, 0x40, 0x0, 0x0, 0x6, 0xff, 0x2b,
0xfd, 0x0, 0x0, 0x1, 0xef, 0x90, 0x3f, 0xf6,
0x0, 0x0, 0x9f, 0xf1, 0x0, 0xaf, 0xe0, 0x0,
0x2f, 0xf8, 0x0, 0x2, 0xff, 0x80, 0xc, 0xfe,
0x0, 0x0, 0x8, 0xff, 0x20,
/* U+59 "Y" */
0xc, 0xfd, 0x0, 0x0, 0xe, 0xfb, 0x3, 0xff,
0x50, 0x0, 0x7f, 0xf2, 0x0, 0xbf, 0xd0, 0x1,
0xef, 0x90, 0x0, 0x2f, 0xf6, 0x8, 0xff, 0x10,
0x0, 0xa, 0xfe, 0x1f, 0xf8, 0x0, 0x0, 0x1,
0xff, 0xdf, 0xe0, 0x0, 0x0, 0x0, 0x8f, 0xff,
0x60, 0x0, 0x0, 0x0, 0x1f, 0xfd, 0x0, 0x0,
0x0, 0x0, 0xb, 0xf8, 0x0, 0x0, 0x0, 0x0,
0xb, 0xf8, 0x0, 0x0, 0x0, 0x0, 0xb, 0xf8,
0x0, 0x0, 0x0, 0x0, 0xb, 0xf8, 0x0, 0x0,
0x0, 0x0, 0xb, 0xf8, 0x0, 0x0,
/* U+5A "Z" */
0x5f, 0xff, 0xff, 0xff, 0xfe, 0x5f, 0xff, 0xff,
0xff, 0xfe, 0x0, 0x0, 0x0, 0x6f, 0xf8, 0x0,
0x0, 0x2, 0xff, 0xc0, 0x0, 0x0, 0xd, 0xfe,
0x10, 0x0, 0x0, 0x9f, 0xf4, 0x0, 0x0, 0x5,
0xff, 0x90, 0x0, 0x0, 0x1e, 0xfc, 0x0, 0x0,
0x0, 0xcf, 0xf2, 0x0, 0x0, 0x8, 0xff, 0x50,
0x0, 0x0, 0x4f, 0xfa, 0x11, 0x11, 0x10, 0x9f,
0xff, 0xff, 0xff, 0xff, 0x9f, 0xff, 0xff, 0xff,
0xff,
/* U+5B "[" */
0xf, 0xff, 0xa0, 0xff, 0xc8, 0xf, 0xf1, 0x0,
0xff, 0x10, 0xf, 0xf1, 0x0, 0xff, 0x10, 0xf,
0xf1, 0x0, 0xff, 0x10, 0xf, 0xf1, 0x0, 0xff,
0x10, 0xf, 0xf1, 0x0, 0xff, 0x10, 0xf, 0xf1,
0x0, 0xff, 0x10, 0xf, 0xf1, 0x0, 0xff, 0xc8,
0xf, 0xff, 0xa0,
/* U+5C "\\" */
0xad, 0x0, 0x0, 0x0, 0x0, 0x2, 0xf6, 0x0,
0x0, 0x0, 0x0, 0x9, 0xe0, 0x0, 0x0, 0x0,
0x0, 0x1f, 0x70, 0x0, 0x0, 0x0, 0x0, 0x8e,
0x10, 0x0, 0x0, 0x0, 0x0, 0xe8, 0x0, 0x0,
0x0, 0x0, 0x6, 0xf2, 0x0, 0x0, 0x0, 0x0,
0xd, 0xa0, 0x0, 0x0, 0x0, 0x0, 0x5f, 0x30,
0x0, 0x0, 0x0, 0x0, 0xcb, 0x0, 0x0, 0x0,
0x0, 0x3, 0xf4, 0x0, 0x0, 0x0, 0x0, 0xb,
0xc0, 0x0, 0x0, 0x0, 0x0, 0x2f, 0x50, 0x0,
0x0, 0x0, 0x0, 0x9e, 0x0, 0x0, 0x0, 0x0,
0x1, 0xf7, 0x0, 0x0, 0x0, 0x0, 0x8, 0xe1,
0x0, 0x0, 0x0, 0x0, 0xe, 0x80,
/* U+5D "]" */
0x1f, 0xff, 0x81, 0xce, 0xf8, 0x0, 0x9f, 0x80,
0x9, 0xf8, 0x0, 0x9f, 0x80, 0x9, 0xf8, 0x0,
0x9f, 0x80, 0x9, 0xf8, 0x0, 0x9f, 0x80, 0x9,
0xf8, 0x0, 0x9f, 0x80, 0x9, 0xf8, 0x0, 0x9f,
0x80, 0x9, 0xf8, 0x0, 0x9f, 0x81, 0xce, 0xf8,
0x1f, 0xff, 0x80,
/* U+5E "^" */
0x0, 0x4f, 0xfd, 0x0, 0x0, 0xc, 0xfe, 0xf5,
0x0, 0x4, 0xfd, 0x4f, 0xd0, 0x0, 0xcf, 0x50,
0xcf, 0x50, 0x4f, 0xd0, 0x4, 0xfd, 0xc, 0xf5,
0x0, 0xc, 0xf5,
/* U+5F "_" */
0xee, 0xee, 0xee, 0xee, 0xef, 0xff, 0xff, 0xff,
0xff,
/* U+60 "`" */
0x33, 0x0, 0xaf, 0x80, 0x5, 0xd8, 0x0, 0x0,
/* U+61 "a" */
0x3, 0xcf, 0xff, 0xc5, 0x0, 0xdf, 0xc7, 0x9f,
0xf1, 0xa, 0xa1, 0x0, 0xbf, 0x50, 0x0, 0x11,
0xa, 0xf6, 0x6, 0xef, 0xfd, 0xbf, 0x62, 0xff,
0x75, 0x7f, 0xf6, 0x4f, 0xc0, 0x0, 0xaf, 0x61,
0xff, 0x75, 0x7e, 0xf6, 0x5, 0xdf, 0xea, 0xaf,
0x60,
/* U+62 "b" */
0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0,
0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0,
0xff, 0x4d, 0xfe, 0x90, 0xff, 0xec, 0xbf, 0xf6,
0xff, 0x70, 0x7, 0xfb, 0xff, 0x10, 0x3, 0xfc,
0xff, 0x0, 0x3, 0xfd, 0xff, 0x10, 0x4, 0xfc,
0xff, 0x40, 0x7, 0xfa, 0xff, 0xeb, 0xcf, 0xf6,
0xff, 0x4d, 0xfe, 0x80,
/* U+63 "c" */
0x2, 0xbe, 0xff, 0xc4, 0x0, 0xdf, 0xeb, 0xef,
0xe0, 0x2f, 0xe0, 0x0, 0xef, 0x24, 0xfc, 0x0,
0x2, 0x30, 0x4f, 0xb0, 0x0, 0x0, 0x4, 0xfc,
0x0, 0x5, 0x72, 0x2f, 0xe0, 0x0, 0xcf, 0x40,
0xdf, 0xeb, 0xcf, 0xf1, 0x2, 0xbe, 0xfe, 0xb4,
0x0,
/* U+64 "d" */
0x0, 0x0, 0x0, 0x8f, 0x70, 0x0, 0x0, 0x8,
0xf7, 0x0, 0x0, 0x0, 0x8f, 0x70, 0x0, 0x0,
0x8, 0xf7, 0x3, 0xcf, 0xe9, 0x9f, 0x70, 0xef,
0xeb, 0xdf, 0xf7, 0x2f, 0xe0, 0x0, 0xcf, 0x74,
0xfc, 0x0, 0x9, 0xf7, 0x4f, 0xb0, 0x0, 0x8f,
0x74, 0xfc, 0x0, 0x9, 0xf7, 0x2f, 0xe0, 0x0,
0xcf, 0x70, 0xef, 0xd9, 0xbe, 0xf7, 0x3, 0xcf,
0xfa, 0x8f, 0x70,
/* U+65 "e" */
0x2, 0xbe, 0xff, 0xb3, 0x0, 0xdf, 0xc9, 0xbf,
0xe0, 0x2f, 0xe0, 0x0, 0xbf, 0x44, 0xfc, 0x0,
0x9, 0xf5, 0x4f, 0xff, 0xff, 0xff, 0x64, 0xfc,
0x33, 0x33, 0x31, 0x2f, 0xd0, 0x0, 0x7b, 0x40,
0xdf, 0xc9, 0xaf, 0xf2, 0x2, 0xbe, 0xfe, 0xc5,
0x0,
/* U+66 "f" */
0x0, 0x9e, 0xf7, 0x5, 0xff, 0xa4, 0x8, 0xf8,
0x0, 0x9, 0xf6, 0x0, 0xcf, 0xff, 0xf8, 0x7d,
0xfc, 0x95, 0x9, 0xf6, 0x0, 0x9, 0xf6, 0x0,
0x9, 0xf6, 0x0, 0x9, 0xf6, 0x0, 0x9, 0xf6,
0x0, 0x9, 0xf6, 0x0, 0x9, 0xf6, 0x0,
/* U+67 "g" */
0x3, 0xcf, 0xe9, 0x7f, 0x80, 0xef, 0xeb, 0xde,
0xf8, 0x2f, 0xe0, 0x0, 0xcf, 0x84, 0xfc, 0x0,
0x9, 0xf8, 0x4f, 0xb0, 0x0, 0x8f, 0x84, 0xfc,
0x0, 0x9, 0xf8, 0x2f, 0xe0, 0x0, 0xcf, 0x80,
0xdf, 0xeb, 0xde, 0xf8, 0x3, 0xcf, 0xfa, 0x8f,
0x80, 0x11, 0x0, 0x8, 0xf7, 0xf, 0xf0, 0x0,
0xbf, 0x60, 0xcf, 0xdb, 0xdf, 0xf1, 0x3, 0xbe,
0xff, 0xc4, 0x0,
/* U+68 "h" */
0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0,
0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0,
0xff, 0x3c, 0xfd, 0x70, 0xff, 0xec, 0xcf, 0xf4,
0xff, 0x60, 0x9, 0xf8, 0xff, 0x0, 0x7, 0xf9,
0xff, 0x0, 0x7, 0xf9, 0xff, 0x0, 0x7, 0xf9,
0xff, 0x0, 0x7, 0xf9, 0xff, 0x0, 0x7, 0xf9,
0xff, 0x0, 0x7, 0xf9,
/* U+69 "i" */
0xff, 0xcc, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff,
/* U+6A "j" */
0xf, 0xf0, 0xcc, 0x0, 0x0, 0x0, 0xf, 0xf0,
0xff, 0xf, 0xf0, 0xff, 0xf, 0xf0, 0xff, 0xf,
0xf0, 0xff, 0xf, 0xf1, 0xff, 0xbf, 0xce, 0xd3,
/* U+6B "k" */
0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0,
0xff, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0,
0xff, 0x0, 0x7f, 0xc0, 0xff, 0x1, 0xff, 0x20,
0xff, 0xa, 0xf8, 0x0, 0xff, 0x5f, 0xd0, 0x0,
0xff, 0xff, 0x60, 0x0, 0xff, 0x7f, 0xd1, 0x0,
0xff, 0xa, 0xfb, 0x0, 0xff, 0x0, 0xdf, 0x80,
0xff, 0x0, 0x2f, 0xf5,
/* U+6C "l" */
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff,
/* U+6D "m" */
0xff, 0x4d, 0xfe, 0x62, 0xcf, 0xe7, 0xf, 0xfe,
0xab, 0xff, 0xdb, 0xaf, 0xf4, 0xff, 0x40, 0xc,
0xf9, 0x0, 0x8f, 0x8f, 0xf0, 0x0, 0xbf, 0x50,
0x6, 0xfa, 0xff, 0x0, 0xb, 0xf5, 0x0, 0x6f,
0xaf, 0xf0, 0x0, 0xbf, 0x50, 0x6, 0xfa, 0xff,
0x0, 0xb, 0xf5, 0x0, 0x6f, 0xaf, 0xf0, 0x0,
0xbf, 0x50, 0x6, 0xfa, 0xff, 0x0, 0xb, 0xf5,
0x0, 0x6f, 0xa0,
/* U+6E "n" */
0xff, 0x4d, 0xfd, 0x70, 0xff, 0xea, 0xaf, 0xf4,
0xff, 0x40, 0x8, 0xf7, 0xff, 0x0, 0x7, 0xf9,
0xff, 0x0, 0x7, 0xf9, 0xff, 0x0, 0x7, 0xf9,
0xff, 0x0, 0x7, 0xf9, 0xff, 0x0, 0x7, 0xf9,
0xff, 0x0, 0x7, 0xf9,
/* U+6F "o" */
0x3, 0xbe, 0xff, 0xd6, 0x0, 0xef, 0xeb, 0xcf,
0xf3, 0x2f, 0xe0, 0x0, 0xaf, 0x74, 0xfc, 0x0,
0x7, 0xf9, 0x4f, 0xb0, 0x0, 0x6f, 0x94, 0xfc,
0x0, 0x7, 0xf9, 0x2f, 0xe0, 0x0, 0xaf, 0x70,
0xef, 0xeb, 0xdf, 0xf2, 0x3, 0xbe, 0xff, 0xd6,
0x0,
/* U+70 "p" */
0xff, 0x4c, 0xfe, 0x90, 0xff, 0xea, 0xaf, 0xf8,
0xff, 0x50, 0x4, 0xfc, 0xff, 0x20, 0x2, 0xfe,
0xff, 0x10, 0x1, 0xfe, 0xff, 0x20, 0x2, 0xfe,
0xff, 0x60, 0x5, 0xfc, 0xff, 0xec, 0xcf, 0xf7,
0xff, 0x4c, 0xfe, 0x90, 0xff, 0x10, 0x0, 0x0,
0xff, 0x10, 0x0, 0x0, 0xff, 0x10, 0x0, 0x0,
0xff, 0x10, 0x0, 0x0,
/* U+71 "q" */
0x3, 0xcf, 0xe9, 0x8f, 0x80, 0xef, 0xeb, 0xde,
0xf8, 0x2f, 0xe0, 0x0, 0xcf, 0x84, 0xfc, 0x0,
0x9, 0xf8, 0x4f, 0xb0, 0x0, 0x8f, 0x84, 0xfc,
0x0, 0x8, 0xf8, 0x2f, 0xe0, 0x0, 0xcf, 0x80,
0xef, 0xeb, 0xde, 0xf8, 0x3, 0xcf, 0xf9, 0x8f,
0x80, 0x0, 0x0, 0x8, 0xf8, 0x0, 0x0, 0x0,
0x8f, 0x80, 0x0, 0x0, 0x8, 0xf8, 0x0, 0x0,
0x0, 0x8f, 0x80,
/* U+72 "r" */
0xff, 0x5e, 0xf9, 0xf, 0xfe, 0x9e, 0xf3, 0xff,
0x40, 0x7f, 0x6f, 0xf1, 0x3, 0x73, 0xff, 0x10,
0x0, 0xf, 0xf1, 0x0, 0x0, 0xff, 0x10, 0x0,
0xf, 0xf1, 0x0, 0x0, 0xff, 0x10, 0x0, 0x0,
/* U+73 "s" */
0x7, 0xdf, 0xff, 0xc3, 0x2, 0xff, 0x87, 0x9f,
0xd0, 0x4f, 0xc0, 0x0, 0x88, 0x2, 0xff, 0xdc,
0xba, 0x40, 0x6, 0xce, 0xff, 0xff, 0x10, 0x11,
0x0, 0x1e, 0xf4, 0x5f, 0xa0, 0x0, 0xcf, 0x42,
0xff, 0x97, 0xaf, 0xf1, 0x6, 0xdf, 0xfe, 0xb3,
0x0,
/* U+74 "t" */
0xd, 0xf3, 0x0, 0x0, 0xdf, 0x30, 0x0, 0xef,
0xff, 0xff, 0x68, 0xef, 0xa9, 0x94, 0xd, 0xf3,
0x0, 0x0, 0xdf, 0x30, 0x0, 0xd, 0xf3, 0x0,
0x0, 0xdf, 0x30, 0x86, 0xc, 0xf4, 0xf, 0xb0,
0x9f, 0xdd, 0xf9, 0x1, 0xbf, 0xea, 0x10,
/* U+75 "u" */
0xf, 0xf0, 0x0, 0x9f, 0x70, 0xff, 0x0, 0x9,
0xf7, 0xf, 0xf0, 0x0, 0x9f, 0x70, 0xff, 0x0,
0x9, 0xf7, 0xf, 0xf0, 0x0, 0x9f, 0x70, 0xff,
0x0, 0xa, 0xf7, 0xf, 0xf1, 0x0, 0xef, 0x70,
0xbf, 0xd9, 0xde, 0xf7, 0x2, 0xbf, 0xe9, 0x8f,
0x70,
/* U+76 "v" */
0xf, 0xf2, 0x0, 0x4f, 0xd0, 0xaf, 0x70, 0x8,
0xf9, 0x6, 0xfb, 0x0, 0xcf, 0x50, 0x1f, 0xf0,
0xf, 0xf1, 0x0, 0xdf, 0x34, 0xfc, 0x0, 0x8,
0xf7, 0x8f, 0x80, 0x0, 0x4f, 0xbc, 0xf4, 0x0,
0x0, 0xff, 0xff, 0x0, 0x0, 0xb, 0xff, 0xb0,
0x0,
/* U+77 "w" */
0xdf, 0x20, 0xf, 0xfc, 0x0, 0x5f, 0xaa, 0xf5,
0x3, 0xff, 0xf0, 0x8, 0xf7, 0x7f, 0x80, 0x6f,
0xaf, 0x30, 0xbf, 0x33, 0xfb, 0xa, 0xf4, 0xf7,
0xe, 0xf0, 0xf, 0xe0, 0xdd, 0xf, 0xa2, 0xfd,
0x0, 0xdf, 0x3f, 0xa0, 0xde, 0x4f, 0x90, 0x9,
0xf9, 0xf7, 0x9, 0xf9, 0xf6, 0x0, 0x6f, 0xef,
0x30, 0x6f, 0xef, 0x30, 0x3, 0xff, 0xf0, 0x3,
0xff, 0xf0, 0x0,
/* U+78 "x" */
0x7, 0xfe, 0x0, 0xcf, 0x90, 0x0, 0xdf, 0x64,
0xfe, 0x10, 0x0, 0x5f, 0xdc, 0xf6, 0x0, 0x0,
0xc, 0xff, 0xd0, 0x0, 0x0, 0x7, 0xff, 0x90,
0x0, 0x0, 0x1f, 0xff, 0xf2, 0x0, 0x0, 0x9f,
0xa8, 0xfb, 0x0, 0x3, 0xff, 0x21, 0xff, 0x40,
0xc, 0xfa, 0x0, 0x8f, 0xd0,
/* U+79 "y" */
0xe, 0xf3, 0x0, 0x4f, 0xc0, 0xaf, 0x70, 0x8,
0xf8, 0x5, 0xfc, 0x0, 0xbf, 0x50, 0xf, 0xf0,
0xf, 0xf1, 0x0, 0xbf, 0x52, 0xfd, 0x0, 0x6,
0xf9, 0x6f, 0xa0, 0x0, 0x1f, 0xd9, 0xf6, 0x0,
0x0, 0xcf, 0xef, 0x20, 0x0, 0x7, 0xff, 0xf0,
0x0, 0x0, 0x6, 0xfb, 0x0, 0x0, 0x0, 0xcf,
0x70, 0x0, 0x3, 0xcf, 0xf1, 0x0, 0x0, 0x5f,
0xd4, 0x0, 0x0,
/* U+7A "z" */
0x4f, 0xff, 0xff, 0xf4, 0x29, 0x99, 0xbf, 0xf4,
0x0, 0x0, 0xdf, 0xb0, 0x0, 0xb, 0xfd, 0x0,
0x0, 0x8f, 0xf2, 0x0, 0x4, 0xff, 0x40, 0x0,
0x2f, 0xf7, 0x0, 0x0, 0x9f, 0xf9, 0x99, 0x92,
0xaf, 0xff, 0xff, 0xf4,
/* U+7B "{" */
0x2, 0xcf, 0xb0, 0x9f, 0xe7, 0xc, 0xf3, 0x0,
0xdf, 0x0, 0xd, 0xf0, 0x0, 0xdf, 0x0, 0xe,
0xf0, 0x8, 0xfc, 0x0, 0xdf, 0x40, 0x8, 0xfc,
0x0, 0xe, 0xf0, 0x0, 0xdf, 0x0, 0xd, 0xf0,
0x0, 0xdf, 0x0, 0xc, 0xf3, 0x0, 0x9f, 0xe7,
0x2, 0xcf, 0xb0,
/* U+7C "|" */
0xff, 0xf, 0xf0, 0xff, 0xf, 0xf0, 0xff, 0xf,
0xf0, 0xff, 0xf, 0xf0, 0xff, 0xf, 0xf0, 0xff,
0xf, 0xf0, 0xff, 0xf, 0xf0, 0xff, 0xd, 0xd0,
/* U+7D "}" */
0xdf, 0xb1, 0x8, 0xff, 0x80, 0x5, 0xfa, 0x0,
0x2f, 0xb0, 0x2, 0xfb, 0x0, 0x2f, 0xb0, 0x1,
0xfc, 0x0, 0xe, 0xf6, 0x0, 0x6f, 0xb0, 0xe,
0xf6, 0x2, 0xfc, 0x0, 0x2f, 0xb0, 0x2, 0xfb,
0x0, 0x2f, 0xb0, 0x4, 0xfa, 0x9, 0xef, 0x80,
0xdf, 0xb1, 0x0,
/* U+7E "~" */
0x0, 0x0, 0x0, 0x0, 0x0, 0xaf, 0xe9, 0x32,
0xc6, 0x8f, 0xff, 0xff, 0xff, 0x3b, 0x90, 0x49,
0xee, 0x50, 0x0, 0x0, 0x0, 0x0, 0x0
};
/*---------------------
* GLYPH DESCRIPTION
*--------------------*/
static const lv_font_fmt_txt_glyph_dsc_t glyph_dsc[] = {
{.bitmap_index = 0, .adv_w = 0, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0} /* id = 0 reserved */,
{.bitmap_index = 0, .adv_w = 72, .box_w = 0, .box_h = 0, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 0, .adv_w = 79, .box_w = 3, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 20, .adv_w = 107, .box_w = 6, .box_h = 6, .ofs_x = 0, .ofs_y = 7},
{.bitmap_index = 38, .adv_w = 181, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 110, .adv_w = 181, .box_w = 11, .box_h = 16, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 198, .adv_w = 230, .box_w = 14, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 289, .adv_w = 200, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 374, .adv_w = 56, .box_w = 3, .box_h = 6, .ofs_x = 0, .ofs_y = 7},
{.bitmap_index = 383, .adv_w = 89, .box_w = 5, .box_h = 17, .ofs_x = 0, .ofs_y = -4},
{.bitmap_index = 426, .adv_w = 89, .box_w = 5, .box_h = 17, .ofs_x = 0, .ofs_y = -4},
{.bitmap_index = 469, .adv_w = 180, .box_w = 7, .box_h = 7, .ofs_x = 2, .ofs_y = 6},
{.bitmap_index = 494, .adv_w = 181, .box_w = 10, .box_h = 10, .ofs_x = 1, .ofs_y = 2},
{.bitmap_index = 544, .adv_w = 65, .box_w = 3, .box_h = 5, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 552, .adv_w = 64, .box_w = 5, .box_h = 3, .ofs_x = 0, .ofs_y = 4},
{.bitmap_index = 560, .adv_w = 61, .box_w = 3, .box_h = 3, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 565, .adv_w = 175, .box_w = 11, .box_h = 17, .ofs_x = -1, .ofs_y = -4},
{.bitmap_index = 659, .adv_w = 181, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 731, .adv_w = 181, .box_w = 7, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 777, .adv_w = 181, .box_w = 10, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 842, .adv_w = 181, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 914, .adv_w = 181, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 986, .adv_w = 181, .box_w = 10, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1051, .adv_w = 181, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1123, .adv_w = 181, .box_w = 10, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1188, .adv_w = 181, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1260, .adv_w = 181, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1332, .adv_w = 61, .box_w = 3, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1346, .adv_w = 60, .box_w = 3, .box_h = 11, .ofs_x = 0, .ofs_y = -2},
{.bitmap_index = 1363, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 1},
{.bitmap_index = 1407, .adv_w = 181, .box_w = 10, .box_h = 6, .ofs_x = 1, .ofs_y = 3},
{.bitmap_index = 1437, .adv_w = 125, .box_w = 8, .box_h = 11, .ofs_x = 0, .ofs_y = 1},
{.bitmap_index = 1481, .adv_w = 152, .box_w = 9, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1540, .adv_w = 201, .box_w = 12, .box_h = 12, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1612, .adv_w = 183, .box_w = 13, .box_h = 13, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 1697, .adv_w = 183, .box_w = 10, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1762, .adv_w = 178, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1834, .adv_w = 193, .box_w = 11, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 1906, .adv_w = 156, .box_w = 10, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 1971, .adv_w = 149, .box_w = 8, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2023, .adv_w = 186, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2101, .adv_w = 197, .box_w = 11, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2173, .adv_w = 70, .box_w = 3, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2193, .adv_w = 149, .box_w = 9, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2252, .adv_w = 186, .box_w = 11, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2324, .adv_w = 145, .box_w = 8, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2376, .adv_w = 258, .box_w = 15, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2474, .adv_w = 212, .box_w = 12, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2552, .adv_w = 187, .box_w = 12, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2630, .adv_w = 176, .box_w = 10, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2695, .adv_w = 193, .box_w = 13, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2780, .adv_w = 186, .box_w = 10, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 2845, .adv_w = 172, .box_w = 11, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2917, .adv_w = 152, .box_w = 10, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 2982, .adv_w = 194, .box_w = 11, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3054, .adv_w = 177, .box_w = 13, .box_h = 13, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 3139, .adv_w = 287, .box_w = 18, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3256, .adv_w = 181, .box_w = 13, .box_h = 13, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 3341, .adv_w = 175, .box_w = 12, .box_h = 13, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 3419, .adv_w = 166, .box_w = 10, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3484, .adv_w = 89, .box_w = 5, .box_h = 17, .ofs_x = 0, .ofs_y = -4},
{.bitmap_index = 3527, .adv_w = 175, .box_w = 11, .box_h = 17, .ofs_x = -1, .ofs_y = -4},
{.bitmap_index = 3621, .adv_w = 88, .box_w = 5, .box_h = 17, .ofs_x = 0, .ofs_y = -4},
{.bitmap_index = 3664, .adv_w = 138, .box_w = 9, .box_h = 6, .ofs_x = 0, .ofs_y = 7},
{.bitmap_index = 3691, .adv_w = 144, .box_w = 9, .box_h = 2, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 3700, .adv_w = 144, .box_w = 4, .box_h = 4, .ofs_x = 2, .ofs_y = 9},
{.bitmap_index = 3708, .adv_w = 150, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3749, .adv_w = 152, .box_w = 8, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 3801, .adv_w = 141, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3842, .adv_w = 151, .box_w = 9, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3901, .adv_w = 146, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3942, .adv_w = 90, .box_w = 6, .box_h = 13, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 3981, .adv_w = 152, .box_w = 9, .box_h = 13, .ofs_x = 0, .ofs_y = -4},
{.bitmap_index = 4040, .adv_w = 153, .box_w = 8, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4092, .adv_w = 64, .box_w = 2, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4105, .adv_w = 64, .box_w = 3, .box_h = 16, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 4129, .adv_w = 138, .box_w = 8, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4181, .adv_w = 64, .box_w = 2, .box_h = 13, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4194, .adv_w = 235, .box_w = 13, .box_h = 9, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4253, .adv_w = 153, .box_w = 8, .box_h = 9, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4289, .adv_w = 149, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4330, .adv_w = 154, .box_w = 8, .box_h = 13, .ofs_x = 1, .ofs_y = -4},
{.bitmap_index = 4382, .adv_w = 152, .box_w = 9, .box_h = 13, .ofs_x = 0, .ofs_y = -4},
{.bitmap_index = 4441, .adv_w = 121, .box_w = 7, .box_h = 9, .ofs_x = 1, .ofs_y = 0},
{.bitmap_index = 4473, .adv_w = 142, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4514, .adv_w = 110, .box_w = 7, .box_h = 11, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4553, .adv_w = 152, .box_w = 9, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4594, .adv_w = 127, .box_w = 9, .box_h = 9, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 4635, .adv_w = 205, .box_w = 13, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4694, .adv_w = 129, .box_w = 10, .box_h = 9, .ofs_x = -1, .ofs_y = 0},
{.bitmap_index = 4739, .adv_w = 125, .box_w = 9, .box_h = 13, .ofs_x = -1, .ofs_y = -4},
{.bitmap_index = 4798, .adv_w = 122, .box_w = 8, .box_h = 9, .ofs_x = 0, .ofs_y = 0},
{.bitmap_index = 4834, .adv_w = 110, .box_w = 5, .box_h = 17, .ofs_x = 1, .ofs_y = -4},
{.bitmap_index = 4877, .adv_w = 32, .box_w = 3, .box_h = 16, .ofs_x = 0, .ofs_y = -3},
{.bitmap_index = 4901, .adv_w = 110, .box_w = 5, .box_h = 17, .ofs_x = 1, .ofs_y = -4},
{.bitmap_index = 4944, .adv_w = 140, .box_w = 9, .box_h = 5, .ofs_x = 0, .ofs_y = 10}
};
/*---------------------
* CHARACTER MAPPING
*--------------------*/
/*Collect the unicode lists and glyph_id offsets*/
static const lv_font_fmt_txt_cmap_t cmaps[] =
{
{
.range_start = 32, .range_length = 95, .glyph_id_start = 1,
.unicode_list = NULL, .glyph_id_ofs_list = NULL, .list_length = 0, .type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY
}
};
/*--------------------
* ALL CUSTOM DATA
*--------------------*/
/*Store all the custom data of the font*/
static lv_font_fmt_txt_dsc_t font_dsc = {
.glyph_bitmap = gylph_bitmap,
.glyph_dsc = glyph_dsc,
.cmaps = cmaps,
.kern_dsc = NULL,
.kern_scale = 0,
.cmap_num = 1,
.bpp = 4,
.kern_classes = 0,
.bitmap_format = 0
};
/*-----------------
* PUBLIC FONT
*----------------*/
/*Initialize a public general font descriptor*/
lv_font_t lv_font_eurostyle_bold_18 = {
.get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt, /*Function pointer to get glyph's data*/
.get_glyph_bitmap = lv_font_get_bitmap_fmt_txt, /*Function pointer to get glyph's bitmap*/
.line_height = 19, /*The maximum line height required by the font*/
.base_line = 4, /*Baseline measured from the bottom of the line*/
#if !(LVGL_VERSION_MAJOR == 6 && LVGL_VERSION_MINOR == 0)
.subpx = LV_FONT_SUBPX_NONE,
#endif
#if LV_VERSION_CHECK(7, 4, 0)
.underline_position = -2,
.underline_thickness = 1,
#endif
.dsc = &font_dsc /*The custom font data. Will be accessed by `get_glyph_bitmap/dsc` */
};
#endif /*#if LV_FONT_EUROSTYLE_BOLD_18*/
| 41.856455 | 116 | 0.558727 | [
"3d"
] |
b768d3355f525b2411c9aaafc49c31341875a0ab | 13,399 | h | C | src/stub/nav.h | sigsegv-mvm/sigsegv-mvm | d98dbafed212b203793ffd5eef34e0cad66cede8 | [
"BSD-2-Clause"
] | 33 | 2016-02-18T04:27:53.000Z | 2022-01-15T18:59:53.000Z | src/stub/nav.h | sigsegv-mvm/sigsegv-mvm | d98dbafed212b203793ffd5eef34e0cad66cede8 | [
"BSD-2-Clause"
] | 5 | 2018-01-10T18:41:38.000Z | 2020-10-01T13:34:53.000Z | src/stub/nav.h | sigsegv-mvm/sigsegv-mvm | d98dbafed212b203793ffd5eef34e0cad66cede8 | [
"BSD-2-Clause"
] | 14 | 2017-08-06T23:02:49.000Z | 2021-08-24T00:24:16.000Z | #ifndef _INCLUDE_SIGSEGV_STUB_NAV_H_
#define _INCLUDE_SIGSEGV_STUB_NAV_H_
#include "prop.h"
#include "link/link.h"
#include "stub/tf_shareddefs.h"
#include "stub/entities.h"
class CBaseObject;
class CTFBotPathCost;
enum NavErrorType : int32_t;
enum GetNavAreaFlags_t : uint32_t
{
GETNAVAREA_CHECK_LOS = 0x1,
GETNAVAREA_ALLOW_BLOCKED_AREAS = 0x2,
GETNAVAREA_CHECK_GROUND = 0x4,
};
enum NavAttributeType : uint32_t
{
NAV_MESH_INVALID = 0,
NAV_MESH_CROUCH = 0x00000001, // must crouch to use this node/area
NAV_MESH_JUMP = 0x00000002, // must jump to traverse this area (only used during generation)
NAV_MESH_PRECISE = 0x00000004, // do not adjust for obstacles, just move along area
NAV_MESH_NO_JUMP = 0x00000008, // inhibit discontinuity jumping
NAV_MESH_STOP = 0x00000010, // must stop when entering this area
NAV_MESH_RUN = 0x00000020, // must run to traverse this area
NAV_MESH_WALK = 0x00000040, // must walk to traverse this area
NAV_MESH_AVOID = 0x00000080, // avoid this area unless alternatives are too dangerous
NAV_MESH_TRANSIENT = 0x00000100, // area may become blocked, and should be periodically checked
NAV_MESH_DONT_HIDE = 0x00000200, // area should not be considered for hiding spot generation
NAV_MESH_STAND = 0x00000400, // bots hiding in this area should stand
NAV_MESH_NO_HOSTAGES = 0x00000800, // hostages shouldn't use this area
NAV_MESH_STAIRS = 0x00001000, // this area represents stairs, do not attempt to climb or jump them - just walk up
NAV_MESH_NO_MERGE = 0x00002000, // don't merge this area with adjacent areas
NAV_MESH_OBSTACLE_TOP = 0x00004000, // this nav area is the climb point on the tip of an obstacle
NAV_MESH_CLIFF = 0x00008000, // this nav area is adjacent to a drop of at least CliffHeight
NAV_MESH_FIRST_CUSTOM = 0x00010000, // apps may define custom app-specific bits starting with this value
NAV_MESH_LAST_CUSTOM = 0x04000000, // apps must not define custom app-specific bits higher than with this value
NAV_MESH_FUNC_COST = 0x20000000, // area has designer specified cost controlled by func_nav_cost entities
NAV_MESH_HAS_ELEVATOR = 0x40000000, // area is in an elevator's path
NAV_MESH_NAV_BLOCKER = 0x80000000 // area is blocked by nav blocker ( Alas, needed to hijack a bit in the attributes to get within a cache line [7/24/2008 tom])
};
/* from mvm-reversed/server/tf/nav_mesh/tf_nav_area.h */
enum TFNavAttributeType : uint32_t
{
BLOCKED = (1 << 0),
RED_SPAWN_ROOM = (1 << 1),
BLUE_SPAWN_ROOM = (1 << 2),
SPAWN_ROOM_EXIT = (1 << 3),
AMMO = (1 << 4),
HEALTH = (1 << 5),
CONTROL_POINT = (1 << 6),
BLUE_SENTRY = (1 << 7),
RED_SENTRY = (1 << 8),
/* bit 9: unused */
/* bit 10: unused */
BLUE_SETUP_GATE = (1 << 11),
RED_SETUP_GATE = (1 << 12),
BLOCKED_AFTER_POINT_CAPTURE = (1 << 13),
BLOCKED_UNTIL_POINT_CAPTURE = (1 << 14),
BLUE_ONE_WAY_DOOR = (1 << 15),
RED_ONE_WAY_DOOR = (1 << 16),
WITH_SECOND_POINT = (1 << 17),
WITH_THIRD_POINT = (1 << 18),
WITH_FOURTH_POINT = (1 << 19),
WITH_FIFTH_POINT = (1 << 20),
SNIPER_SPOT = (1 << 21),
SENTRY_SPOT = (1 << 22),
/* bit 23: unused */
/* bit 24: unused */
NO_SPAWNING = (1 << 25),
RESCUE_CLOSET = (1 << 26),
BOMB_DROP = (1 << 27),
DOOR_NEVER_BLOCKS = (1 << 28),
DOOR_ALWAYS_BLOCKS = (1 << 29),
UNBLOCKABLE = (1 << 30),
/* bit 31: unused */
};
struct Extent
{
Vector lo, hi;
void Init( void )
{
lo.Init();
hi.Init();
}
void Init( CBaseEntity *entity )
{
entity->CollisionProp()->WorldSpaceSurroundingBounds( &lo, &hi );
}
float SizeX( void ) const { return hi.x - lo.x; }
float SizeY( void ) const { return hi.y - lo.y; }
float SizeZ( void ) const { return hi.z - lo.z; }
float Area( void ) const { return SizeX() * SizeY(); }
// Increase bounds to contain the given point
void Encompass( const Vector &pos )
{
for ( int i=0; i<3; ++i )
{
if ( pos[i] < lo[i] )
{
lo[i] = pos[i];
}
else if ( pos[i] > hi[i] )
{
hi[i] = pos[i];
}
}
}
// Increase bounds to contain the given extent
void Encompass( const Extent &extent )
{
Encompass( extent.lo );
Encompass( extent.hi );
}
// return true if 'pos' is inside of this extent
bool Contains( const Vector &pos ) const
{
return (pos.x >= lo.x && pos.x <= hi.x &&
pos.y >= lo.y && pos.y <= hi.y &&
pos.z >= lo.z && pos.z <= hi.z);
}
// return true if this extent overlaps the given one
bool IsOverlapping( const Extent &other ) const
{
return (lo.x <= other.hi.x && hi.x >= other.lo.x &&
lo.y <= other.hi.y && hi.y >= other.lo.y &&
lo.z <= other.hi.z && hi.z >= other.lo.z);
}
// return true if this extent completely contains the given one
bool IsEncompassing( const Extent &other, float tolerance = 0.0f ) const
{
return (lo.x <= other.lo.x + tolerance && hi.x >= other.hi.x - tolerance &&
lo.y <= other.lo.y + tolerance && hi.y >= other.hi.y - tolerance &&
lo.z <= other.lo.z + tolerance && hi.z >= other.hi.z - tolerance);
}
};
class CFuncNavCost : public CBaseEntity
{
public:
bool HasTag(const char *groupname) const { return ft_HasTag(this, groupname); }
// CUtlVector<CFmtStr>& GetTagsVector() { return *reinterpret_cast<CUtlVector<CFmtStr> *>((uintptr_t)this->m_iszTags.GetPtr() + sizeof(string_t)); }
DECL_DATAMAP(int, m_team);
DECL_DATAMAP(bool, m_isDisabled);
DECL_DATAMAP(string_t, m_iszTags);
DECL_RELATIVE(CUtlVector<CFmtStr>, m_tags);
private:
static MemberFuncThunk<const CFuncNavCost *, bool, const char *> ft_HasTag;
};
class CFuncNavAvoid : public CFuncNavCost {};
class CFuncNavPrefer : public CFuncNavCost {};
class CNavArea
{
public:
const Vector& GetCenter() const { return this->m_center; }
bool HasAttributes(int bits) const { return ((this->m_attributeFlags & bits) != 0); }
CNavArea *GetParent() const { return this->m_parent; }
int GetParentHow() const { return this->m_parentHow; }
float GetCostSoFar() const { return this->m_costSoFar; }
void GetExtent(Extent *extent) const { ft_GetExtent (this, extent); }
void GetClosestPointOnArea(const Vector& pos, Vector *close) const { ft_GetClosestPointOnArea (this, &pos, close); }
float ComputeAdjacentConnectionHeightChange(const CNavArea *destinationArea) const { return ft_ComputeAdjacentConnectionHeightChange(this, destinationArea); }
float GetZ(float x, float y) const { return ft_GetZ (this, x, y); }
void DrawFilled(int r, int g, int b, int a, float deltaT, bool noDepthTest, float margin) const { vt_DrawFilled (this, r, g, b, a, deltaT, noDepthTest, margin); }
DECL_EXTRACT(CUtlVector<CHandle<CFuncNavCost>>, m_funcNavCostVector);
private:
DECL_EXTRACT (Vector, m_center);
DECL_EXTRACT (int, m_attributeFlags);
DECL_RELATIVE(CNavArea *, m_parent);
DECL_RELATIVE(int, m_parentHow);
DECL_EXTRACT (float, m_costSoFar);
static MemberFuncThunk <const CNavArea *, void, Extent *> ft_GetExtent;
static MemberFuncThunk <const CNavArea *, void, const Vector *, Vector *> ft_GetClosestPointOnArea;
static MemberFuncThunk <const CNavArea *, float, const CNavArea *> ft_ComputeAdjacentConnectionHeightChange;
static MemberFuncThunk <const CNavArea *, float, float, float> ft_GetZ;
static MemberVFuncThunk<const CNavArea *, void, int, int, int, int, float, bool, float> vt_DrawFilled;
};
class CTFNavArea : public CNavArea
{
public:
TFNavAttributeType GetTFAttributes() const { return this->m_nAttributes; }
bool HasTFAttributes(TFNavAttributeType attr) const { return ((this->m_nAttributes & attr) != 0); }
bool IsInCombat() const { return (this->GetCombatIntensity() > 0.01f); }
float GetIncursionDistance(int team) const { return this->m_IncursionDistances[team]; }
bool IsBlocked(int teamID, bool ignoreNavBlockers = false) const { return ft_IsBlocked(this, teamID, ignoreNavBlockers); }
float GetCombatIntensity() const { return ft_GetCombatIntensity(this); }
private:
DECL_EXTRACT(TFNavAttributeType, m_nAttributes);
DECL_EXTRACT(float[4], m_IncursionDistances);
static MemberFuncThunk<const CTFNavArea *, bool, int, bool> ft_IsBlocked;
static MemberFuncThunk<const CTFNavArea *, float> ft_GetCombatIntensity;
};
class CNavMesh
{
public:
CNavArea *GetNavArea(const Vector& pos, float beneathLimit = 120.0f) const { return ft_GetNavArea_vec (this, pos, beneathLimit); }
CNavArea *GetNavArea(CBaseEntity *pEntity, int nGetNavAreaFlags, float flBeneathLimit = 120.0f) const { return ft_GetNavArea_ent (this, pEntity, nGetNavAreaFlags, flBeneathLimit); }
CNavArea *GetNearestNavArea(const Vector& pos, bool anyZ = false, float maxDist = 10000.0f, bool checkLOS = false, bool checkGround = true, int team = TEAM_ANY) const { return ft_GetNearestNavArea_vec (this, pos, anyZ, maxDist, checkLOS, checkGround, team); }
CNavArea *GetNearestNavArea(CBaseEntity *pEntity, int nFlags = GETNAVAREA_CHECK_GROUND, float maxDist = 10000.0f) const { return ft_GetNearestNavArea_ent (this, pEntity, nFlags, maxDist); }
bool GetGroundHeight(const Vector& pos, float *height, Vector *normal = nullptr) const { return ft_GetGroundHeight (this, pos, height, normal); }
#if TOOLCHAIN_FIXES
void CollectAreasOverlappingExtent(const Extent& extent, CUtlVector<CTFNavArea *> *outVector) { ft_CollectAreasOverlappingExtent_CTFNavArea(this, extent, outVector); }
#endif
private:
static MemberFuncThunk<const CNavMesh *, CNavArea *, const Vector&, float> ft_GetNavArea_vec;
static MemberFuncThunk<const CNavMesh *, CNavArea *, CBaseEntity *, int, float> ft_GetNavArea_ent;
static MemberFuncThunk<const CNavMesh *, CNavArea *, const Vector&, bool, float, bool, bool, int> ft_GetNearestNavArea_vec;
static MemberFuncThunk<const CNavMesh *, CNavArea *, CBaseEntity *, int, float> ft_GetNearestNavArea_ent;
static MemberFuncThunk<const CNavMesh *, bool, const Vector&, float *, Vector *> ft_GetGroundHeight;
static MemberFuncThunk< CNavMesh *, void, const Extent&, CUtlVector<CTFNavArea *> *> ft_CollectAreasOverlappingExtent_CTFNavArea;
};
class CTFNavMesh : public CNavMesh
{
public:
void CollectBuiltObjects(CUtlVector<CBaseObject *> *objects, int i1) { ft_CollectBuiltObjects(this, objects, i1); }
private:
static MemberFuncThunk<CTFNavMesh *, void, CUtlVector<CBaseObject *> *, int> ft_CollectBuiltObjects;
};
extern GlobalThunk<CTFNavMesh *> TheNavMesh;
extern GlobalThunk<CUtlVector<CTFNavArea *>> TheNavAreas;
extern StaticFuncThunk<float, CNavArea *, CNavArea *, CTFBotPathCost&, float> ft_NavAreaTravelDistance_CTFBotPathCost;
template<typename CostFunctor>
inline float NavAreaTravelDistance(CNavArea *startArea, CNavArea *endArea, CostFunctor& costFunc, float maxPathLength = 0.0f)
{
/* we call NavAreaTravelDistance<CTFBotPathCost> for all functor types; should be okay */
return ft_NavAreaTravelDistance_CTFBotPathCost(startArea, endArea, *reinterpret_cast<CTFBotPathCost *>(&costFunc), maxPathLength);
}
extern StaticFuncThunk<bool, CNavArea *, CNavArea *, const Vector *, CTFBotPathCost&, CNavArea **, float, int, bool> ft_NavAreaBuildPath_CTFBotPathCost;
template<typename CostFunctor>
inline bool NavAreaBuildPath(CNavArea *startArea, CNavArea *goalArea, const Vector *goalPos, CostFunctor& costFunc, CNavArea **closestArea = nullptr, float maxPathLength = 0.0f, int teamID = TEAM_ANY, bool ignoreNavBlockers = false)
{
/* we call NavAreaBuildPath<CTFBotPathCost> for all functor types; should be okay */
return ft_NavAreaBuildPath_CTFBotPathCost(startArea, goalArea, goalPos, *reinterpret_cast<CTFBotPathCost *>(&costFunc), closestArea, maxPathLength, teamID, ignoreNavBlockers);
}
#endif
| 44.663333 | 279 | 0.628853 | [
"vector"
] |
b7758dbe6e9d7aa6192f07fb8e6de5fa7818b880 | 43,833 | h | C | benchmark/gruntcontribclean/bond/schema_apply.h | jviotti/binary-json-size-benchmark | a515dfd05736204fb36d3571a6a6b17e5f6e4916 | [
"Apache-2.0"
] | 2 | 2022-01-14T06:09:26.000Z | 2022-02-04T02:13:03.000Z | benchmark/gruntcontribclean/bond/schema_apply.h | jviotti/binary-json-size-benchmark | a515dfd05736204fb36d3571a6a6b17e5f6e4916 | [
"Apache-2.0"
] | null | null | null | benchmark/gruntcontribclean/bond/schema_apply.h | jviotti/binary-json-size-benchmark | a515dfd05736204fb36d3571a6a6b17e5f6e4916 | [
"Apache-2.0"
] | null | null | null |
//------------------------------------------------------------------------------
// This code was generated by a tool.
//
// Tool : Bond Compiler 0.12.1.0
// Input filename: benchmark/gruntcontribclean/bond/schema.bond
// Output filename: schema_apply.h
//
// Changes to this file may cause incorrect behavior and will be lost when
// the code is regenerated.
// <auto-generated />
//------------------------------------------------------------------------------
#pragma once
#include "schema_types.h"
#include <bond/core/bond.h>
#include <bond/stream/output_buffer.h>
namespace bond
{
//
// Extern template specializations of Apply function with common
// transforms for Options.
//
extern template
bool Apply(const ::bond::To< ::benchmark::Options>& transform,
const ::bond::bonded< ::benchmark::Options>& value);
extern template
bool Apply(const ::bond::InitSchemaDef& transform,
const ::benchmark::Options& value);
extern template
bool Apply(const ::bond::Null& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader< ::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Options>& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Options>& transform,
const ::bond::bonded<void, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Options& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Options& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::benchmark::Options& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Options>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::benchmark::Options& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Options>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Options>& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Options>& transform,
const ::bond::bonded<void, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Options& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Options& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Options>& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Options>& transform,
const ::bond::bonded<void, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Options& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Options& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Options, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
//
// Extern template specializations of Apply function with common
// transforms for Files.
//
extern template
bool Apply(const ::bond::To< ::benchmark::Files>& transform,
const ::bond::bonded< ::benchmark::Files>& value);
extern template
bool Apply(const ::bond::InitSchemaDef& transform,
const ::benchmark::Files& value);
extern template
bool Apply(const ::bond::Null& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader< ::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Files>& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Files>& transform,
const ::bond::bonded<void, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Files& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Files& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::benchmark::Files& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Files>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::benchmark::Files& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Files>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Files>& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Files>& transform,
const ::bond::bonded<void, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Files& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Files& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Files>& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Files>& transform,
const ::bond::bonded<void, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Files& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Files& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Files, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
//
// Extern template specializations of Apply function with common
// transforms for MainOptions.
//
extern template
bool Apply(const ::bond::To< ::benchmark::MainOptions>& transform,
const ::bond::bonded< ::benchmark::MainOptions>& value);
extern template
bool Apply(const ::bond::InitSchemaDef& transform,
const ::benchmark::MainOptions& value);
extern template
bool Apply(const ::bond::Null& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader< ::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::MainOptions>& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::MainOptions>& transform,
const ::bond::bonded<void, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::MainOptions& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::MainOptions& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::benchmark::MainOptions& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::MainOptions>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::benchmark::MainOptions& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::MainOptions>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::MainOptions>& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::MainOptions>& transform,
const ::bond::bonded<void, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::MainOptions& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::MainOptions& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::MainOptions>& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::MainOptions>& transform,
const ::bond::bonded<void, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::MainOptions& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::MainOptions& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::MainOptions, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
//
// Extern template specializations of Apply function with common
// transforms for Main.
//
extern template
bool Apply(const ::bond::To< ::benchmark::Main>& transform,
const ::bond::bonded< ::benchmark::Main>& value);
extern template
bool Apply(const ::bond::InitSchemaDef& transform,
const ::benchmark::Main& value);
extern template
bool Apply(const ::bond::Null& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader< ::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Main>& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Main>& transform,
const ::bond::bonded<void, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Main& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Main& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::benchmark::Main& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Main>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::benchmark::Main& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Main>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::CompactBinaryWriter<::bond::OutputBuffer>::Pass0 >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Main>& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Main>& transform,
const ::bond::bonded<void, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Main& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Main& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::FastBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Main>& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::To< ::benchmark::Main>& transform,
const ::bond::bonded<void, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Main& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Serializer< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::benchmark::Main& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::CompactBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::FastBinaryReader<::bond::InputBuffer>&>& value);
extern template
bool Apply(const ::bond::Marshaler< ::bond::SimpleBinaryWriter<::bond::OutputBuffer> >& transform,
const ::bond::bonded< ::benchmark::Main, ::bond::SimpleBinaryReader<::bond::InputBuffer>&>& value);
} // namespace bond
| 52.874548 | 123 | 0.640545 | [
"transform"
] |
b77dec7731786693cd1437d6a6213311132524b9 | 3,327 | h | C | external/bsd/dhcp/dist/includes/omapip/buffer.h | calmsacibis995/minix | dfba95598f553b6560131d35a76658f1f8c9cf38 | [
"Unlicense"
] | null | null | null | external/bsd/dhcp/dist/includes/omapip/buffer.h | calmsacibis995/minix | dfba95598f553b6560131d35a76658f1f8c9cf38 | [
"Unlicense"
] | null | null | null | external/bsd/dhcp/dist/includes/omapip/buffer.h | calmsacibis995/minix | dfba95598f553b6560131d35a76658f1f8c9cf38 | [
"Unlicense"
] | null | null | null | /* $NetBSD: buffer.h,v 1.1.1.3 2014/07/12 11:57:57 spz Exp $ */
/* buffer.h
Definitions for the object management API protocol buffering... */
/*
* Copyright (c) 2004,2009,2014 by Internet Systems Consortium, Inc. ("ISC")
* Copyright (c) 1996-2003 by Internet Software Consortium
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Internet Systems Consortium, Inc.
* 950 Charter Street
* Redwood City, CA 94063
* <info@isc.org>
* https://www.isc.org/
*
*/
/* OMAPI buffers are ring buffers, which means that the beginning of the
buffer and the end of the buffer chase each other around. As long as
the tail never catches up to the head, there's room in the buffer for
data.
- If the tail and the head are equal, the buffer is empty.
- If the tail is less than the head, the contents of the buffer
are the bytes from the head to the end of buffer, and in addition,
the bytes between the beginning of the buffer and the tail, not
including the byte addressed by the tail.
- If the tail is greater than the head, then the buffer contains
valid bytes starting with the byte addressed by the head, and
ending with the byte before the byte addressed by the tail.
There will always be at least one byte of waste, because the tail can't
increase so that it's equal to the head (that would represent an empty
buffer. */
#define OMAPI_BUF_SIZE 4048
typedef struct _omapi_buffer {
struct _omapi_buffer *next; /* Buffers can be chained. */
u_int32_t refcnt; /* Buffers are reference counted. */
u_int16_t head, tail; /* Buffers are organized in a ring. */
char buf [OMAPI_BUF_SIZE]; /* The actual buffer is included in
the buffer data structure. */
} omapi_buffer_t;
#define BUFFER_BYTES_FREE(x) \
((x) -> tail > (x) -> head \
? sizeof ((x) -> buf) - ((x) -> tail - (x) -> head) \
: (x) -> head - (x) -> tail)
#define BYTES_IN_BUFFER(x) \
((x) -> tail > (x) -> head \
? (x) -> tail - (x) -> head - 1 \
: sizeof ((x) -> buf) - ((x) -> head - (x) -> tail) - 1)
isc_result_t omapi_connection_require (omapi_object_t *, unsigned);
isc_result_t omapi_connection_copyout (unsigned char *,
omapi_object_t *, unsigned);
isc_result_t omapi_connection_copyin (omapi_object_t *,
const unsigned char *, unsigned);
isc_result_t omapi_connection_flush (omapi_object_t *);
isc_result_t omapi_connection_get_uint32 (omapi_object_t *, u_int32_t *);
isc_result_t omapi_connection_put_uint32 (omapi_object_t *, u_int32_t);
isc_result_t omapi_connection_get_uint16 (omapi_object_t *, u_int16_t *);
isc_result_t omapi_connection_put_uint16 (omapi_object_t *, u_int32_t);
| 42.113924 | 76 | 0.717463 | [
"object"
] |
b77e2dc0db70ff3875758bc0969a5abe4f40c501 | 2,002 | h | C | chromium/ui/gfx/win/dpi.h | wedataintelligence/vivaldi-source | 22a46f2c969f6a0b7ca239a05575d1ea2738768c | [
"BSD-3-Clause"
] | 27 | 2016-04-27T01:02:03.000Z | 2021-12-13T08:53:19.000Z | chromium/ui/gfx/win/dpi.h | wedataintelligence/vivaldi-source | 22a46f2c969f6a0b7ca239a05575d1ea2738768c | [
"BSD-3-Clause"
] | 2 | 2017-03-09T09:00:50.000Z | 2017-09-21T15:48:20.000Z | chromium/ui/gfx/win/dpi.h | wedataintelligence/vivaldi-source | 22a46f2c969f6a0b7ca239a05575d1ea2738768c | [
"BSD-3-Clause"
] | 17 | 2016-04-27T02:06:39.000Z | 2019-12-18T08:07:00.000Z | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_GFX_DPI_WIN_H_
#define UI_GFX_DPI_WIN_H_
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/gfx_export.h"
namespace gfx {
// Sets the device scale factor that will be used unless overridden on the
// command line by --force-device-scale-factor. If this is not called, and that
// flag is not used, the scale factor used by the DIP conversion functions below
// will be that returned by GetDPIScale().
GFX_EXPORT void SetDefaultDeviceScaleFactor(float scale);
GFX_EXPORT Size GetDPI();
// Gets the scale factor of the display. For example, if the display DPI is
// 96 then the scale factor is 1.0. This clamps scale factors <= 1.25 to 1.0 to
// maintain previous (non-DPI-aware) behavior where only the font size was
// boosted.
GFX_EXPORT float GetDPIScale();
namespace win {
GFX_EXPORT Point ScreenToDIPPoint(const Point& pixel_point);
GFX_EXPORT Point DIPToScreenPoint(const Point& dip_point);
// WARNING: there is no right way to scale sizes and rects. The implementation
// of these strives to maintain a constant size by scaling the size independent
// of the origin. An alternative is to get the enclosing rect, which is the
// right way for some situations. Understand which you need before blindly
// assuming this is the right way.
GFX_EXPORT Rect ScreenToDIPRect(const Rect& pixel_bounds);
GFX_EXPORT Rect DIPToScreenRect(const Rect& dip_bounds);
GFX_EXPORT Size ScreenToDIPSize(const Size& size_in_pixels);
GFX_EXPORT Size DIPToScreenSize(const Size& dip_size);
// Win32's GetSystemMetrics uses pixel measures. This function calls
// GetSystemMetrics for the given |metric|, then converts the result to DIP.
GFX_EXPORT int GetSystemMetricsInDIP(int metric);
} // namespace win
} // namespace gfx
#endif // UI_GFX_DPI_WIN_H_
| 37.773585 | 80 | 0.774226 | [
"geometry"
] |
b7802c450c671074087227657190f7af28dc9870 | 777 | h | C | include/ccf/crypto/recover.h | PlyTools/cloak-evm | 687fe85b649e3907cafc9292a264b247c354282e | [
"Apache-2.0",
"MIT"
] | null | null | null | include/ccf/crypto/recover.h | PlyTools/cloak-evm | 687fe85b649e3907cafc9292a264b247c354282e | [
"Apache-2.0",
"MIT"
] | null | null | null | include/ccf/crypto/recover.h | PlyTools/cloak-evm | 687fe85b649e3907cafc9292a264b247c354282e | [
"Apache-2.0",
"MIT"
] | null | null | null | #pragma once
namespace crypto
{
struct RecoverableSignature
{
// Signature consists of 32 byte R, 32 byte S, and recovery id. Some
// formats concatenate all 3 into 65 bytes. We stick with libsecp256k1
// and separate 64 bytes of (R, S) from recovery_id.
static constexpr size_t RS_Size = 64;
std::array<uint8_t, RS_Size> raw;
int recovery_id;
RecoverableSignature() = default;
RecoverableSignature(const std::vector<uint8_t>& data)
{
std::copy(data.begin(), data.end(), raw.begin());
recovery_id = (int)data[64];
}
std::vector<uint8_t> serialise() const
{
std::vector<uint8_t> res(65);
std::copy(raw.begin(), raw.end(), res.begin());
res[64] = recovery_id;
return res;
}
};
} | 28.777778 | 74 | 0.631918 | [
"vector"
] |
b78f87d876c91f67baf6471d4039fc4687fe0bf2 | 4,193 | h | C | chrome/browser/chromeos/extensions/login_screen/login_screen_storage/login_screen_storage_api.h | sarang-apps/darshan_browser | 173649bb8a7c656dc60784d19e7bb73e07c20daa | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 575 | 2015-06-18T23:58:20.000Z | 2022-03-23T09:32:39.000Z | chrome/browser/chromeos/extensions/login_screen/login_screen_storage/login_screen_storage_api.h | sarang-apps/darshan_browser | 173649bb8a7c656dc60784d19e7bb73e07c20daa | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 113 | 2015-05-04T09:58:14.000Z | 2022-01-31T19:35:03.000Z | chrome/browser/chromeos/extensions/login_screen/login_screen_storage/login_screen_storage_api.h | sarang-apps/darshan_browser | 173649bb8a7c656dc60784d19e7bb73e07c20daa | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 52 | 2015-07-14T10:40:50.000Z | 2022-03-15T01:11:49.000Z | // Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_CHROMEOS_EXTENSIONS_LOGIN_SCREEN_LOGIN_SCREEN_STORAGE_LOGIN_SCREEN_STORAGE_API_H_
#define CHROME_BROWSER_CHROMEOS_EXTENSIONS_LOGIN_SCREEN_LOGIN_SCREEN_STORAGE_LOGIN_SCREEN_STORAGE_API_H_
#include "chromeos/dbus/login_manager/login_screen_storage.pb.h"
#include "extensions/browser/extension_function.h"
namespace extensions {
// Provides common callback functions to return results from
// 'LoginScreenStorageStore' and 'LoginScreenStorageRetrieve' D-Bus methods.
class LoginScreenStorageExtensionFunction : public ExtensionFunction {
protected:
LoginScreenStorageExtensionFunction();
~LoginScreenStorageExtensionFunction() override;
// When passed as a callback to the 'LoginScreenStorageStore' D-Bus method,
// returns its result to the calling extension.
void OnDataStored(base::Optional<std::string> error);
// When passed as a callback to the 'LoginScreenStorageRetrieve' D-Bus method,
// returns its result to the calling extension.
void OnDataRetrieved(base::Optional<std::string> data,
base::Optional<std::string> error);
private:
DISALLOW_COPY_AND_ASSIGN(LoginScreenStorageExtensionFunction);
};
class LoginScreenStorageStorePersistentDataFunction : public ExtensionFunction {
public:
LoginScreenStorageStorePersistentDataFunction();
DECLARE_EXTENSION_FUNCTION("loginScreenStorage.storePersistentData",
LOGINSCREENSTORAGE_STOREPERSISTENTDATA)
protected:
~LoginScreenStorageStorePersistentDataFunction() override;
// ExtensionFunction:
ResponseAction Run() override;
private:
// Called when data for one of the extension was stored, |extension_ids| is a
// list of the extensions that the data wasn't yet stored for.
void OnDataStored(std::vector<std::string> extension_ids,
const login_manager::LoginScreenStorageMetadata& metadata,
const std::string& data,
base::Optional<std::string> error);
// Asynchronously stores data for every extension from |extension_ids|.
void StoreDataForExtensions(
std::vector<std::string> extension_ids,
const login_manager::LoginScreenStorageMetadata& metadata,
const std::string& data);
DISALLOW_COPY_AND_ASSIGN(LoginScreenStorageStorePersistentDataFunction);
};
class LoginScreenStorageRetrievePersistentDataFunction
: public LoginScreenStorageExtensionFunction {
public:
LoginScreenStorageRetrievePersistentDataFunction();
DECLARE_EXTENSION_FUNCTION("loginScreenStorage.retrievePersistentData",
LOGINSCREENSTORAGE_RETRIEVEPERSISTENTDATA)
protected:
~LoginScreenStorageRetrievePersistentDataFunction() override;
// ExtensionFunction:
ResponseAction Run() override;
private:
DISALLOW_COPY_AND_ASSIGN(LoginScreenStorageRetrievePersistentDataFunction);
};
class LoginScreenStorageStoreCredentialsFunction
: public LoginScreenStorageExtensionFunction {
public:
LoginScreenStorageStoreCredentialsFunction();
DECLARE_EXTENSION_FUNCTION("loginScreenStorage.storeCredentials",
LOGINSCREENSTORAGE_STORECREDENTIALS)
protected:
~LoginScreenStorageStoreCredentialsFunction() override;
// ExtensionFunction:
ResponseAction Run() override;
private:
DISALLOW_COPY_AND_ASSIGN(LoginScreenStorageStoreCredentialsFunction);
};
class LoginScreenStorageRetrieveCredentialsFunction
: public LoginScreenStorageExtensionFunction {
public:
LoginScreenStorageRetrieveCredentialsFunction();
DECLARE_EXTENSION_FUNCTION("loginScreenStorage.retrieveCredentials",
LOGINSCREENSTORAGE_RETRIEVECREDENTIALS)
protected:
~LoginScreenStorageRetrieveCredentialsFunction() override;
// ExtensionFunction:
ResponseAction Run() override;
private:
DISALLOW_COPY_AND_ASSIGN(LoginScreenStorageRetrieveCredentialsFunction);
};
} // namespace extensions
#endif // CHROME_BROWSER_CHROMEOS_EXTENSIONS_LOGIN_SCREEN_LOGIN_SCREEN_STORAGE_LOGIN_SCREEN_STORAGE_API_H_
| 36.146552 | 107 | 0.789411 | [
"vector"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.