max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
1,738 | /*
* 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.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMONTOOLS_EXPORT_GEOMETRYDATA_H
#define CRYINCLUDE_CRYCOMMONTOOLS_EXPORT_GEOMETRYDATA_H
#pragma once
#include "IGeometryData.h"
#include <vector>
class GeometryData
: public IGeometryData
{
public:
GeometryData();
// IGeometryData
virtual int AddPosition(float x, float y, float z);
virtual int AddNormal(float x, float y, float z);
virtual int AddTextureCoordinate(float u, float v);
virtual int AddVertexColor(float r, float g, float b, float a);
virtual int AddPolygon(const int* indices, int mtlID);
virtual int GetNumberOfPositions() const;
virtual int GetNumberOfNormals() const;
virtual int GetNumberOfTextureCoordinates() const;
virtual int GetNumberOfVertexColors() const;
virtual int GetNumberOfPolygons() const;
struct Vector
{
Vector(float x, float y, float z)
: x(x)
, y(y)
, z(z) {}
float x, y, z;
};
struct TextureCoordinate
{
TextureCoordinate(float u, float v)
: u(u)
, v(v) {}
float u, v;
};
struct VertexColor
{
VertexColor(float r, float g, float b, float a)
: r(r)
, g(g)
, b(b)
, a(a) {}
float r, g, b, a;
};
struct Polygon
{
struct Vertex
{
Vertex() {}
Vertex(int positionIndex, int normalIndex, int textureCoordinateIndex, int vertexColorIndex)
: positionIndex(positionIndex)
, normalIndex(normalIndex)
, textureCoordinateIndex(textureCoordinateIndex)
, vertexColorIndex(vertexColorIndex) {}
int positionIndex, normalIndex, textureCoordinateIndex, vertexColorIndex;
};
Polygon(int mtlID, const Vertex& v0, const Vertex& v1, const Vertex& v2)
: mtlID(mtlID)
{
v[0] = v0;
v[1] = v1;
v[2] = v2;
}
int mtlID;
Vertex v[3];
};
std::vector<Vector> positions;
std::vector<Vector> normals;
std::vector<TextureCoordinate> textureCoordinates;
std::vector<VertexColor> vertexColors;
std::vector<Polygon> polygons;
};
#endif // CRYINCLUDE_CRYCOMMONTOOLS_EXPORT_GEOMETRYDATA_H
| 1,249 |
13,511 | <gh_stars>1000+
/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
package com.facebook.stetho.inspector.helper;
import javax.annotation.Nullable;
import javax.annotation.concurrent.GuardedBy;
import java.nio.channels.NotYetConnectedException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import com.facebook.stetho.common.LogRedirector;
import com.facebook.stetho.common.Util;
import com.facebook.stetho.inspector.jsonrpc.DisconnectReceiver;
import com.facebook.stetho.inspector.jsonrpc.JsonRpcPeer;
import com.facebook.stetho.inspector.jsonrpc.PendingRequestCallback;
/**
* Interface glue that allows a particular domain to manage the enabled peers. The way the
* WebKit inspector protocol works is that each functionality domain has an enable/disable JSON-RPC
* method call which alerts the server (that's us) that we can now begin sending local events
* to the peer to have them appear in the inspector UI. This class simplifies managing those
* enabled peers for each functionality domain.
*/
public class ChromePeerManager {
private static final String TAG = "ChromePeerManager";
/**
* Set of registered peers, mapped to the disconnect receiver for automatic unregistration
* purposes.
*/
@GuardedBy("this")
private final Map<JsonRpcPeer, DisconnectReceiver> mReceivingPeers = new HashMap<>();
/**
* This should be set to null anytime mReceivingPeers is changed. It should always be
* retrieved by calling getReceivingPeersSnapshot().
*/
@GuardedBy("this")
private JsonRpcPeer[] mReceivingPeersSnapshot;
@GuardedBy("this")
private PeerRegistrationListener mListener;
public ChromePeerManager() {
}
/**
* Set a listener which can receive notifications of unique registration event (see
* {@link #addPeer} and {@link #removePeer}).
*
* @param listener
*/
public synchronized void setListener(PeerRegistrationListener listener) {
mListener = listener;
}
/**
* Register a new peer, adding them to an internal list of receivers.
*
* @param peer
* @return True if this is a newly registered peer; false if it was already registered.
*/
public synchronized boolean addPeer(JsonRpcPeer peer) {
if (mReceivingPeers.containsKey(peer)) {
return false;
}
DisconnectReceiver disconnectReceiver = new UnregisterOnDisconnect(peer);
peer.registerDisconnectReceiver(disconnectReceiver);
mReceivingPeers.put(peer, disconnectReceiver);
mReceivingPeersSnapshot = null;
if (mListener != null) {
mListener.onPeerRegistered(peer);
}
return true;
}
/**
* Unregister an existing peer.
*
* @param peer
*/
public synchronized void removePeer(JsonRpcPeer peer) {
if (mReceivingPeers.remove(peer) != null) {
mReceivingPeersSnapshot = null;
if (mListener != null) {
mListener.onPeerUnregistered(peer);
}
}
}
public synchronized boolean hasRegisteredPeers() {
return !mReceivingPeers.isEmpty();
}
private synchronized JsonRpcPeer[] getReceivingPeersSnapshot() {
if (mReceivingPeersSnapshot == null) {
mReceivingPeersSnapshot = mReceivingPeers.keySet().toArray(
new JsonRpcPeer[mReceivingPeers.size()]);
}
return mReceivingPeersSnapshot;
}
public void sendNotificationToPeers(String method,
Object params) {
sendMessageToPeers(method, params, null /* callback */);
}
public void invokeMethodOnPeers(String method,
Object params,
PendingRequestCallback callback) {
Util.throwIfNull(callback);
sendMessageToPeers(method, params, callback);
}
private void sendMessageToPeers(String method,
Object params,
@Nullable PendingRequestCallback callback) {
JsonRpcPeer[] peers = getReceivingPeersSnapshot();
for (JsonRpcPeer peer : peers) {
try {
peer.invokeMethod(method, params, callback);
} catch (NotYetConnectedException e) {
LogRedirector.e(TAG, "Error delivering data to Chrome", e);
}
}
}
private class UnregisterOnDisconnect implements DisconnectReceiver {
private final JsonRpcPeer mPeer;
public UnregisterOnDisconnect(JsonRpcPeer peer) {
mPeer = peer;
}
@Override
public void onDisconnect() {
removePeer(mPeer);
}
}
}
| 1,518 |
1,088 | <gh_stars>1000+
# Copyright 2021 Alibaba Group Holding Limited. 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.
# =============================================================================
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
class Config(object):
def __init__(self):
"""Set and get configurations for tf models.
Configurations:
training (bool): Whether in training mode or not. Defaults to True.
emb_max_partitions (int): The `max_partitions` for embedding variables
partitioned by `min_max_variable_partitioner`. Specially,
`EmbeddingVariable` uses `fixed_size_partitioner`.
Defaults to None means no partition.
emb_min_slice_size (int): The `min_slice_size` for embedding variables
partitioned by `min_max_variable_partitioner`. Defaults to 128K.
emb_live_steps (int): Global steps to live for inactive keys in embedding
variables. Defaults to None.
"""
self.training = True
self.partitioner = 'min_max'
self.emb_max_partitions = None
self.emb_min_slice_size = 128 * 1024
self.emb_live_steps = None
conf = Config()
| 515 |
1,433 | //-----------------------------------------------------------------------------
//
// SensorAlarm.cpp
//
// Implementation of the Z-Wave COMMAND_CLASS_SENSOR_ALARM
//
// Copyright (c) 2010 <NAME> <<EMAIL>>
//
// SOFTWARE NOTICE AND LICENSE
//
// This file is part of OpenZWave.
//
// OpenZWave 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.
//
// OpenZWave 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 OpenZWave. If not, see <http://www.gnu.org/licenses/>.
//
//-----------------------------------------------------------------------------
#include "command_classes/CommandClasses.h"
#include "command_classes/SensorAlarm.h"
#include "Defs.h"
#include "Msg.h"
#include "Node.h"
#include "Driver.h"
#include "platform/Log.h"
#include "value_classes/ValueByte.h"
using namespace OpenZWave;
enum SensorAlarmCmd
{
SensorAlarmCmd_Get = 0x01,
SensorAlarmCmd_Report = 0x02,
SensorAlarmCmd_SupportedGet = 0x03,
SensorAlarmCmd_SupportedReport = 0x04
};
static char const* c_alarmTypeName[] =
{
"General",
"Smoke",
"Carbon Monoxide",
"Carbon Dioxide",
"Heat",
"Flood"
};
//-----------------------------------------------------------------------------
// <SensorAlarm::SensorAlarm>
// Constructor
//-----------------------------------------------------------------------------
SensorAlarm::SensorAlarm
(
uint32 const _homeId,
uint8 const _nodeId
):
CommandClass( _homeId, _nodeId )
{
SetStaticRequest( StaticRequest_Values );
}
//-----------------------------------------------------------------------------
// <SensorAlarm::RequestState>
// Get the static thermostat setpoint details from the device
//-----------------------------------------------------------------------------
bool SensorAlarm::RequestState
(
uint32 const _requestFlags,
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
bool requests = false;
if( ( _requestFlags & RequestFlag_Static ) && HasStaticRequest( StaticRequest_Values ) )
{
requests = RequestValue( _requestFlags, 0xff, _instance, _queue );
}
if( _requestFlags & RequestFlag_Dynamic )
{
for( uint8 i=0; i<SensorAlarm_Count; ++i )
{
Value* value = GetValue( 1, i );
if( value != NULL )
{
value->Release();
// There is a value for this alarm type, so request it
requests |= RequestValue( _requestFlags, i, _instance, _queue );
}
}
}
return requests;
}
//-----------------------------------------------------------------------------
// <SensorAlarm::RequestValue>
// Get the sensor alarm details from the device
//-----------------------------------------------------------------------------
bool SensorAlarm::RequestValue
(
uint32 const _requestFlags,
uint8 const _alarmType,
uint8 const _instance,
Driver::MsgQueue const _queue
)
{
if( _alarmType == 0xff )
{
// Request the supported alarm types
Msg* msg = new Msg( "SensorAlarmCmd_SupportedGet", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 2 );
msg->Append( GetCommandClassId() );
msg->Append( SensorAlarmCmd_SupportedGet );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
}
else
{
// Request the alarm state
if ( IsGetSupported() )
{
Msg* msg = new Msg( "SensorAlarmCmd_Get", GetNodeId(), REQUEST, FUNC_ID_ZW_SEND_DATA, true, true, FUNC_ID_APPLICATION_COMMAND_HANDLER, GetCommandClassId() );
msg->SetInstance( this, _instance );
msg->Append( GetNodeId() );
msg->Append( 3 );
msg->Append( GetCommandClassId() );
msg->Append( SensorAlarmCmd_Get );
msg->Append( _alarmType );
msg->Append( GetDriver()->GetTransmitOptions() );
GetDriver()->SendMsg( msg, _queue );
return true;
} else {
Log::Write( LogLevel_Info, GetNodeId(), "SensorAlarmCmd_Get Not Supported on this node");
}
}
return false;
}
//-----------------------------------------------------------------------------
// <SensorAlarm::HandleMsg>
// Handle a message from the Z-Wave network
//-----------------------------------------------------------------------------
bool SensorAlarm::HandleMsg
(
uint8 const* _data,
uint32 const _length,
uint32 const _instance // = 1
)
{
if( SensorAlarmCmd_Report == (SensorAlarmCmd)_data[0] )
{
// We have received an alarm state report from the Z-Wave device
if( ValueByte* value = static_cast<ValueByte*>( GetValue( _instance, _data[2] ) ) )
{
uint8 sourceNodeId = _data[1];
uint8 state = _data[3];
// uint16 time = (((uint16)_data[4])<<8) | (uint16)_data[5]; Don't know what to do with this yet.
value->OnValueRefreshed( state );
value->Release();
Log::Write( LogLevel_Info, GetNodeId(), "Received alarm state report from node %d: %s = %d", sourceNodeId, value->GetLabel().c_str(), state );
}
return true;
}
if( SensorAlarmCmd_SupportedReport == (SensorAlarmCmd)_data[0] )
{
if( Node* node = GetNodeUnsafe() )
{
// We have received the supported alarm types from the Z-Wave device
Log::Write( LogLevel_Info, GetNodeId(), "Received supported alarm types" );
// Parse the data for the supported alarm types
uint8 numBytes = _data[1];
for( uint32 i=0; i<numBytes; ++i )
{
for( int32 bit=0; bit<8; ++bit )
{
if( ( _data[i+2] & (1<<bit) ) != 0 )
{
// Add supported setpoint
int32 index = (int32)(i<<3) + bit;
if( index < SensorAlarm_Count )
{
node->CreateValueByte( ValueID::ValueGenre_User, GetCommandClassId(), _instance, index, c_alarmTypeName[index], "", true, false, 0, 0 );
Log::Write( LogLevel_Info, GetNodeId(), " Added alarm type: %s", c_alarmTypeName[index] );
}
}
}
}
}
ClearStaticRequest( StaticRequest_Values );
return true;
}
return false;
}
| 2,118 |
2,603 | /*******************************************************************************
* (c) Copyright 2016-2018 Microsemi SoC Products Group. All rights reserved.
*
* @file encodings.h
* @author Microsemi SoC Products Group
* @brief Mi-V soft processor register bit mask and shift constants encodings.
*
* SVN $Revision: 9825 $
* SVN $Date: 2018-03-19 10:31:41 +0530 (Mon, 19 Mar 2018) $
*/
#ifndef RISCV_CSR_ENCODING_H
#define RISCV_CSR_ENCODING_H
#ifdef __cplusplus
extern "C" {
#endif
#define MSTATUS_UIE 0x00000001
#define MSTATUS_SIE 0x00000002
#define MSTATUS_HIE 0x00000004
#define MSTATUS_MIE 0x00000008
#define MSTATUS_UPIE 0x00000010
#define MSTATUS_SPIE 0x00000020
#define MSTATUS_HPIE 0x00000040
#define MSTATUS_MPIE 0x00000080
#define MSTATUS_SPP 0x00000100
#define MSTATUS_HPP 0x00000600
#define MSTATUS_MPP 0x00001800
#define MSTATUS_FS 0x00006000
#define MSTATUS_XS 0x00018000
#define MSTATUS_MPRV 0x00020000
#define MSTATUS_SUM 0x00040000 /*changed in v1.10*/
#define MSTATUS_MXR 0x00080000 /*changed in v1.10*/
#define MSTATUS_TVM 0x00100000 /*changed in v1.10*/
#define MSTATUS_TW 0x00200000 /*changed in v1.10*/
#define MSTATUS_TSR 0x00400000 /*changed in v1.10*/
#define MSTATUS_RES 0x7F800000 /*changed in v1.10*/
#define MSTATUS32_SD 0x80000000
#define MSTATUS64_SD 0x8000000000000000
#define MCAUSE32_CAUSE 0x7FFFFFFF
#define MCAUSE64_CAUSE 0x7FFFFFFFFFFFFFFF
#define MCAUSE32_INT 0x80000000
#define MCAUSE64_INT 0x8000000000000000
#define SSTATUS_UIE 0x00000001
#define SSTATUS_SIE 0x00000002
#define SSTATUS_UPIE 0x00000010
#define SSTATUS_SPIE 0x00000020
#define SSTATUS_SPP 0x00000100
#define SSTATUS_FS 0x00006000
#define SSTATUS_XS 0x00018000
#define SSTATUS_PUM 0x00040000
#define SSTATUS32_SD 0x80000000
#define SSTATUS64_SD 0x8000000000000000
#define MIP_SSIP (1u << IRQ_S_SOFT)
#define MIP_HSIP (1u << IRQ_H_SOFT)
#define MIP_MSIP (1u << IRQ_M_SOFT)
#define MIP_STIP (1u << IRQ_S_TIMER)
#define MIP_HTIP (1u << IRQ_H_TIMER)
#define MIP_MTIP (1u << IRQ_M_TIMER)
#define MIP_SEIP (1u << IRQ_S_EXT)
#define MIP_HEIP (1u << IRQ_H_EXT)
#define MIP_MEIP (1u << IRQ_M_EXT)
#define SIP_SSIP MIP_SSIP
#define SIP_STIP MIP_STIP
#define PRV_U 0
#define PRV_S 1
#define PRV_H 2
#define PRV_M 3
#define VM_MBARE 0
#define VM_MBB 1
#define VM_MBBID 2
#define VM_SV32 8
#define VM_SV39 9
#define VM_SV48 10
#define IRQ_S_SOFT 1
#define IRQ_H_SOFT 2
#define IRQ_M_SOFT 3
#define IRQ_S_TIMER 5
#define IRQ_H_TIMER 6
#define IRQ_M_TIMER 7
#define IRQ_S_EXT 9
#define IRQ_H_EXT 10
#define IRQ_M_EXT 11
#define DEFAULT_RSTVEC 0x00001000
#define DEFAULT_NMIVEC 0x00001004
#define DEFAULT_MTVEC 0x00001010
#define CONFIG_STRING_ADDR 0x0000100C
#define EXT_IO_BASE 0x40000000
#define DRAM_BASE 0x80000000
/* page table entry (PTE) fields */
#define PTE_V 0x001 /* Valid */
#define PTE_TYPE 0x01E /* Type */
#define PTE_R 0x020 /* Referenced */
#define PTE_D 0x040 /* Dirty */
#define PTE_SOFT 0x380 /* Reserved for Software */
#define PTE_TYPE_TABLE 0x00
#define PTE_TYPE_TABLE_GLOBAL 0x02
#define PTE_TYPE_URX_SR 0x04
#define PTE_TYPE_URWX_SRW 0x06
#define PTE_TYPE_UR_SR 0x08
#define PTE_TYPE_URW_SRW 0x0A
#define PTE_TYPE_URX_SRX 0x0C
#define PTE_TYPE_URWX_SRWX 0x0E
#define PTE_TYPE_SR 0x10
#define PTE_TYPE_SRW 0x12
#define PTE_TYPE_SRX 0x14
#define PTE_TYPE_SRWX 0x16
#define PTE_TYPE_SR_GLOBAL 0x18
#define PTE_TYPE_SRW_GLOBAL 0x1A
#define PTE_TYPE_SRX_GLOBAL 0x1C
#define PTE_TYPE_SRWX_GLOBAL 0x1E
#define PTE_PPN_SHIFT 10
#define PTE_TABLE(PTE) ((0x0000000AU >> ((PTE) & 0x1F)) & 1)
#define PTE_UR(PTE) ((0x0000AAA0U >> ((PTE) & 0x1F)) & 1)
#define PTE_UW(PTE) ((0x00008880U >> ((PTE) & 0x1F)) & 1)
#define PTE_UX(PTE) ((0x0000A0A0U >> ((PTE) & 0x1F)) & 1)
#define PTE_SR(PTE) ((0xAAAAAAA0U >> ((PTE) & 0x1F)) & 1)
#define PTE_SW(PTE) ((0x88888880U >> ((PTE) & 0x1F)) & 1)
#define PTE_SX(PTE) ((0xA0A0A000U >> ((PTE) & 0x1F)) & 1)
#define PTE_CHECK_PERM(PTE, SUPERVISOR, STORE, FETCH) \
((STORE) ? ((SUPERVISOR) ? PTE_SW(PTE) : PTE_UW(PTE)) : \
(FETCH) ? ((SUPERVISOR) ? PTE_SX(PTE) : PTE_UX(PTE)) : \
((SUPERVISOR) ? PTE_SR(PTE) : PTE_UR(PTE)))
#ifdef __riscv
#if __riscv_xlen == 64
# define MSTATUS_SD MSTATUS64_SD
# define SSTATUS_SD SSTATUS64_SD
# define MCAUSE_INT MCAUSE64_INT
# define MCAUSE_CAUSE MCAUSE64_CAUSE
# define RISCV_PGLEVEL_BITS 9
#else
# define MSTATUS_SD MSTATUS32_SD
# define SSTATUS_SD SSTATUS32_SD
# define RISCV_PGLEVEL_BITS 10
# define MCAUSE_INT MCAUSE32_INT
# define MCAUSE_CAUSE MCAUSE32_CAUSE
#endif
#define RISCV_PGSHIFT 12
#define RISCV_PGSIZE (1 << RISCV_PGSHIFT)
#ifndef __ASSEMBLER__
#ifdef __GNUC__
#define read_csr(reg) ({ unsigned long __tmp; \
asm volatile ("csrr %0, " #reg : "=r"(__tmp)); \
__tmp; })
#define write_csr(reg, val) ({ \
if (__builtin_constant_p(val) && (unsigned long)(val) < 32) \
asm volatile ("csrw " #reg ", %0" :: "i"(val)); \
else \
asm volatile ("csrw " #reg ", %0" :: "r"(val)); })
#define swap_csr(reg, val) ({ unsigned long __tmp; \
if (__builtin_constant_p(val) && (unsigned long)(val) < 32) \
asm volatile ("csrrw %0, " #reg ", %1" : "=r"(__tmp) : "i"(val)); \
else \
asm volatile ("csrrw %0, " #reg ", %1" : "=r"(__tmp) : "r"(val)); \
__tmp; })
#define set_csr(reg, bit) ({ unsigned long __tmp; \
if (__builtin_constant_p(bit) && (unsigned long)(bit) < 32) \
asm volatile ("csrrs %0, " #reg ", %1" : "=r"(__tmp) : "i"(bit)); \
else \
asm volatile ("csrrs %0, " #reg ", %1" : "=r"(__tmp) : "r"(bit)); \
__tmp; })
#define clear_csr(reg, bit) ({ unsigned long __tmp; \
if (__builtin_constant_p(bit) && (unsigned long)(bit) < 32) \
asm volatile ("csrrc %0, " #reg ", %1" : "=r"(__tmp) : "i"(bit)); \
else \
asm volatile ("csrrc %0, " #reg ", %1" : "=r"(__tmp) : "r"(bit)); \
__tmp; })
#define rdtime() read_csr(time)
#define rdcycle() read_csr(cycle)
#define rdinstret() read_csr(instret)
#ifdef __riscv_atomic
#define MASK(nr) (1UL << nr)
#define MASK_NOT(nr) (~(1UL << nr))
/**
* atomic_read - read atomic variable
* @v: pointer of type int
*
* Atomically reads the value of @v.
*/
static inline int atomic_read(const int *v)
{
return *((volatile int *)(v));
}
/**
* atomic_set - set atomic variable
* @v: pointer of type int
* @i: required value
*
* Atomically sets the value of @v to @i.
*/
static inline void atomic_set(int *v, int i)
{
*v = i;
}
/**
* atomic_add - add integer to atomic variable
* @i: integer value to add
* @v: pointer of type int
*
* Atomically adds @i to @v.
*/
static inline void atomic_add(int i, int *v)
{
__asm__ __volatile__ (
"amoadd.w zero, %1, %0"
: "+A" (*v)
: "r" (i));
}
static inline int atomic_fetch_add(unsigned int mask, int *v)
{
int out;
__asm__ __volatile__ (
"amoadd.w %2, %1, %0"
: "+A" (*v), "=r" (out)
: "r" (mask));
return out;
}
/**
* atomic_sub - subtract integer from atomic variable
* @i: integer value to subtract
* @v: pointer of type int
*
* Atomically subtracts @i from @v.
*/
static inline void atomic_sub(int i, int *v)
{
atomic_add(-i, v);
}
static inline int atomic_fetch_sub(unsigned int mask, int *v)
{
int out;
__asm__ __volatile__ (
"amosub.w %2, %1, %0"
: "+A" (*v), "=r" (out)
: "r" (mask));
return out;
}
/**
* atomic_add_return - add integer to atomic variable
* @i: integer value to add
* @v: pointer of type int
*
* Atomically adds @i to @v and returns the result
*/
static inline int atomic_add_return(int i, int *v)
{
register int c;
__asm__ __volatile__ (
"amoadd.w %0, %2, %1"
: "=r" (c), "+A" (*v)
: "r" (i));
return (c + i);
}
/**
* atomic_sub_return - subtract integer from atomic variable
* @i: integer value to subtract
* @v: pointer of type int
*
* Atomically subtracts @i from @v and returns the result
*/
static inline int atomic_sub_return(int i, int *v)
{
return atomic_add_return(-i, v);
}
/**
* atomic_inc - increment atomic variable
* @v: pointer of type int
*
* Atomically increments @v by 1.
*/
static inline void atomic_inc(int *v)
{
atomic_add(1, v);
}
/**
* atomic_dec - decrement atomic variable
* @v: pointer of type int
*
* Atomically decrements @v by 1.
*/
static inline void atomic_dec(int *v)
{
atomic_add(-1, v);
}
static inline int atomic_inc_return(int *v)
{
return atomic_add_return(1, v);
}
static inline int atomic_dec_return(int *v)
{
return atomic_sub_return(1, v);
}
/**
* atomic_sub_and_test - subtract value from variable and test result
* @i: integer value to subtract
* @v: pointer of type int
*
* Atomically subtracts @i from @v and returns
* true if the result is zero, or false for all
* other cases.
*/
static inline int atomic_sub_and_test(int i, int *v)
{
return (atomic_sub_return(i, v) == 0);
}
/**
* atomic_inc_and_test - increment and test
* @v: pointer of type int
*
* Atomically increments @v by 1
* and returns true if the result is zero, or false for all
* other cases.
*/
static inline int atomic_inc_and_test(int *v)
{
return (atomic_inc_return(v) == 0);
}
/**
* atomic_dec_and_test - decrement and test
* @v: pointer of type int
*
* Atomically decrements @v by 1 and
* returns true if the result is 0, or false for all other
* cases.
*/
static inline int atomic_dec_and_test(int *v)
{
return (atomic_dec_return(v) == 0);
}
/**
* atomic_add_negative - add and test if negative
* @i: integer value to add
* @v: pointer of type int
*
* Atomically adds @i to @v and returns true
* if the result is negative, or false when
* result is greater than or equal to zero.
*/
static inline int atomic_add_negative(int i, int *v)
{
return (atomic_add_return(i, v) < 0);
}
static inline int atomic_xchg(int *v, int n)
{
register int c;
__asm__ __volatile__ (
"amoswap.w %0, %2, %1"
: "=r" (c), "+A" (*v)
: "r" (n));
return c;
}
/**
* atomic_and - Atomically clear bits in atomic variable
* @mask: Mask of the bits to be retained
* @v: pointer of type int
*
* Atomically retains the bits set in @mask from @v
*/
static inline void atomic_and(unsigned int mask, int *v)
{
__asm__ __volatile__ (
"amoand.w zero, %1, %0"
: "+A" (*v)
: "r" (mask));
}
static inline int atomic_fetch_and(unsigned int mask, int *v)
{
int out;
__asm__ __volatile__ (
"amoand.w %2, %1, %0"
: "+A" (*v), "=r" (out)
: "r" (mask));
return out;
}
/**
* atomic_or - Atomically set bits in atomic variable
* @mask: Mask of the bits to be set
* @v: pointer of type int
*
* Atomically sets the bits set in @mask in @v
*/
static inline void atomic_or(unsigned int mask, int *v)
{
__asm__ __volatile__ (
"amoor.w zero, %1, %0"
: "+A" (*v)
: "r" (mask));
}
static inline int atomic_fetch_or(unsigned int mask, int *v)
{
int out;
__asm__ __volatile__ (
"amoor.w %2, %1, %0"
: "+A" (*v), "=r" (out)
: "r" (mask));
return out;
}
/**
* atomic_xor - Atomically flips bits in atomic variable
* @mask: Mask of the bits to be flipped
* @v: pointer of type int
*
* Atomically flips the bits set in @mask in @v
*/
static inline void atomic_xor(unsigned int mask, int *v)
{
__asm__ __volatile__ (
"amoxor.w zero, %1, %0"
: "+A" (*v)
: "r" (mask));
}
static inline int atomic_fetch_xor(unsigned int mask, int *v)
{
int out;
__asm__ __volatile__ (
"amoxor.w %2, %1, %0"
: "+A" (*v), "=r" (out)
: "r" (mask));
return out;
}
/*----------------------------------------------------*/
/**
* test_and_set_bit - Set a bit and return its old value
* @nr: Bit to set
* @addr: Address to count from
*
* This operation is atomic and cannot be reordered.
* It also implies a memory barrier.
*/
static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
{
unsigned long __res, __mask;
__mask = MASK(nr);
__asm__ __volatile__ ( \
"amoor.w %0, %2, %1" \
: "=r" (__res), "+A" (*addr) \
: "r" (__mask)); \
return ((__res & __mask) != 0);
}
/**
* test_and_clear_bit - Clear a bit and return its old value
* @nr: Bit to clear
* @addr: Address to count from
*
* This operation is atomic and cannot be reordered.
* It also implies a memory barrier.
*/
static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
{
unsigned long __res, __mask;
__mask = MASK_NOT(nr);
__asm__ __volatile__ ( \
"amoand.w %0, %2, %1" \
: "=r" (__res), "+A" (*addr) \
: "r" (__mask)); \
return ((__res & __mask) != 0);
}
/**
* test_and_change_bit - Change a bit and return its old value
* @nr: Bit to change
* @addr: Address to count from
*
* This operation is atomic and cannot be reordered.
* It also implies a memory barrier.
*/
static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
{
unsigned long __res, __mask;
__mask = MASK(nr);
__asm__ __volatile__ ( \
"amoxor.w %0, %2, %1" \
: "=r" (__res), "+A" (*addr) \
: "r" (__mask)); \
return ((__res & __mask) != 0);
}
/**
* set_bit - Atomically set a bit in memory
* @nr: the bit to set
* @addr: the address to start counting from
*
* This function is atomic and may not be reordered.
*/
static inline void set_bit(int nr, volatile unsigned long *addr)
{
__asm__ __volatile__ ( \
"AMOOR.w zero, %1, %0" \
: "+A" (*addr) \
: "r" (MASK(nr)));
}
/**
* clear_bit - Clears a bit in memory
* @nr: Bit to clear
* @addr: Address to start counting from
*
* clear_bit() is atomic and may not be reordered.
*/
static inline void clear_bit(int nr, volatile unsigned long *addr)
{
__asm__ __volatile__ ( \
"AMOAND.w zero, %1, %0" \
: "+A" (*addr) \
: "r" (MASK_NOT(nr)));
}
/**
* change_bit - Toggle a bit in memory
* @nr: Bit to change
* @addr: Address to start counting from
*
* change_bit() is atomic and may not be reordered.
*/
static inline void change_bit(int nr, volatile unsigned long *addr)
{
__asm__ __volatile__ ( \
"AMOXOR.w zero, %1, %0" \
: "+A" (*addr) \
: "r" (MASK(nr)));
}
#endif /* __riscv_atomic */
#endif /*__GNUC__*/
#endif /*__ASSEMBLER__*/
#endif /*__riscv*/
#ifdef __cplusplus
}
#endif
#endif /*RISCV_CSR_ENCODING_H*/
| 8,064 |
317 | <gh_stars>100-1000
/*
* Copyright (C) 2005-2020 Centre National d'Etudes Spatiales (CNES)
*
* 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.
*/
#include "otbSarImageMetadataInterface.h"
#include "otbCosmoImageMetadataInterface.h"
#include "otbMacro.h"
#include "itkMetaDataObject.h"
#include "otbSpatialReference.h"
// useful constants
#include <otbMath.h>
#include <iomanip>
#include "otbSystem.h"
#include "otbXMLMetadataSupplier.h"
#include "gdal_pam.h"
#include <iostream>
namespace otb
{
double CosmoImageMetadataInterface::GetCenterIncidenceAngle(const MetadataSupplierInterface &) const
{
return 0;
}
std::vector<std::map<std::string, std::string> > CosmoImageMetadataInterface::saveMetadataBands(std::string file)
{
// Create GDALImageIO to retrieve all metadata (from .h5 input file)
std::map<std::string, std::string> metadataDataSet;
std::vector<std::map<std::string, std::string> > metadataBands;
GDALDataset * dataset = static_cast<GDALDataset*>(GDALOpen(file.c_str(), GA_ReadOnly));
// Metadata for dataset
char** papszMetadata = dataset->GetMetadata(nullptr);
for (int cpt = 0; papszMetadata[cpt] != nullptr; ++cpt)
{
std::string key, value;
if (otb::System::ParseHdfSubsetName(papszMetadata[cpt], key, value))
{
metadataDataSet[key] = value;
}
}
int nbRasterCount = dataset->GetRasterCount();
// Metadata for each Band
for (int iBand = 0; iBand < nbRasterCount; iBand++)
{
std::map<std::string, std::string> mapCurrentBand;
GDALRasterBand * Band = dataset->GetRasterBand(iBand + 1);
papszMetadata = Band->GetMetadata(nullptr);
for (int cpt = 0; papszMetadata[cpt] != nullptr; ++cpt)
{
std::string key, value;
if (otb::System::ParseHdfSubsetName(papszMetadata[cpt], key, value))
{
mapCurrentBand[key] = value;
}
}
metadataBands.push_back(mapCurrentBand);
}
GDALClose(static_cast<GDALDatasetH>(dataset));
return metadataBands;
}
std::vector<Orbit> CosmoImageMetadataInterface::getOrbits(const std::string & reference_UTC) const
{
////////////////// Add Orbit List ////////////////
bool hasOrbit ;
std::string nb_orbits = m_MetadataSupplierInterface->GetMetadataValue("Number_of_State_Vectors", hasOrbit) ;
// Get elements
int stateVectorList_size = std::stoi(nb_orbits);
std::string state_times = m_MetadataSupplierInterface->GetMetadataValue("State_Vectors_Times", hasOrbit);
std::string ecef_satellite_pos = m_MetadataSupplierInterface->GetMetadataValue("ECEF_Satellite_Position", hasOrbit) ;
std::string ecef_satellite_vel = m_MetadataSupplierInterface->GetMetadataValue("ECEF_Satellite_Velocity", hasOrbit);
// Convert std::string to vector
std::vector<std::string> vTimes;
otb::Utils::ConvertStringToVector(state_times, vTimes, "State_Vectors_Times", " ");
std::vector<std::string> vECEF_sat_pos;
otb::Utils::ConvertStringToVector(ecef_satellite_pos, vECEF_sat_pos, "ECEF_Satellite_Position", " ");
std::vector<std::string> vECEF_sat_vel;
otb::Utils::ConvertStringToVector(ecef_satellite_vel, vECEF_sat_vel, "ECEF_Satellite_Velocity", " ");
std::vector<Orbit> orbitVector;
// Helper function to convert to a two digit string.
auto formatTimeInt = [](int i) { return (i < 10 ? "0" + std::to_string(i)
: std::to_string(i) );};
auto formatTimeDouble = [](double d) { return (d < 10 ? "0" + std::to_string(d)
: std::to_string(d) );};
std::ostringstream oss;
for (int i = 0; i != stateVectorList_size ; ++i)
{
oss.str("");
oss << stateVectorList_size;
Orbit orbit;
double total_seconds = std::stod(vTimes[i]);
int hour = static_cast<int> (total_seconds/3600.0);
int minutes = static_cast<int> ((total_seconds-hour*3600)/60.0);
double seconds = total_seconds - hour*3600 - minutes*60;
std::string timeStr = reference_UTC + "T" + formatTimeInt(hour) + ":" + formatTimeInt(minutes) + ":" + formatTimeDouble(seconds);
orbit.time = MetaData::ReadFormattedDate(timeStr);
orbit.position[0] = std::stod(vECEF_sat_pos[i*3 + 0]) ;
orbit.position[1] = std::stod(vECEF_sat_pos[i*3 + 1]) ;
orbit.position[2] = std::stod(vECEF_sat_pos[i*3 + 2]) ;
orbit.velocity[0] = std::stod(vECEF_sat_vel[i*3 + 0]) ;
orbit.velocity[1] = std::stod(vECEF_sat_vel[i*3 + 1]) ;
orbit.velocity[2] = std::stod(vECEF_sat_vel[i*3 + 2]) ;
orbitVector.push_back(orbit);
}
return orbitVector;
}
std::vector<BurstRecord> CosmoImageMetadataInterface::CreateBurstRecord(const std::string & firstLineTimeStr, const std::string & lastLineTimeStr, const unsigned long endLine, const unsigned long endSample) const
{
BurstRecord record;
record.startLine = 0;
record.startSample = 0;
record.endLine = endLine;
record.endSample = endSample;
record.azimuthStartTime = MetaData::ReadFormattedDate(firstLineTimeStr, "%Y-%m-%dT%H:%M:%S");
record.azimuthStopTime = MetaData::ReadFormattedDate(lastLineTimeStr, "%Y-%m-%dT%H:%M:%S");
record.azimuthAnxTime = 0.;
return {record};
}
bool not_in(std::vector<std::string> possible_values, std::string test_value)
{
return std::none_of(possible_values.begin(), possible_values.end(), [test_value](std::string s){return s == test_value;});
}
void CosmoImageMetadataInterface::ParseGdal(ImageMetadata & imd)
{
// Check acquisition mode and product type
Fetch(MDStr::Mode, imd, "Acquisition_Mode");
if (not_in({"HIMAGE", "SPOTLIGHT", "ENHANCED SPOTLIGHT"}, imd[MDStr::Mode]))
{
otbGenericExceptionMacro(MissingMetadataException, "Not an expected acquisition mode (only HIMAGE and SPOTLIGHT expected)" << imd[MDStr::Mode] );
}
Fetch(MDStr::ProductType, imd, "Product_Type");
if (not_in({"SCS_B", "SCS_U"}, imd[MDStr::ProductType]))
{
otbGenericExceptionMacro(MissingMetadataException, "Not an expected product type (only SCS_B and SCS_U expected) " << imd[MDStr::ProductType] );
}
imd.Add(MDStr::Mission, "CSK");
imd.Add(MDStr::SensorID, "CSK");
imd.Add(MDStr::Instrument, "SAR-2000");
Fetch(MDStr::OrbitDirection, imd, "Orbit_Direction");
bool hasOrbitNumber ;
std::string orbitNumber = m_MetadataSupplierInterface->GetMetadataValue("Orbit_Number", hasOrbitNumber) ;
imd.Add(MDNum::OrbitNumber, std::stoi(orbitNumber));
bool hasRadarFrequency ;
std::string radarFrequency = m_MetadataSupplierInterface->GetMetadataValue("Radar_Frequency", hasRadarFrequency) ;
imd.Add(MDNum::RadarFrequency, std::stod(radarFrequency));
Fetch(MDStr::Polarization, imd, "S01_Polarisation") ;
imd.Add(MDStr::Swath, "S1");
Fetch(MDNum::PRF, imd, "S01_PRF");
//getTime
auto subDsName = "HDF5:" + m_MetadataSupplierInterface->GetResourceFile() + "://S01/SBI";
auto metadataBands = this->saveMetadataBands(subDsName) ;
bool hasTimeUTC;
int pos = m_MetadataSupplierInterface->GetMetadataValue("Reference_UTC", hasTimeUTC).find(" ");;
std::string reference_UTC = m_MetadataSupplierInterface->GetMetadataValue("Reference_UTC", hasTimeUTC).substr(0, pos);
double total_seconds = std::stod(metadataBands[0]["S01_SBI_Zero_Doppler_Azimuth_First_Time"]);
int hour = static_cast<int> (total_seconds/3600.0);
int minutes = static_cast<int> ((total_seconds-hour*3600)/60.0);
double seconds = total_seconds - hour*3600 - minutes*60;
// Helper function to convert to a two digit string.
auto formatTimeInt = [](int i) { return (i < 10 ? "0" + std::to_string(i)
: std::to_string(i) );};
auto formatTimeDouble = [](double d) { return (d < 10 ? "0" + std::to_string(d)
: std::to_string(d) );};
std::string first_line_time = reference_UTC + "T" + formatTimeInt(hour) + ":" + formatTimeInt(minutes) + ":" + formatTimeDouble(seconds);
total_seconds = std::stod(metadataBands[0]["S01_SBI_Zero_Doppler_Azimuth_Last_Time"]);
hour = static_cast<int> (total_seconds/3600.0);
minutes = static_cast<int> ((total_seconds-hour*3600)/60.0);
seconds = total_seconds - hour*3600 - minutes*60;
std::string last_line_time = reference_UTC + "T" + formatTimeInt(hour) + ":" + formatTimeInt(minutes) + ":" + formatTimeDouble(seconds);
imd.Add(MDTime::AcquisitionStartTime, MetaData::ReadFormattedDate(first_line_time));
imd.Add(MDTime::AcquisitionStopTime, MetaData::ReadFormattedDate(last_line_time));
// Retrieve the product dimension, as it is not stored in the metadata
auto dataset = static_cast<GDALDataset*>(GDALOpen(subDsName.c_str(), GA_ReadOnly));
int sizex = dataset->GetRasterXSize();
int sizey = dataset->GetRasterYSize();
GDALClose(dataset);
//SAR Parameters
SARParam sarParam;
sarParam.orbits = this->getOrbits(reference_UTC);
sarParam.burstRecords = CreateBurstRecord(first_line_time, last_line_time, sizex-1, sizey-1);
auto rangeTimeInterval = std::stod(metadataBands[0]["S01_SBI_Column_Time_Interval"]);
if (!rangeTimeInterval)
{
otbGenericExceptionMacro(MissingMetadataException, "Range time interval is null.");
}
sarParam.rangeSamplingRate = 1 / rangeTimeInterval;
sarParam.azimuthTimeInterval = MetaData::Duration::Seconds(
std::stod(metadataBands[0]["S01_SBI_Line_Time_Interval"]));
sarParam.nearRangeTime = std::stod(metadataBands[0]["S01_SBI_Zero_Doppler_Range_First_Time"]);
auto lookSide = m_MetadataSupplierInterface->GetAs<std::string>("Look_Side");
if (lookSide != "RIGHT" && lookSide != "LEFT")
{
otbGenericExceptionMacro(MissingMetadataException, "Not an expected look side (only RIGHT or LEFT expected)");
}
sarParam.rightLookingFlag = lookSide == "RIGHT";
imd.Add(MDGeom::SAR, sarParam);
// TODO: compute a GCP at the center of scene using the inverse sar model like it is done in ossim plugins
// This require to move IMIs to another higher level module that depends on OTBTransform (which depends
// on OTBMetadata) so that SarSensorModel can be used. (this cannot be done while IMIs still depend on Ossim)
// Add the top left corner as GCP for now
std::istringstream output(metadataBands[0]["S01_SBI_Top_Left_Geodetic_Coordinates"]);
GCP gcp;
output >> gcp.m_GCPY; // lat
output >> gcp.m_GCPX; // lon
output >> gcp.m_GCPZ; // height
gcp.m_GCPRow = 0;
gcp.m_GCPCol = 0;
gcp.m_Id = "1";
Projection::GCPParam gcpParam;
gcpParam.GCPProjection = SpatialReference::FromWGS84().ToWkt();
gcpParam.GCPs.push_back(gcp);
imd.Add(MDGeom::GCP, gcpParam);
SARCalib sarCalib;
std::istringstream("1970-01-01T00:00:00.000000") >> sarCalib.calibrationStartTime;
std::istringstream("1970-01-01T00:00:00.000000") >> sarCalib.calibrationStopTime;
LoadRadiometricCalibrationData(sarCalib, *m_MetadataSupplierInterface, imd);
imd.Add(MDGeom::SARCalib, sarCalib);
}
void CosmoImageMetadataInterface::ParseGeom(ImageMetadata &imd)
{
// Check acquisition mode and product type
Fetch(MDStr::Mode, imd, "support_data.acquisition_mode");
if(not_in({"HIMAGE", "SPOTLIGHT", "ENHANCED SPOTLIGHT"}, imd[MDStr::Mode]))
{
otbGenericExceptionMacro(MissingMetadataException, << "Not an expected acquisition mode (only HIMAGE and SPOTLIGHT expected)" << imd[MDStr::Mode] );
}
Fetch(MDStr::ProductType, imd, "support_data.product_type");
if(not_in({"SCS_B", "SCS_U"}, imd[MDStr::ProductType]))
{
otbGenericExceptionMacro(MissingMetadataException, << "Not an expected product type (only SCS_B and SCS_U expected) " << imd[MDStr::ProductType] );
}
imd.Add(MDStr::Mission, "CSK");
imd.Add(MDStr::SensorID, "CSK");
imd.Add(MDStr::Instrument, "SAR-2000");
Fetch(MDStr::OrbitDirection, imd, "support_data.orbit_pass");
Fetch(MDNum::OrbitNumber, imd, "support_data.abs_orbit");
Fetch(MDNum::RadarFrequency, imd, "support_data.radar_frequency");
Fetch(MDStr::Polarization, imd, "header.polarisation");
imd.Add(MDStr::Swath, "S1");
Fetch(MDNum::PRF, imd, "support_data.pulse_repetition_frequency");
Fetch(MDTime::AcquisitionStartTime, imd, "header.first_line_time");
Fetch(MDTime::AcquisitionStopTime, imd, "header.last_line_time");
//SAR Parameters
SARParam sarParam;
sarParam.orbits = this->GetOrbitsGeom();
imd.Add(MDGeom::SAR, sarParam);
SARCalib sarCalib;
LoadRadiometricCalibrationData(sarCalib, *m_MetadataSupplierInterface, imd);
imd.Add(MDGeom::SARCalib, sarCalib);
}
void CosmoImageMetadataInterface::Parse(ImageMetadata & imd)
{
assert(m_MetadataSupplierInterface != nullptr && "In ImageMetadataInterface, the MetadataSupplier needs to be set before calling the Parse function.");
// Try to fetch the metadata from GDAL Metadata Supplier
if (m_MetadataSupplierInterface->GetAs<std::string>("", "MISSION_ID") == "CSK")
this->ParseGdal(imd);
// Try to fetch the metadata from GEOM file
else if (m_MetadataSupplierInterface->GetAs<std::string>("", "sensor") == "CSK")
this->ParseGeom(imd);
// Failed to fetch the metadata
else
otbGenericExceptionMacro(MissingMetadataException,
<< "Not a CosmoSkyMed product");
// Default display
imd.Add(MDNum::RedDisplayChannel, 0);
imd.Add(MDNum::GreenDisplayChannel, 0);
imd.Add(MDNum::BlueDisplayChannel, 0);
}
} // end namespace otb
| 5,293 |
3,049 | import logging
import numpy as np
logger = logging.getLogger(__name__)
class ImageNetCombiner(object):
def aggregate(self, Xs, features_names):
print("ImageNet Combiner aggregate called")
logger.debug(Xs)
return (np.reshape(Xs[0],(1,-1)) + np.reshape(Xs[1], (1,-1)))/2.0
| 126 |
2,570 | <reponame>macneek/tensorflow-without-a-phd
# Copyright 2018 Google LLC
#
# 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.
# Generates 20x20 background tiles from the 88 500x500 background tiles
# in sample_data/USGS_public_domain/tr* into output file backgrounds.pklz
# Default settings: 20x20px output tiles, 5px overlap between adjacent tiles
# 1.5x zoom out until source 500x500 tile is fully used, 45° rotations.
# Can generate as many as 711,000 tiles with these settings.
# To generate fewer tiles, use the skip setting. With skip=13, only one tile out of 13
# will be generated. No skipping with skip=1.
import gzip
import pickle
import numpy as np
from PIL import Image
from PIL import ImageStat
from trainer import boxscan
def genBackgrounds(filename):
with gzip.open(filename, mode='wb') as d:
result = {"data":[], "labels": []}
imcount = 0
for file_n in range(1, 89):
loadfilename = "sample_data/USGS_public_domain/tr" + str(file_n) + ".png"
print(loadfilename)
tile_size = 20
step_size = 15 # 1/4 image overlap
zoom_step = 1.5
skip = 3
with Image.open(loadfilename) as im:
i = 0
for angle in range(0, 360, 45):
print("rotation angle: " + str(angle))
rot_im = im.rotate(angle, expand=True, resample=Image.BILINEAR)
for box in boxscan.genBox(rot_im.width, rot_im.height, tile_size, step_size, zoom_step, skip):
im2 = rot_im.crop(box)
# outfilename = "sample_data/USGS_public_domain/processed/tr{}_{:05d}.png".format(file_n, i)
im2 = im2.resize([tile_size, tile_size], resample=Image.BICUBIC)
pixmean = sum(ImageStat.Stat(im2).mean)
if pixmean > 300: # to eliminate black images with no info in the (rotation background)
data = np.asarray([im2.getdata(band=0), im2.getdata(band=1), im2.getdata(band=2)], dtype=np.uint8)
data = np.reshape(data, [-1]) # to get it in exactly the same format as planesnet data
result["data"].append(data)
result["labels"].append(0) # not an airplane
# im2.save(outfilename)
i += 1
imcount +=1
result["data"] = np.asarray(result["data"]) # to get it in exactly the same format as planesnet data
pickle.dump(result, d)
print("Saved {} background images to file {}".format(imcount, filename))
if __name__ == '__main__':
genBackgrounds("backgrounds.pklz") | 1,395 |
480 | /*
* Copyright [2013-2021], Alibaba Group Holding Limited
*
* 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.
*/
package com.alibaba.polardbx.group.jdbc;
import com.alibaba.polardbx.atom.TAtomDataSource;
import com.alibaba.polardbx.common.TddlConstants;
import com.alibaba.polardbx.common.utils.GeneralUtil;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
/**
* <pre>
*
* 封装了dataSource的lazyInit逻辑的DataSourceWrapper,
* 当真正需要使用数据源时，就会触发真正的数据源初始化逻辑，
* 主要用于主备切换场景
*
*
* 使用场景：
* 在主备切换（特别是过程中是有更新dbKey的情况），会造成新库的重新初始化，
*
* 库在初始化过程中可能会出错，为避免因为数据源的初始化出错导致主备切换的新的主备信息无法生效，
* 将所有在初始化过程中出错的新的dbKey改为lazyInit模式，保留在应用真正查询数据库再重新进行初始化
* </pre>
*
* @author chenghui.lch 2017年1月20日 下午2:52:29
* @since 5.0.0
*/
public class DataSourceLazyInitWrapper extends DataSourceWrapper {
/**
* 实际的数据源获取器，lazyInit的关键对象
*/
protected DataSourceFetcher fetcher;
public DataSourceLazyInitWrapper(String dataSourceKey, String weightStr, DataSourceFetcher fetcher,
int dataSourceIndex) {
super(dataSourceKey, weightStr, null, dataSourceIndex);
this.fetcher = fetcher;
this.isInited = false;
}
@Override
protected void doInit() {
if (wrappedDataSource == null) {
wrappedDataSource = fetcher.getDataSource(this.dbKey);
if (wrappedDataSource != null) {
if (weight.a > 0) {
wrappedDataSource.setDsModeInGroupKey(TddlConstants.DS_MODE_AP);
} else {
wrappedDataSource.setDsModeInGroupKey(null);
}
}
}
}
protected TAtomDataSource getDataSourceInner() {
try {
if (wrappedDataSource == null) {
if (!isInited) {
init();
}
}
return wrappedDataSource;
} catch (Throwable e) {
// 物理数据源初始化失败， 则直接报错
throw GeneralUtil.nestedException(e);
}
}
@Override
public TAtomDataSource getWrappedDataSource() {
return getDataSourceInner();
}
@Override
public Connection getConnection() throws SQLException {
return getDataSourceInner().getConnection();
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
return getDataSourceInner().getConnection(username, password);
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return getDataSourceInner().getLogWriter();
}
@Override
public int getLoginTimeout() throws SQLException {
return getDataSourceInner().getLoginTimeout();
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
getDataSourceInner().setLogWriter(out);
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
getDataSourceInner().setLoginTimeout(seconds);
}
}
| 1,780 |
5,937 | <gh_stars>1000+
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
#pragma once
/////////////////////////////////////////////////////////////////////////////
template<class ENTRY_TYPE, const int INITIAL_COUNT>
class CPbPreallocArray
{
public:
/////////////////////////////////////////////////////////////////////////
CPbPreallocArray()
{
m_cCurrent = 0;
m_cAllocated = INITIAL_COUNT;
m_pa = m_aInitial;
};
/////////////////////////////////////////////////////////////////////////
~CPbPreallocArray()
{
if (m_pa != NULL &&
m_pa != m_aInitial)
{
delete m_pa;
}
};
/////////////////////////////////////////////////////////////////////////
inline INT GetSize()
{
return m_cCurrent;
};
/////////////////////////////////////////////////////////////////////////
HRESULT SetSize(INT cNew, BOOL fGrowFast = TRUE)
{
DHR;
CHR(EnsureSize(cNew, fGrowFast));
m_cCurrent = cNew;
CLEANUP:
RHR;
}
/////////////////////////////////////////////////////////////////////////
HRESULT Add(__out INT * pidxNew, BOOL fGrowFast = TRUE)
{
DHR;
ASSERT (pidxNew);
// Make sure we don't overflow UINT (GetSize() + 1 < MAXINT). If we do handle as out of memory error.
CHR_MEMALLOC(GetSize() < (~(UINT)0) ? 1 /*not NULL*/ : NULL);
CHR(SetSize(GetSize() + 1, fGrowFast));
*pidxNew = GetSize() - 1;
CLEANUP:
RHR;
}
/////////////////////////////////////////////////////////////////////////
HRESULT Add(ENTRY_TYPE entry, BOOL fGrowFast = TRUE)
{
DHR;
INT idxNew;
CHR(Add(&idxNew));
(*this)[idxNew] = entry;
CLEANUP:
RHR;
}
/////////////////////////////////////////////////////////////////////////
__out ENTRY_TYPE & operator[](UINT idx)
{
ASSERT (idx < m_cCurrent);
return m_pa[idx];
}
/////////////////////////////////////////////////////////////////////////
__out ENTRY_TYPE * GetData()
{
ASSERT (m_pa);
return m_pa;
}
/////////////////////////////////////////////////////////////////////////
HRESULT Remove(UINT idx)
{
DHR;
ASSERT (0 <= idx && idx < m_cCurrent);
if (idx < m_cCurrent - 1)
{
UINT cbToCopy = sizeof(m_pa[0]) * (m_cCurrent - idx - 1);
ASSERT (sizeof(m_pa[0]) * 1 <= cbToCopy && cbToCopy <= sizeof(m_pa[0]) * (m_cCurrent - 1));
CopyMemory(&(m_pa[idx]), &(m_pa[idx + 1]), cbToCopy);
}
m_cCurrent--;
RHR;
}
/////////////////////////////////////////////////////////////////////////
protected:
/////////////////////////////////////////////////////////////////////////
HRESULT EnsureSize(UINT cRequested, BOOL fGrowFast)
{
DHR;
if (m_cAllocated < cRequested)
{
if (fGrowFast)
cRequested = max(m_cAllocated * 2, cRequested);
ASSERT (m_pa != NULL);
// Make sure we don't overflow byte count (cRequested * sizeof(ENTRY_TYPE)). If we do handle as out of memory error.
CHR_MEMALLOC(cRequested <= ((~(UINT)0) / (sizeof(ENTRY_TYPE))) ? 1 /*not NULL*/ : NULL);
if (m_pa == m_aInitial)
{
CHR_MEMALLOC(m_pa = new ENTRY_TYPE[cRequested]);
CopyMemory(m_pa, m_aInitial, sizeof(m_pa[0]) * m_cAllocated);
}
else
{
ENTRY_TYPE * paNew = (ENTRY_TYPE*)realloc(m_pa, sizeof(m_pa[0]) * cRequested);
CHR_MEMALLOC(paNew);
m_pa = paNew;
}
m_cAllocated = cRequested;
}
CLEANUP:
RHR;
}
/////////////////////////////////////////////////////////////////////////
protected:
ENTRY_TYPE m_aInitial[INITIAL_COUNT];
ENTRY_TYPE* m_pa;
UINT m_cAllocated;
UINT m_cCurrent;
};
/////////////////////////////////////////////////////////////////////////////
#ifdef DBG
void TestPbPreallocArray();
#endif
| 1,834 |
1,531 | /**
* Common utility classes.
*/
package net.grinder.util;
| 19 |
647 | <filename>trick_source/sim_services/VariableServer/VariableServerThread_write_stdio.cpp
#include "trick/VariableServer.hh"
#include "trick/variable_server_message_types.h"
#include "trick/tc_proto.h"
int Trick::VariableServerThread::write_stdio(int stream, std::string text) {
char header[16] ;
sprintf(header, "%-2d %1d %8d\n" , VS_STDIO, stream , (int)text.length()) ;
tc_write(&connection , (char *) header , strlen(header)) ;
tc_write(&connection , (char *) text.c_str() , text.length()) ;
return 0 ;
}
| 196 |
16,989 | <filename>src/main/cpp/util/path_posix.cc
// Copyright 2018 The Bazel Authors. 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.
#include "src/main/cpp/util/path_platform.h"
#include <limits.h> // PATH_MAX
#include <stdlib.h> // getenv
#include <string.h> // strncmp
#include <unistd.h> // access, open, close, fsync
#include "src/main/cpp/util/errors.h"
#include "src/main/cpp/util/exit_code.h"
#include "src/main/cpp/util/file_platform.h"
#include "src/main/cpp/util/logging.h"
#include "src/main/cpp/util/path.h"
namespace blaze_util {
std::string ConvertPath(const std::string &path) { return path; }
std::string PathAsJvmFlag(const std::string &path) { return path; }
bool CompareAbsolutePaths(const std::string &a, const std::string &b) {
return a == b;
}
std::pair<std::string, std::string> SplitPath(const std::string &path) {
size_t pos = path.rfind('/');
// Handle the case with no '/' in 'path'.
if (pos == std::string::npos) return std::make_pair("", path);
// Handle the case with a single leading '/' in 'path'.
if (pos == 0)
return std::make_pair(std::string(path, 0, 1), std::string(path, 1));
return std::make_pair(std::string(path, 0, pos), std::string(path, pos + 1));
}
bool IsDevNull(const char *path) {
return path != nullptr && *path != 0 && strncmp("/dev/null\0", path, 10) == 0;
}
bool IsRootDirectory(const std::string &path) {
return path.size() == 1 && path[0] == '/';
}
bool IsRootDirectory(const Path &path) {
return IsRootDirectory(path.AsNativePath());
}
bool IsAbsolute(const std::string &path) {
return !path.empty() && path[0] == '/';
}
std::string MakeAbsolute(const std::string &path) {
if (blaze_util::IsAbsolute(path) || path.empty()) {
return path;
}
return JoinPath(blaze_util::GetCwd(), path);
}
std::string ResolveEnvvars(const std::string &path) {
std::string result = path;
size_t start = 0;
while ((start = result.find("${", start)) != std::string::npos) {
// Just match to the next }
size_t end = result.find('}', start + 1);
if (end == std::string::npos) {
BAZEL_DIE(blaze_exit_code::LOCAL_ENVIRONMENTAL_ERROR)
<< "ResolveEnvvars(" << path << "): incomplete variable at position "
<< start;
}
// Extract the variable name
const std::string name = result.substr(start + 2, end - start - 2);
// Get the value from the environment
const char *c_value = getenv(name.c_str());
const std::string value = std::string(c_value ? c_value : "");
result.replace(start, end - start + 1, value);
start += value.length();
}
return result;
}
std::string MakeAbsoluteAndResolveEnvvars(const std::string &path) {
return MakeAbsolute(ResolveEnvvars(path));
}
static std::string NormalizeAbsPath(const std::string &p) {
if (p.empty() || p[0] != '/') {
return "";
}
typedef std::string::size_type index;
std::vector<std::pair<index, index> > segments;
for (index s = 0; s < p.size();) {
index e = p.find_first_of('/', s);
if (e == std::string::npos) {
e = p.size();
}
if (e > s) {
if (p.compare(s, e - s, "..") == 0) {
if (!segments.empty()) {
segments.pop_back();
}
} else if (p.compare(s, e - s, ".") != 0) {
segments.push_back(std::make_pair(s, e - s));
}
}
s = e + 1;
}
if (segments.empty()) {
return "/";
} else {
std::stringstream r;
for (const auto &s : segments) {
r << "/" << p.substr(s.first, s.second);
}
if (p[p.size() - 1] == '/') {
r << "/";
}
return r.str();
}
}
std::string TestOnly_NormalizeAbsPath(const std::string &s) {
return NormalizeAbsPath(s);
}
Path::Path(const std::string &path)
: path_(NormalizeAbsPath(MakeAbsolute(path))) {}
Path::Path(const std::string &path, std::string *errorText)
: path_(NormalizeAbsPath(MakeAbsolute(path))) {}
bool Path::IsNull() const { return path_ == "/dev/null"; }
bool Path::Contains(const char c) const {
return path_.find_first_of(c) != std::string::npos;
}
bool Path::Contains(const std::string &s) const {
return path_.find(s) != std::string::npos;
}
Path Path::GetRelative(const std::string &r) const {
return Path(JoinPath(path_, r));
}
Path Path::Canonicalize() const { return Path(MakeCanonical(path_.c_str())); }
Path Path::GetParent() const { return Path(SplitPath(path_).first); }
std::string Path::AsPrintablePath() const { return path_; }
std::string Path::AsJvmArgument() const { return path_; }
std::string Path::AsCommandLineArgument() const { return path_; }
} // namespace blaze_util
| 1,912 |
674 | <gh_stars>100-1000
"""passlib.handlers.phpass - PHPass Portable Crypt
phppass located - http://www.openwall.com/phpass/
algorithm described - http://www.openwall.com/articles/PHP-Users-Passwords
phpass context - blowfish, bsdi_crypt, phpass
"""
#=============================================================================
# imports
#=============================================================================
# core
from hashlib import md5
import re
import logging; log = logging.getLogger(__name__)
from warnings import warn
# site
# pkg
from passlib.utils import h64
from passlib.utils.compat import b, bytes, u, uascii_to_str, unicode
import passlib.utils.handlers as uh
# local
__all__ = [
"phpass",
]
#=============================================================================
# phpass
#=============================================================================
class phpass(uh.HasManyIdents, uh.HasRounds, uh.HasSalt, uh.GenericHandler):
"""This class implements the PHPass Portable Hash, and follows the :ref:`password-hash-api`.
It supports a fixed-length salt, and a variable number of rounds.
The :meth:`~passlib.ifc.PasswordHash.encrypt` and :meth:`~passlib.ifc.PasswordHash.genconfig` methods accept the following optional keywords:
:type salt: str
:param salt:
Optional salt string.
If not specified, one will be autogenerated (this is recommended).
If specified, it must be 8 characters, drawn from the regexp range ``[./0-9A-Za-z]``.
:type rounds: int
:param rounds:
Optional number of rounds to use.
Defaults to 19, must be between 7 and 30, inclusive.
This value is logarithmic, the actual number of iterations used will be :samp:`2**{rounds}`.
:type ident: str
:param ident:
phpBB3 uses ``H`` instead of ``P`` for its identifier,
this may be set to ``H`` in order to generate phpBB3 compatible hashes.
it defaults to ``P``.
:type relaxed: bool
:param relaxed:
By default, providing an invalid value for one of the other
keywords will result in a :exc:`ValueError`. If ``relaxed=True``,
and the error can be corrected, a :exc:`~passlib.exc.PasslibHashWarning`
will be issued instead. Correctable errors include ``rounds``
that are too small or too large, and ``salt`` strings that are too long.
.. versionadded:: 1.6
"""
#===================================================================
# class attrs
#===================================================================
#--GenericHandler--
name = "phpass"
setting_kwds = ("salt", "rounds", "ident")
checksum_chars = uh.HASH64_CHARS
#--HasSalt--
min_salt_size = max_salt_size = 8
salt_chars = uh.HASH64_CHARS
#--HasRounds--
default_rounds = 19
min_rounds = 7
max_rounds = 30
rounds_cost = "log2"
#--HasManyIdents--
default_ident = u("$P$")
ident_values = [u("$P$"), u("$H$")]
ident_aliases = {u("P"):u("$P$"), u("H"):u("$H$")}
#===================================================================
# formatting
#===================================================================
#$P$9IQRaTwmfeRo7ud9Fh4E2PdI0S3r.L0
# $P$
# 9
# IQRaTwmf
# eRo7ud9Fh4E2PdI0S3r.L0
@classmethod
def from_string(cls, hash):
ident, data = cls._parse_ident(hash)
rounds, salt, chk = data[0], data[1:9], data[9:]
return cls(
ident=ident,
rounds=h64.decode_int6(rounds.encode("ascii")),
salt=salt,
checksum=chk or None,
)
def to_string(self):
hash = u("%s%s%s%s") % (self.ident,
h64.encode_int6(self.rounds).decode("ascii"),
self.salt,
self.checksum or u(''))
return uascii_to_str(hash)
#===================================================================
# backend
#===================================================================
def _calc_checksum(self, secret):
# FIXME: can't find definitive policy on how phpass handles non-ascii.
if isinstance(secret, unicode):
secret = secret.encode("utf-8")
real_rounds = 1<<self.rounds
result = md5(self.salt.encode("ascii") + secret).digest()
r = 0
while r < real_rounds:
result = md5(result + secret).digest()
r += 1
return h64.encode_bytes(result).decode("ascii")
#===================================================================
# eoc
#===================================================================
#=============================================================================
# eof
#=============================================================================
| 1,773 |
372 | <filename>dgl/ImageBase.hpp
/*
* DISTRHO Plugin Framework (DPF)
* Copyright (C) 2012-2021 <NAME> <<EMAIL>>
*
* 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.
*/
#ifndef DGL_IMAGE_BASE_HPP_INCLUDED
#define DGL_IMAGE_BASE_HPP_INCLUDED
#include "Geometry.hpp"
START_NAMESPACE_DGL
// --------------------------------------------------------------------------------------------------------------------
enum ImageFormat {
kImageFormatNull,
kImageFormatGrayscale,
kImageFormatBGR,
kImageFormatBGRA,
kImageFormatRGB,
kImageFormatRGBA,
};
/**
Base DGL Image class.
This is an Image class that handles raw image data in pixels.
It is an abstract class that provides the common methods to build on top.
Cairo and OpenGL Image classes are based upon this one.
@see Image
*/
class ImageBase
{
protected:
/**
Constructor for a null Image.
*/
ImageBase();
/**
Constructor using raw image data.
@note @a rawData must remain valid for the lifetime of this Image.
*/
ImageBase(const char* rawData, uint width, uint height, ImageFormat format);
/**
Constructor using raw image data.
@note @a rawData must remain valid for the lifetime of this Image.
*/
ImageBase(const char* rawData, const Size<uint>& size, ImageFormat format);
/**
Constructor using another image data.
*/
ImageBase(const ImageBase& image);
public:
/**
Destructor.
*/
virtual ~ImageBase();
/**
Check if this image is valid.
*/
bool isValid() const noexcept;
/**
Check if this image is not valid.
*/
bool isInvalid() const noexcept;
/**
Get width.
*/
uint getWidth() const noexcept;
/**
Get height.
*/
uint getHeight() const noexcept;
/**
Get size.
*/
const Size<uint>& getSize() const noexcept;
/**
Get the raw image data.
*/
const char* getRawData() const noexcept;
/**
Get the image format.
*/
ImageFormat getFormat() const noexcept;
/**
Load image data from memory.
@note @a rawData must remain valid for the lifetime of this Image.
*/
void loadFromMemory(const char* rawData, uint width, uint height, ImageFormat format = kImageFormatBGRA) noexcept;
/**
Load image data from memory.
@note @a rawData must remain valid for the lifetime of this Image.
*/
virtual void loadFromMemory(const char* rawData,
const Size<uint>& size,
ImageFormat format = kImageFormatBGRA) noexcept;
/**
Draw this image at (0, 0) point using the current OpenGL context.
*/
void draw(const GraphicsContext& context);
/**
Draw this image at (x, y) point using the current OpenGL context.
*/
void drawAt(const GraphicsContext& context, int x, int y);
/**
Draw this image at position @a pos using the current OpenGL context.
*/
virtual void drawAt(const GraphicsContext& context, const Point<int>& pos) = 0;
/**
TODO document this.
*/
ImageBase& operator=(const ImageBase& image) noexcept;
bool operator==(const ImageBase& image) const noexcept;
bool operator!=(const ImageBase& image) const noexcept;
protected:
const char* rawData;
Size<uint> size;
ImageFormat format;
};
// --------------------------------------------------------------------------------------------------------------------
END_NAMESPACE_DGL
#endif // DGL_IMAGE_HPP_INCLUDED
| 1,433 |
1,029 | <reponame>d3lta-v/node-lame
/*
* Version numbering for LAME.
*
* Copyright (c) 1999 <NAME>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef LAME_VERSION_H
#define LAME_VERSION_H
/*
* To make a string from a token, use the # operator:
*/
#ifndef STR
# define __STR(x) #x
# define STR(x) __STR(x)
#endif
# define LAME_URL "http://lame.sf.net"
# define LAME_MAJOR_VERSION 3 /* Major version number */
# define LAME_MINOR_VERSION 99 /* Minor version number */
# define LAME_TYPE_VERSION 2 /* 0:alpha 1:beta 2:release */
# define LAME_PATCH_VERSION 5 /* Patch level */
# define LAME_ALPHA_VERSION (LAME_TYPE_VERSION==0)
# define LAME_BETA_VERSION (LAME_TYPE_VERSION==1)
# define LAME_RELEASE_VERSION (LAME_TYPE_VERSION==2)
# define PSY_MAJOR_VERSION 1 /* Major version number */
# define PSY_MINOR_VERSION 0 /* Minor version number */
# define PSY_ALPHA_VERSION 0 /* Set number if this is an alpha version, otherwise zero */
# define PSY_BETA_VERSION 0 /* Set number if this is a beta version, otherwise zero */
#if LAME_ALPHA_VERSION
#define LAME_PATCH_LEVEL_STRING " alpha " STR(LAME_PATCH_VERSION)
#endif
#if LAME_BETA_VERSION
#define LAME_PATCH_LEVEL_STRING " beta " STR(LAME_PATCH_VERSION)
#endif
#if LAME_RELEASE_VERSION
#if LAME_PATCH_VERSION
#define LAME_PATCH_LEVEL_STRING " release " STR(LAME_PATCH_VERSION)
#else
#define LAME_PATCH_LEVEL_STRING ""
#endif
#endif
# define LAME_VERSION_STRING STR(LAME_MAJOR_VERSION) "." STR(LAME_MINOR_VERSION) LAME_PATCH_LEVEL_STRING
#endif /* LAME_VERSION_H */
/* End of version.h */
| 829 |
1,014 | <gh_stars>1000+
{
"IES.L": {
"short_name": "INVINITY ENERGY SYSTEMS PLC ORD",
"long_name": "Invinity Energy Systems plc",
"summary": "Invinity Energy Systems plc manufactures and sells vanadium flow batteries for energy storage applications of businesses, industries, and electricity networks. The company offers off grid energy and grid services. Invinity Energy Systems plc is based in Saint Helier, Jersey.",
"currency": "GBp",
"sector": "Utilities",
"industry": "Utilities - Diversified",
"exchange": "LSE",
"market": "gb_market",
"country": "Jersey",
"state": null,
"city": "Saint Helier",
"zipcode": "JE2 4SZ",
"website": "http://invinity.com",
"market_cap": "Small Cap"
},
"IVVGF": {
"short_name": "INVINITY ENERGY SYSTEMS PLC",
"long_name": "Invinity Energy Systems plc",
"summary": "Invinity Energy Systems plc manufactures and sells vanadium flow batteries for energy storage applications of businesses, industries, and electricity networks. The company offers off grid energy and grid services. Invinity Energy Systems plc is based in Saint Helier, Jersey.",
"currency": "USD",
"sector": "Utilities",
"industry": "Utilities - Diversified",
"exchange": "PNK",
"market": "us_market",
"country": "Jersey",
"state": null,
"city": "Saint Helier",
"zipcode": "JE2 4SZ",
"website": "http://invinity.com",
"market_cap": "Small Cap"
},
"J4Q5.F": {
"short_name": "INVINITY ENER.SYS EO -,50",
"long_name": "Invinity Energy Systems plc",
"summary": "Invinity Energy Systems plc manufactures and sells vanadium flow batteries for energy storage applications of businesses, industries, and electricity networks. The company offers off grid energy and grid services. Invinity Energy Systems plc is based in Saint Helier, Jersey.",
"currency": "EUR",
"sector": "Utilities",
"industry": "Utilities - Diversified",
"exchange": "FRA",
"market": "dr_market",
"country": "Jersey",
"state": null,
"city": "Saint Helier",
"zipcode": "JE2 4SZ",
"website": "http://invinity.com",
"market_cap": "Small Cap"
},
"JEL.L": {
"short_name": "JERSEY ELECTRICITY PLC 'A'ORD 5",
"long_name": "Jersey Electricity plc",
"summary": "Jersey Electricity plc, together with its subsidiaries, engages in the supply, generation, transmission, and distribution of electricity in Jersey, the Channel Islands. The company offers energy solutions and services for enterprises to switch their heating and cooling systems from fossil-based fuels to electric; and building services, including design, installation, and maintenance services, which cover heating systems, electric works, plumbing services, air conditioning, low energy and LED lighting, renewable systems, commercial refrigeration, and maintenance services. It also provides mechanical and electrical building consultancy services for various project, such as serviced houses, hotels, leisure centers, office developments, schools, social housing estates, computer data centers, and retail outlets; designs, maintains, and sells refrigeration and catering equipment; and operates and leases Powerhouse retail park to retailers. In addition, the company offers various electrical appliances, such as cookers, washing machines, dishwashers, fridges, and freezers; small appliances comprising vacuum cleaners, kettles, coffee makers, toasters, blenders, and food processors; TVs, computers, mobile devices, digital cameras, and game consoles; and cooking equipment and accessories through retail shop, as well as online store, powerhouse.je. Further, it engages in the provision of Jenworks, a multi-utility billing engine; and property management business, as well as other businesses, which comprise software development and consulting. The company was founded in 1924 and is headquartered in St Helier, Jersey.",
"currency": "GBp",
"sector": "Utilities",
"industry": "Utilities - Regulated Electric",
"exchange": "LSE",
"market": "gb_market",
"country": "Jersey",
"state": null,
"city": "Saint Helier",
"zipcode": "JE4 8NY",
"website": "http://www.jec.co.uk",
"market_cap": "Small Cap"
}
} | 1,570 |
1,694 | <gh_stars>1000+
//
// Generated by class-dump 3.5 (64 bit) (Debug version compiled Sep 17 2017 16:24:48).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2015 by <NAME>.
//
#import "MMUIViewController.h"
#import "AirKissViewControllerDelegate-Protocol.h"
#import "CNetworkStatusExt-Protocol.h"
#import "IWCDeviceBrandMgrExt-Protocol.h"
@class AirKissConfData, NSString, UIScrollView, UIView, WCDevice;
@interface WCDeviceSearchGuideViewController : MMUIViewController <AirKissViewControllerDelegate, IWCDeviceBrandMgrExt, CNetworkStatusExt>
{
WCDevice *m_device;
AirKissConfData *m_confData;
UIScrollView *m_scrolView;
UIView *m_noWifiOrBLEView;
}
- (void).cxx_destruct;
- (void)onSimCardNetTypeChange;
- (void)ReachabilityChange:(unsigned int)arg1;
- (void)onWCDeviceBlueToothStateChanged:(int)arg1;
- (_Bool)isWifiConnected;
- (_Bool)isBLEConnected;
- (void)updateConnectState;
- (void)onAirKissReturn:(_Bool)arg1;
- (void)onDeviceSearch;
- (void)onAirKiss;
- (void)initNoWifiOrBLEView;
- (void)initGuideView;
- (void)dealloc;
- (void)viewDidLoad;
- (id)initWithFilterUserData:(id)arg1;
// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly, copy) NSString *description;
@property(readonly) unsigned long long hash;
@property(readonly) Class superclass;
@end
| 520 |
1,108 | from dataclasses import dataclass
from jiant.tasks.lib.templates.shared import labels_to_bimap
from jiant.tasks.lib.templates import multiple_choice as mc_template
from jiant.utils.python.io import read_json_lines
@dataclass
class Example(mc_template.Example):
@property
def task(self):
return CommonsenseQATask
@dataclass
class TokenizedExample(mc_template.TokenizedExample):
pass
@dataclass
class DataRow(mc_template.DataRow):
pass
@dataclass
class Batch(mc_template.Batch):
pass
class CommonsenseQATask(mc_template.AbstractMultipleChoiceTask):
Example = Example
TokenizedExample = Example
DataRow = DataRow
Batch = Batch
CHOICE_KEYS = ["A", "B", "C", "D", "E"]
CHOICE_TO_ID, ID_TO_CHOICE = labels_to_bimap(CHOICE_KEYS)
NUM_CHOICES = len(CHOICE_KEYS)
def get_train_examples(self):
return self._create_examples(lines=read_json_lines(self.train_path), set_type="train")
def get_val_examples(self):
return self._create_examples(lines=read_json_lines(self.val_path), set_type="val")
def get_test_examples(self):
return self._create_examples(lines=read_json_lines(self.test_path), set_type="test")
@classmethod
def _create_examples(cls, lines, set_type):
examples = []
for i, line in enumerate(lines):
examples.append(cls._create_example(raw_example=line, set_type=set_type, i=i,))
return examples
@classmethod
def _create_example(cls, raw_example, set_type, i):
# Use heuristic for determining original or HF Datasets format
if isinstance(raw_example["question"], dict):
return cls._create_example_from_original_format(
raw_example=raw_example, set_type=set_type, i=i,
)
elif isinstance(raw_example["question"], str):
return cls._create_example_from_hf_datasets_format(
raw_example=raw_example, set_type=set_type, i=i,
)
else:
raise TypeError(raw_example["question"])
@classmethod
def _create_example_from_original_format(cls, raw_example, set_type, i):
"""Return question and choices from original example format"""
choice_dict = {elem["label"]: elem["text"] for elem in raw_example["question"]["choices"]}
choice_list = [choice_dict[key] for key in cls.CHOICE_KEYS]
return Example(
guid="%s-%s" % (set_type, i),
prompt=raw_example["question"]["stem"],
choice_list=choice_list,
label=raw_example["answerKey"] if set_type != "test" else cls.CHOICE_KEYS[-1],
)
@classmethod
def _create_example_from_hf_datasets_format(cls, raw_example, set_type, i):
"""Return question and choices from HF Datasets example format"""
return Example(
guid="%s-%s" % (set_type, i),
prompt=raw_example["question"],
choice_list=raw_example["choices"]["text"],
label=raw_example["answerKey"] if set_type != "test" else cls.CHOICE_KEYS[-1],
)
| 1,306 |
1,210 | <gh_stars>1000+
# -*- coding: utf-8 -*-
"""
Tencent is pleased to support the open source community by making GameAISDK available.
This source code file is licensed under the GNU General Public License Version 3.
For full details, please refer to the file "LICENSE.txt" which is provided as part of this source code package.
Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
"""
from qtpy import QtCore
from qtpy import QtWidgets
from qtpy import QtGui
from PyQt5.QtGui import QCursor
from PyQt5.QtCore import pyqtSignal
from .tip_dialog import show_warning_tips
class ProjectNewDlg(QtWidgets.QDialog):
# name
finish_new_signal = pyqtSignal(str)
def __init__(self, parent=None):
super(ProjectNewDlg, self).__init__(parent)
self.setWindowTitle("new project")
layout = QtWidgets.QVBoxLayout()
self.name_layout = QtWidgets.QHBoxLayout()
self.label_name = QtWidgets.QLabel(self)
self.label_name.setObjectName("video_label")
self.label_name.setText("name")
self.name_layout.addWidget(self.label_name)
self.edit_name = QtWidgets.QLineEdit()
self.edit_name.setPlaceholderText("project name")
self.edit_name.setFocusPolicy(QtCore.Qt.StrongFocus)
self.name_layout.addWidget(self.edit_name)
layout.addLayout(self.name_layout)
bb = QtWidgets.QDialogButtonBox(
QtWidgets.QDialogButtonBox.Ok | QtWidgets.QDialogButtonBox.Cancel,
QtCore.Qt.Horizontal,
self,
)
bb.button(bb.Ok).setIcon(QtGui.QIcon(":/menu/done.png"))
bb.button(bb.Cancel).setIcon(QtGui.QIcon(":/menu/undo.png"))
bb.accepted.connect(self.check_valid)
bb.rejected.connect(self.reject)
layout.addWidget(bb)
self.setLayout(layout)
self.edit_name.setCursorPosition(2)
def pop_up(self):
self.move(QCursor.pos())
self.exec_()
def check_valid(self):
name = self.edit_name.text()
if len(name) == 0:
show_warning_tips("please input name")
return
self.finish_new_signal.emit(name)
self.accept()
| 991 |
348 | {"nom":"Castineta","dpt":"Haute-Corse","inscrits":54,"abs":38,"votants":16,"blancs":1,"nuls":3,"exp":12,"res":[{"panneau":"1","voix":9},{"panneau":"2","voix":3}]} | 70 |
14,668 | <filename>chrome/browser/enterprise/connectors/file_system/box_upload_file_chunks_handler.cc
// Copyright 2021 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.
#include "chrome/browser/enterprise/connectors/file_system/box_upload_file_chunks_handler.h"
#include "base/base64.h"
#include "base/files/file.h"
#include "base/task/thread_pool.h"
#include "build/build_config.h"
#include "net/base/file_stream.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
namespace {
const uint32_t kOpenFlag = base::File::FLAG_OPEN | base::File::FLAG_READ;
bool CheckChunkSize(const size_t chunks,
const size_t file_size,
const size_t chunk_size,
const size_t bytes_read) {
if (chunks < file_size / chunk_size) {
CHECK_EQ(bytes_read, chunk_size);
} else {
CHECK_GT(bytes_read, 0U);
CHECK_LE(bytes_read, chunk_size);
}
return true;
}
} // namespace
namespace enterprise_connectors {
using FileChunksHandler = BoxChunkedUploader::FileChunksHandler;
FileChunksHandler::FileChunksHandler(const base::FilePath& path,
const size_t file_size,
const size_t chunk_size)
: sequenced_file_(base::ThreadPool::CreateSequencedTaskRunner(
{base::MayBlock(), base::TaskPriority::USER_VISIBLE})),
file_size_(file_size),
chunk_size_(chunk_size) {
sequenced_file_.AsyncCall(&base::File::Initialize).WithArgs(path, kOpenFlag);
}
FileChunksHandler::~FileChunksHandler() = default;
void FileChunksHandler::StartReading(
FilePartiallyReadCallback file_partially_read_cb,
FileCompletelyReadCallback file_completely_read_cb) {
file_partially_read_cb_ = file_partially_read_cb;
file_completely_read_cb_ = std::move(file_completely_read_cb);
CheckFileError(base::BindOnce(&FileChunksHandler::ReadIfValid,
weak_factory_.GetWeakPtr()));
}
void FileChunksHandler::ReadIfValid(FileStatus file_status) {
if (file_status != FileStatus::FILE_OK) {
return OnFileCompletelyRead(file_status);
}
chunk_content_.resize(chunk_size_);
base::SHA1Init(sha1_ctx_);
Read();
}
void FileChunksHandler::Read() {
auto bytes_remaining = file_size_ - byte_to_;
DCHECK_GE(bytes_remaining, 0U);
if (bytes_remaining == 0U) {
return OnFileCompletelyRead(FileStatus::FILE_OK);
} else if (bytes_remaining < chunk_content_.size()) {
chunk_content_.resize(bytes_remaining);
}
byte_from_ = byte_to_;
DCHECK(sequenced_file_);
sequenced_file_.AsyncCall(&base::File::ReadAtCurrentPos)
.WithArgs(&chunk_content_[0U], chunk_content_.size())
.Then(base::BindOnce(&FileChunksHandler::OnFileChunkRead,
weak_factory_.GetWeakPtr()));
}
void FileChunksHandler::OnFileChunkRead(int bytes_read) {
if (bytes_read > 0) {
byte_to_ += bytes_read;
++chunks_read_;
DCHECK(CheckChunkSize(chunks_read_, file_size_, chunk_size_,
static_cast<size_t>(bytes_read)));
DCHECK_EQ(byte_to_, std::min(file_size_, chunks_read_ * chunk_size_));
DCHECK_EQ(static_cast<size_t>(bytes_read), chunk_content_.size())
<< "at " << byte_to_ << " / total " << file_size_ << " bytes";
base::SHA1Update(chunk_content_, sha1_ctx_);
// Everywhere else in this class, byte_to_ is used to verify chunk size and
// bytes already read, exclusive of the last byte read. However, the byte
// ranges used to upload each part's content need to be non-overlapping.
// Therefore, PartInfo::byte_to == byte_to_ = 1.
size_t range_to = byte_to_ - 1;
file_partially_read_cb_.Run(
PartInfo{FileStatus::FILE_OK, chunk_content_, byte_from_, range_to});
} else {
DLOG(ERROR) << "Failed to read file chunk from byte " << byte_from_;
OnFileError(base::BindOnce(&FileChunksHandler::OnFileCompletelyRead,
weak_factory_.GetWeakPtr()),
FileStatus::FILE_ERROR_IO);
}
}
void FileChunksHandler::OnFileCompletelyRead(FileStatus status) {
sequenced_file_.Reset();
if (status != FileStatus::FILE_OK) {
LOG(ERROR) << "Terminating file read due to failure!";
PartInfo info;
info.error = status;
file_partially_read_cb_.Run(std::move(info));
return;
}
DCHECK_EQ(byte_to_, file_size_);
// Finalize the file's SHA-1 digest and format it into base64 encoding as
// required by box API.
base::SHA1Digest sha1_digest;
base::SHA1Final(sha1_ctx_, sha1_digest);
auto digest_str = base::Base64Encode(base::span<const uint8_t>(sha1_digest));
DCHECK(file_completely_read_cb_);
std::move(file_completely_read_cb_).Run(digest_str);
}
void FileChunksHandler::ContinueToReadChunk(size_t n) {
DCHECK_EQ(chunks_read_ + 1, n);
Read();
}
void FileChunksHandler::CheckFileError(FileCheckCallback cb) {
sequenced_file_.AsyncCall(&base::File::IsValid)
.Then(base::BindOnce(&FileChunksHandler::OnFileChecked,
weak_factory_.GetWeakPtr(), std::move(cb)));
}
void FileChunksHandler::OnFileChecked(FileCheckCallback cb,
bool file_valid) {
if (!file_valid) {
LOG(ERROR) << "File is invalid!";
sequenced_file_.AsyncCall(&base::File::error_details)
.Then(base::BindOnce(&FileChunksHandler::OnFileError,
weak_factory_.GetWeakPtr(), std::move(cb)));
} else {
std::move(cb).Run(FileStatus::FILE_OK);
}
}
void FileChunksHandler::OnFileError(FileCheckCallback cb, FileStatus status) {
LOG(ERROR) << "File Error: " << base::File::ErrorToString(status);
sequenced_file_.Reset();
std::move(cb).Run(status);
}
void FileChunksHandler::SkipToOnFileChunkReadForTesting(
std::string content,
int bytes_read,
FilePartiallyReadCallback file_partially_read_cb,
FileCompletelyReadCallback file_completely_read_cb) {
chunk_content_ = content;
file_partially_read_cb_ = file_partially_read_cb;
file_completely_read_cb_ = std::move(file_completely_read_cb);
OnFileChunkRead(bytes_read);
}
} // namespace enterprise_connectors
| 2,511 |
325 | <filename>src/parsers/nop.cc
#include "parser.h"
using namespace wasmdec;
string wasmdec::parsers::nop(Context* ctx, Expression* ex) {
return util::tab(ctx->depth) + "// <Nop expression>\n"; // Nop expressions do nothing
} | 82 |
354 | <gh_stars>100-1000
/***********************************************************************************************************************
* OpenStudio(R), Copyright (c) 2008-2021, Alliance for Sustainable Energy, LLC, and other contributors. 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.
*
* (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission from the respective party.
*
* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
* written permission from Alliance for Sustainable Energy, LLC.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY 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(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, 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.
***********************************************************************************************************************/
#include <gtest/gtest.h>
#include "ModelFixture.hpp"
#include "../Surface.hpp"
#include "../RenderingColor.hpp"
#include "../ScheduleConstant.hpp"
#include "../ConstructionAirBoundary.hpp"
#include "../ConstructionAirBoundary_Impl.hpp"
#include "../../utilities/geometry/Point3d.hpp"
using namespace openstudio;
using namespace openstudio::model;
TEST_F(ModelFixture, ConstructionAirBoundary) {
Model model;
ConstructionAirBoundary construction(model);
EXPECT_EQ(0, construction.getNetArea());
EXPECT_FALSE(construction.setUFactor(0.1));
EXPECT_FALSE(construction.setConductance(10));
EXPECT_FALSE(construction.isOpaque());
EXPECT_FALSE(construction.isFenestration());
EXPECT_FALSE(construction.isSolarDiffusing());
EXPECT_TRUE(construction.isModelPartition());
EXPECT_FALSE(construction.isGreenRoof());
EXPECT_FALSE(construction.uFactor());
EXPECT_FALSE(construction.thermalConductance());
EXPECT_FALSE(construction.heatCapacity());
EXPECT_FALSE(construction.heatCapacity());
EXPECT_FALSE(construction.interiorVisibleAbsorptance());
EXPECT_FALSE(construction.exteriorVisibleAbsorptance());
EXPECT_FALSE(construction.visibleTransmittance());
EXPECT_FALSE(construction.renderingColor());
EXPECT_EQ("None", construction.airExchangeMethod());
EXPECT_EQ(0.0, construction.simpleMixingAirChangesPerHour());
EXPECT_FALSE(construction.renderingColor());
EXPECT_FALSE(construction.simpleMixingSchedule());
EXPECT_TRUE(construction.setAirExchangeMethod("SimpleMixing"));
EXPECT_TRUE(construction.setSimpleMixingAirChangesPerHour(1.0));
RenderingColor color(model);
construction.setRenderingColor(color);
ScheduleConstant schedule(model);
schedule.setValue(0.25);
construction.setSimpleMixingSchedule(schedule);
EXPECT_EQ("SimpleMixing", construction.airExchangeMethod());
EXPECT_EQ(1.0, construction.simpleMixingAirChangesPerHour());
ASSERT_TRUE(construction.renderingColor());
EXPECT_EQ(color.handle(), construction.renderingColor()->handle());
ASSERT_TRUE(construction.simpleMixingSchedule());
EXPECT_EQ(schedule.handle(), construction.simpleMixingSchedule()->handle());
// square with unit area
std::vector<Point3d> points;
points.push_back(Point3d(0, 1, 0));
points.push_back(Point3d(0, 0, 0));
points.push_back(Point3d(1, 0, 0));
points.push_back(Point3d(1, 1, 0));
Surface surface(points, model);
EXPECT_TRUE(surface.setConstruction(construction));
ASSERT_TRUE(surface.construction());
EXPECT_EQ(construction.handle(), surface.construction()->handle());
EXPECT_TRUE(surface.isAirWall());
EXPECT_EQ(1.0, construction.getNetArea());
// DEPRECATED
EXPECT_EQ("GroupedZones", construction.solarAndDaylightingMethod());
EXPECT_EQ("GroupedZones", construction.radiantExchangeMethod());
EXPECT_FALSE(construction.setSolarAndDaylightingMethod("GroupedZones"));
EXPECT_FALSE(construction.setRadiantExchangeMethod("GroupedZones"));
EXPECT_EQ("GroupedZones", construction.solarAndDaylightingMethod());
EXPECT_EQ("GroupedZones", construction.radiantExchangeMethod());
}
| 1,622 |
10,225 | <gh_stars>1000+
package io.quarkus.it.amqp;
import io.quarkus.test.junit.NativeImageTest;
@NativeImageTest
public class AmqpConnectorIT extends AmqpConnectorTest {
}
| 64 |
428 | <filename>Java/Examples/towerdefence(0.5)/src/org/test/towerdefense/StartGameButton.java
package org.test.towerdefense;
import loon.LTexture;
import loon.LTextures;
import loon.action.sprite.SpriteBatch;
import loon.action.sprite.painting.DrawableGameComponent;
import loon.action.sprite.painting.IGameComponent;
import loon.canvas.LColor;
import loon.font.LFont;
import loon.geom.RectBox;
import loon.geom.Vector2f;
import loon.utils.timer.GameTime;
public class StartGameButton extends DrawableGameComponent implements
IGameComponent {
private Vector2f drawPosition;
private LFont font;
private MainGame game;
private LTexture texture;
private String textureFile;
public StartGameButton(MainGame game) {
super(game);
this.drawPosition = new Vector2f(100f, 2f);
this.textureFile = "assets/start.png";
this.game = game;
super.setDrawOrder(40);
}
private RectBox rect = new RectBox();
public final RectBox CentralCollisionArea() {
rect.setBounds(this.drawPosition.x, this.drawPosition.y,
this.texture.getWidth(), this.texture.getHeight());
return rect;
}
@Override
public void draw(SpriteBatch batch, GameTime gameTime) {
batch.draw(this.texture, this.drawPosition, this.game
.getGameplayScreen().getGameOpacity());
Utils.DrawStringAlignCenter(batch, this.font,
"" + LanguageResources.getStart(), this.drawPosition.x + 50f,
this.drawPosition.y + 13f, LColor.white);
super.draw(batch, gameTime);
}
public final void Hide() {
this.drawPosition.y = -300f;
}
@Override
protected void loadContent() {
super.loadContent();
this.texture = LTextures.loadTexture(this.textureFile);
this.font = LFont.getFont(12);
}
public final void Show() {
this.drawPosition.y = 2f;
}
@Override
public void update(GameTime gameTime) {
super.update(gameTime);
}
} | 639 |
731 | package com.webank.weevent.broker.protocol.mqtt.store;
import io.netty.handler.codec.mqtt.MqttQoS;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
/**
* @author websterchen
* @version v1.0
* @since 2019/6/3
*/
@Getter
@Setter
@ToString
public class SubscribeData {
private String clientId;
private MqttQoS mqttQoS;
private String topic;
// always empty
private String groupId;
private String subscriptionId = "";
private String offset = "";
public SubscribeData(String clientId, String topic, MqttQoS mqttQoS) {
this.clientId = clientId;
this.topic = topic;
this.groupId = "";
this.mqttQoS = mqttQoS;
}
// jackson need
private SubscribeData() {
}
}
| 313 |
5,166 | <gh_stars>1000+
//snippet-sourcedescription:[GetBotStatus.java demonstrates how to get the status of an Amazon Lex bot.]
//snippet-keyword:[AWS SDK for Java v2]
//snippet-keyword:[Code Sample]
//snippet-service:[Amazon Lex]
//snippet-sourcetype:[full-example]
//snippet-sourcedate:[09/27/2021]
//snippet-sourceauthor:[scmacdon - aws]
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.example.lex;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.lexmodelbuilding.LexModelBuildingClient;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotRequest;
import software.amazon.awssdk.services.lexmodelbuilding.model.GetBotResponse;
import software.amazon.awssdk.services.lexmodelbuilding.model.LexModelBuildingException;
/**
* To run this Java V2 code example, ensure that you have setup your development environment, including your credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class GetBotStatus {
public static void main(String[] args) {
final String USAGE = "\n" +
"Usage: " +
" <botName> \n\n" +
"Where:\n" +
" botName - the name of an existing bot (for example, BookHotel).\n\n" ;
if (args.length != 1) {
System.out.println(USAGE);
System.exit(1);
}
String botName = args[0];
Region region = Region.US_WEST_2;
LexModelBuildingClient lexClient = LexModelBuildingClient.builder()
.region(region)
.build();
getStatus(lexClient, botName );
lexClient.close();
}
public static void getStatus(LexModelBuildingClient lexClient, String botName ) {
GetBotRequest botRequest = GetBotRequest.builder()
.name(botName)
.versionOrAlias("$LATEST")
.build();
try {
String status = "";
// Loop until the bot is in a ready status
do {
// Wait 5 secs
Thread.sleep(5000);
GetBotResponse response = lexClient.getBot(botRequest);
status = response.statusAsString();
} while (status.compareTo("READY") != 0);
} catch (LexModelBuildingException | InterruptedException e) {
System.out.println(e.getLocalizedMessage());
System.exit(1);
}
}
}
| 1,163 |
357 | <reponame>nicesu/wiki
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100
int place(int k, int x[])
{
int i = 1;
while (i < k)
{
if (x[i] == x[k] || abs(x[i] - x[k]) == abs(i - k))
return 0;
i++;
}
return 1;
}
void N_QUEEN(int n, int x[])
{
x[1] = 0;
int k = 1;
while (k > 0)
{
x[k] += 1;
while (x[k] <= n && !place(k, x))
x[k] += 1;
if (x[k] <= n)
{
if (k == n)
return;
else
{
k++;
x[k] = 0;
}
}
else
k--;
}
}
int main()
{
int x[MAXSIZE];
int n = 8;
N_QUEEN(n, x);
for (int i = 1; i <= n; i++)
{
printf("%d\n", x[i]);
}
system("pause");
return 0;
} | 375 |
3,589 | package picocli.examples.mixin;
import picocli.CommandLine.Command;
import picocli.CommandLine.Option;
@Command(footer = "Common footer")
public class CommonOption {
@Option(names = "-x", description = "reusable option you want in many commands")
int x;
}
| 87 |
538 | #pragma once
#include "VGMInstrSet.h"
#include "VGMSampColl.h"
#include "VGMRgn.h"
#include "AkaoFormat.h"
#include "Matcher.h"
struct AkaoInstrDatLocation {
uint32_t instrAllOffset;
uint32_t instrDatOffset;
uint32_t startingArticulationId;
uint32_t numArticulations;
AkaoInstrDatLocation() noexcept : instrAllOffset(0), instrDatOffset(0), startingArticulationId(0), numArticulations(0) {}
AkaoInstrDatLocation(uint32_t instrAllOffset, uint32_t instrDatOffset, uint32_t startingArticulationId, uint32_t numArticulations) noexcept
: instrAllOffset(instrAllOffset), instrDatOffset(instrDatOffset), startingArticulationId(startingArticulationId), numArticulations(numArticulations) {}
};
// ************
// AkaoInstrSet
// ************
class AkaoInstrSet final : public VGMInstrSet {
public:
AkaoInstrSet(RawFile *file,
uint32_t length,
AkaoPs1Version version,
uint32_t instrOff,
uint32_t dkitOff,
uint32_t id,
std::wstring name = L"Akao Instrument Bank");
AkaoInstrSet(RawFile *file, uint32_t end_boundary_offset, AkaoPs1Version version, std::set<uint32_t> custom_instrument_addresses, std::set<uint32_t> drum_instrument_addresses, std::wstring name = L"Akao Instrument Bank");
AkaoInstrSet(RawFile *file, uint32_t offset, uint32_t end_boundary_offset, AkaoPs1Version version, std::wstring name = L"Akao Instrument Bank (Dummy)");
bool GetInstrPointers() override;
[[nodiscard]] AkaoPs1Version version() const noexcept { return version_; }
bool bMelInstrs, bDrumKit;
uint32_t instrSetOff;
uint32_t drumkitOff;
uint32_t end_boundary_offset;
std::set<uint32_t> custom_instrument_addresses;
std::set<uint32_t> drum_instrument_addresses;
private:
AkaoPs1Version version_;
};
// *********
// AkaoInstr
// *********
class AkaoInstr: public VGMInstr {
public:
AkaoInstr(AkaoInstrSet *instrSet,
uint32_t offset,
uint32_t length,
uint32_t bank,
uint32_t instrNum,
std::wstring name = L"Instrument");
bool LoadInstr() override;
[[nodiscard]] AkaoInstrSet * instrSet() const noexcept { return reinterpret_cast<AkaoInstrSet*>(this->parInstrSet); }
[[nodiscard]] AkaoPs1Version version() const noexcept { return instrSet()->version(); }
bool bDrumKit;
};
// ***********
// AkaoDrumKit
// ***********
class AkaoDrumKit final : public AkaoInstr {
public:
AkaoDrumKit(AkaoInstrSet *instrSet, uint32_t offset, uint32_t length, uint32_t bank, uint32_t instrNum);
bool LoadInstr() override;
};
// *******
// AkaoRgn
// *******
class AkaoRgn final :
public VGMRgn {
public:
AkaoRgn(VGMInstr *instr, uint32_t offset, uint32_t length = 0, std::wstring name = L"Region");
AkaoRgn(VGMInstr *instr, uint32_t offset, uint32_t length, uint8_t keyLow, uint8_t keyHigh,
uint8_t artIDNum, std::wstring name = L"Region");
bool LoadRgn() override;
unsigned short adsr1; //raw psx ADSR1 value (articulation data)
unsigned short adsr2; //raw psx ADSR2 value (articulation data)
uint8_t artNum;
uint8_t drumRelUnityKey;
};
// ***********
// AkaoSampColl
// ***********
struct AkaoArt {
uint8_t unityKey;
short fineTune;
uint32_t sample_offset;
uint32_t loop_point;
uint16_t ADSR1;
uint16_t ADSR2;
uint32_t artID;
int sample_num;
AkaoArt() : unityKey(0), fineTune(0), sample_offset(0), loop_point(0), ADSR1(0), ADSR2(0), artID(0), sample_num(0){}
};
class AkaoSampColl final :
public VGMSampColl {
public:
AkaoSampColl(RawFile *file, uint32_t offset, AkaoPs1Version version, std::wstring name = L"Akao Sample Collection");
AkaoSampColl(RawFile *file, AkaoInstrDatLocation file_location, std::wstring name = L"Akao Sample Collection");
bool GetHeaderInfo() override;
bool GetSampleInfo() override;
[[nodiscard]] AkaoPs1Version version() const noexcept { return version_; }
[[nodiscard]] static bool IsPossibleAkaoSampColl(RawFile *file, uint32_t offset);
[[nodiscard]] static AkaoPs1Version GuessVersion(RawFile *file, uint32_t offset);
std::vector<AkaoArt> akArts;
uint32_t starting_art_id;
uint16_t sample_set_id;
private:
AkaoPs1Version version_;
uint32_t sample_section_size;
uint32_t nNumArts;
uint32_t arts_offset;
uint32_t sample_section_offset;
AkaoInstrDatLocation file_location;
};
| 1,780 |
2,023 | <gh_stars>1000+
'Toolkit for automatic-differentiation of Python functions'
# Resources for automatic-differentiation:
# https://en.wikipedia.org/wiki/Automatic_differentiation
# https://justindomke.wordpress.com/2009/02/17/
# http://www.autodiff.org/
from __future__ import division
import math
## Dual Number Class #####################################################
class Num(float):
''' The auto-differentiation number class works likes a float
for a function input, but all operations on that number
will concurrently compute the derivative.
Creating Nums
-------------
New numbers are created with: Num(x, dx)
Make constants (not varying with respect to x) with: Num(3.5)
Make variables (that vary with respect to x) with: Num(3.5, 1.0)
The short-cut for Num(3.5, 1.0) is: Var(3.5)
Accessing Nums
--------------
Convert a num back to a float with: float(n)
The derivative is accessed with: n.dx
Or with a the short-cut function: d(n)
Functions of One Variable
-------------------------
>>> f = lambda x: cos(2.5 * x) ** 3
>>> y = f(Var(1.5)) # Evaluate at x=1.5
>>> y # f(1.5)
-0.552497105486732
>>> y.dx # f'(1.5)
2.88631746797551
Partial Derivatives and Gradients of Multi-variable Functions
-------------------------------------------------------------
The tool can also be used to compute gradients of multivariable
functions by making one of the inputs variable and the keeping
the remaining inputs constant:
>>> f = lambda x, y: x*y + sin(x)
>>> f(2.5, 3.5) # Evaluate at (2.5, 3.5)
9.348472144103956
>>> d(f(Var(2.5), 3.5)) # Partial with respect to x
2.6988563844530664
>>> d(f(2.5, Var(3.5))) # Partial with respect to y
2.5
>>> gradient(f, (2.5, 3.5))
(2.6988563844530664, 2.5)
See: https://www.wolframalpha.com/input/?lk=3&i=grad(x*y+%2B+sin(x))
'''
# Tables of Derivatives:
# http://hyperphysics.phy-astr.gsu.edu/hbase/math/derfunc.html
# http://tutorial.math.lamar.edu/pdf/Common_Derivatives_Integrals.pdf
# http://www.nps.edu/Academics/Schools/GSEAS/Departments/Math/pdf_sources/BlueBook27.pdf
# https://www.wolframalpha.com/input/?lk=3&i=d%2Fdx(u(x)%5E(v(x)))
__slots__ = ['dx']
def __new__(cls, value, dx=0.0):
if isinstance(value, cls): return value
inst = float.__new__(cls, value)
inst.dx = dx
return inst
def __add__(u, v):
return Num(float(u) + float(v), d(u) + d(v))
def __sub__(u, v):
return Num(float(u) - float(v), d(u) - d(v))
def __mul__(u, v):
u, v, du, dv = float(u), float(v), d(u), d(v)
return Num(u * v, u * dv + v * du)
def __truediv__(u, v):
u, v, du, dv = float(u), float(v), d(u), d(v)
return Num(u / v, (v * du - u * dv) / v ** 2.0)
def __pow__(u, v):
u, v, du, dv = float(u), float(v), d(u), d(v)
return Num(u ** v,
(v * u ** (v - 1.0) * du if du else 0.0) +
(math.log(u) * u ** v * dv if dv else 0.0))
def __floordiv__(u, v):
return Num(float(u) // float(v), 0.0)
def __mod__(u, v):
u, v, du, dv = float(u), float(v), d(u), d(v)
return Num(u % v, du - u // v * dv)
def __pos__(u):
return u
def __neg__(u):
return Num(-float(u), -d(u))
__radd__ = __add__
__rmul__ = __mul__
def __rsub__(self, other):
return -(self - other)
def __rtruediv__(self, other):
return Num(other) / self
def __rpow__(self, other):
return Num(other) ** self
def __rmod__(u, v):
return Num(v) % u
def __rfloordiv__(self, other):
return Num(other) // self
def __abs__(self):
return self if self >= 0.0 else -self
## Convenience Functions #################################################
Var = lambda x: Num(x, 1.0)
d = lambda x: getattr(x, 'dx', 0.0)
## Math Module Functions and Constants ###################################
sqrt = lambda u: Num(math.sqrt(u), d(u) / (2.0 * math.sqrt(u)))
log = lambda u: Num(math.log(u), d(u) / float(u))
log2 = lambda u: Num(math.log2(u), d(u) / (float(u) * math.log(2.0)))
log10 = lambda u: Num(math.log10(u), d(u) / (float(u) * math.log(10.0)))
log1p = lambda u: Num(math.log1p(u), d(u) / (float(u) + 1.0))
exp = lambda u: Num(math.exp(u), math.exp(u) * d(u))
expm1 = lambda u: Num(math.expm1(u), math.exp(u) * d(u))
sin = lambda u: Num(math.sin(u), math.cos(u) * d(u))
cos = lambda u: Num(math.cos(u), -math.sin(u) * d(u))
tan = lambda u: Num(math.tan(u), d(u) / math.cos(u) ** 2.0)
sinh = lambda u: Num(math.sinh(u), math.cosh(u) * d(u))
cosh = lambda u: Num(math.cosh(u), math.sinh(u) * d(u))
tanh = lambda u: Num(math.tanh(u), d(u) / math.cosh(u) ** 2.0)
asin = lambda u: Num(math.asin(u), d(u) / math.sqrt(1.0 - float(u) ** 2.0))
acos = lambda u: Num(math.acos(u), -d(u) / math.sqrt(1.0 - float(u) ** 2.0))
atan = lambda u: Num(math.atan(u), d(u) / (1.0 + float(u) ** 2.0))
asinh = lambda u: Num(math.asinh(u), d(u) / math.hypot(u, 1.0))
acosh = lambda u: Num(math.acosh(u), d(u) / math.sqrt(float(u) ** 2.0 - 1.0))
atanh = lambda u: Num(math.atanh(u), d(u) / (1.0 - float(u) ** 2.0))
radians = lambda u: Num(math.radians(u), math.radians(d(u)))
degrees = lambda u: Num(math.degrees(u), math.degrees(d(u)))
erf = lambda u: Num(math.erf(u),
2.0 / math.sqrt(math.pi) * math.exp(-(float(u) ** 2.0)) * d(u))
erfc = lambda u: Num(math.erfc(u),
-2.0 / math.sqrt(math.pi) * math.exp(-(float(u) ** 2.0)) * d(u))
hypot = lambda u, v: Num(math.hypot(u, v),
(u * d(u) + v * d(v)) / math.hypot(u, v))
fsum = lambda u: Num(math.fsum(map(float, u)), math.fsum(map(d, u)))
fabs = lambda u: abs(Num(u))
fmod = lambda u, v: Num(u) % v
copysign = lambda u, v: Num(math.copysign(u, v),
d(u) if math.copysign(1.0, float(u) * float(v)) > 0.0 else -d(u))
ceil = lambda u: Num(math.ceil(u), 0.0)
floor = lambda u: Num(math.floor(u), 0.0)
trunc = lambda u: Num(math.trunc(u), 0.0)
pi = Num(math.pi)
e = Num(math.e)
## Backport Python 3 Math Module Functions ###############################
if not hasattr(math, 'isclose'):
math.isclose = lambda x, y, rel_tol=1e-09: abs(x/y - 1.0) <= rel_tol
if not hasattr(math, 'log2'):
math.log2 = lambda x: math.log(x) / math.log(2.0)
## Vector Functions ######################################################
def partial(func, point, index):
''' Partial derivative at a given point
>>> func = lambda x, y: x*y + sin(x)
>>> point = (2.5, 3.5)
>>> partial(func, point, 0) # Partial with respect to x
2.6988563844530664
>>> partial(func, point, 1) # Partial with respect to y
2.5
'''
return d(func(*[Num(x, i==index) for i, x in enumerate(point)]))
def gradient(func, point):
''' Vector of the partial derivatives of a scalar field
>>> func = lambda x, y: x*y + sin(x)
>>> point = (2.5, 3.5)
>>> gradient(func, point)
(2.6988563844530664, 2.5)
See: https://www.wolframalpha.com/input/?lk=3&i=grad(x*y+%2B+sin(x))
'''
return tuple(partial(func, point, index) for index in range(len(point)))
def directional_derivative(func, point, direction):
''' The dot product of the gradient and a direction vector.
Computed directly with a single function call.
>>> func = lambda x, y: x*y + sin(x)
>>> point = (2.5, 3.5)
>>> direction = (1.5, -2.2)
>>> directional_derivative(func, point, direction)
-1.4517154233204006
Same result as separately computing and dotting the gradient:
>>> math.fsum(g * d for g, d in zip(gradient(func, point), direction))
-1.4517154233204002
See: https://en.wikipedia.org/wiki/Directional_derivative
'''
return d(func(*map(Num, point, direction)))
def divergence(F, point):
''' Sum of the partial derivatives of a vector field
>>> F = lambda x, y, z: (x*y+sin(x)+3*x, x-y-5*x, cos(2*x)-sin(y)**2)
>>> divergence(F, (3.5, 2.1, -3.3))
3.163543312709203
# http://www.wolframalpha.com/input/?i=div+%7Bx*y%2Bsin(x)%2B3*x,+x-y-5*x,+cos(2*x)-sin(y)%5E2%7D
>>> x, y, z = (3.5, 2.1, -3.3)
>>> math.cos(x) + y + 2
3.1635433127092036
>>> F = lambda x, y, z: (8 * exp(-x), cosh(z), - y**2)
>>> divergence(F, (2, -1, 4))
-1.0826822658929016
# https://www.youtube.com/watch?v=S2rT2zK2bdo
>>> x, y, z = (2, -1, 4)
>>> -8 * math.exp(-x)
-1.0826822658929016
'''
return math.fsum(d(F(*[Num(x, i==index) for i, x in enumerate(point)])[index])
for index in range(len(point)))
def curl(F, point):
''' Rotation around a vector field
>>> F = lambda x, y, z: (x*y+sin(x)+3*x, x-y-5*x, cos(2*x)-sin(y)**2)
>>> curl(F, (3.5, 2.1, -3.3))
(0.8715757724135881, 1.3139731974375781, -7.5)
# http://www.wolframalpha.com/input/?i=curl+%7Bx*y%2Bsin(x)%2B3*x,+x-y-5*x,+cos(2*x)-sin(y)%5E2%7D
>>> x, y, z = (3.5, 2.1, -3.3)
>>> (-2 * math.sin(y) * math.cos(y), 2 * math.sin(2 * x), -x - 4)
(0.8715757724135881, 1.3139731974375781, -7.5)
# https://www.youtube.com/watch?v=UW4SQz29TDc
>>> F = lambda x, y, z: (y**4 - x**2 * z**2, x**2 + y**2, -x**2 * y * z)
>>> curl(F, (1, 3, -2))
(2.0, -8.0, -106.0)
>>> F = lambda x, y, z: (8 * exp(-x), cosh(z), - y**2)
>>> curl(F, (2, -1, 4))
(-25.289917197127753, 0.0, 0.0)
# https://www.youtube.com/watch?v=S2rT2zK2bdo
>>> x, y, z = (2, -1, 4)
>>> (-(x * y + math.sinh(z)), 0.0, 0.0)
(-25.289917197127753, 0.0, 0.0)
'''
x, y, z = point
_, Fyx, Fzx = map(d, F(Var(x), y, z))
Fxy, _, Fzy = map(d, F(x, Var(y), z))
Fxz, Fyz, _ = map(d, F(x, y, Var(z)))
return (Fzy - Fyz, Fxz - Fzx, Fyx - Fxy)
if __name__ == '__main__':
# River flow example: https://www.youtube.com/watch?v=vvzTEbp9lrc
W = 20 # width of river in meters
C = 0.1 # max flow divided by (W/2)**2
F = lambda x, y=0, z=0: (0.0, C * x * (W - x), 0.0)
for x in range(W+1):
print('%d --> %r' % (x, curl(F, (x, 0.0, 0.0))))
def numeric_derivative(func, x, eps=0.001):
'Estimate the derivative using numerical methods'
y0 = func(x - eps)
y1 = func(x + eps)
return (y1 - y0) / (2.0 * eps)
def test(x_array, *testcases):
for f in testcases:
print(f.__name__.center(40))
print('-' * 40)
for x in map(Var, x_array):
y = f(x)
actual = d(y)
expected = numeric_derivative(f, x, 2**-16)
print('%7.3f %12.4f %12.4f' % (x, actual, expected))
assert math.isclose(expected, actual, rel_tol=1e-5)
print('')
def test_pow_const_base(x):
return 3.1 ** (2.3 * x + 0.4)
def test_pow_const_exp(x):
return (2.3 * x + 0.4) ** (-1.3)
def test_pow_general(x):
return (x / 3.5) ** sin(3.5 * x)
def test_hyperbolics(x):
return 3 * cosh(1/x) + 5 * sinh(x/2.5) ** 2 - 0.7 * tanh(1.7/x) ** 1.5
def test_sqrt(x):
return cos(sqrt(abs(sin(x) + 5)))
def test_conversions(x):
return degrees(x ** 1.5 + 18) * radians(0.83 ** x + 37)
def test_hypot(x):
return hypot(sin(x), cos(1.1 / x))
def test_erf(x):
return (sin(x) * erf(x**0.85 - 3.123) +
cos(x) * erfc(x**0.851 - 3.25))
def test_rounders(x):
return (tan(x) * floor(cos(x**2 + 0.37) * 2.7) +
log(x) * ceil(cos(x**3 + 0.31) * 12.1) * 10.1 +
exp(x) * trunc(sin(x**1.4 + 8.0)) * 1234.567)
def test_inv_trig(x):
return (atan((x - 0.303) ** 2.9 + 0.1234) +
acos((x - 4.1) / 3.113) * 5 +
asin((x - 4.3) / 3.717))
def test_mod(x):
return 137.1327 % (sin(x + 0.3) * 40.123) + cos(x) % 5.753
def test_logs(x):
return log2(fabs(sin(x))) + log10(fabs(cos(x))) + log1p(fabs(tan(x)))
def test_fsum(x):
import random
random.seed(8675309)
data = [Num(random.random()**x, random.random()**x) for i in range(100)]
return fsum(data)
def test_inv_hyperbolics(x):
return (acosh(x**1.1234567 + 0.89) + 3.51 * asinh(x**1.234567 + 8.9) +
atanh(x / 15.0823))
def test_copysign(x):
return (copysign(7.17 * x + 5.11, 1.0) + copysign(4.1 * x, 0.0) +
copysign(8.909 * x + 0.18, -0.0) + copysign(4.321 * x + .12, -1.0) +
copysign(-3.53 * x + 11.5, 1.0) + copysign(-1.4 * x + 2.1, 0.0) +
copysign(-9.089 * x + 0.813, -0.0) + copysign(-1.2347 * x, -1.0) +
copysign(sin(x), x - math.pi))
def test_combined(x):
return (1.7 - 3 * cos(x) ** 2 / sin(3 * x) * 0.1 * exp(+cos(x)) +
sqrt(abs(x - 4.13)) + tan(2.5 * x) * log(3.1 * x**1.5) +
(4.7 * x + 3.1) ** cos(0.43 * x + 8.1) - 2.9 + tan(-x) +
sqrt(radians(log(x) + 1.7)) + e / x + expm1(x / pi))
x_array = [2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5]
tests = [test_combined, test_pow_const_base, test_pow_const_exp,
test_pow_general, test_hyperbolics, test_sqrt, test_copysign,
test_inv_trig, test_conversions, test_hypot, test_rounders,
test_inv_hyperbolics, test_mod, test_logs, test_fsum, test_erf]
test(x_array, *tests)
# Run doctests when the underlying C math library matches the one used to
# generate the code examples (the approximation algorithms vary slightly).
if 2 + math.sinh(4) == 29.289917197127753:
import doctest
print(doctest.testmod())
| 7,300 |
348 | {"nom":"Saint-Maudan","circ":"3ème circonscription","dpt":"Côtes-d'Armor","inscrits":315,"abs":152,"votants":163,"blancs":5,"nuls":2,"exp":156,"res":[{"nuance":"LR","nom":"<NAME>","voix":100},{"nuance":"REM","nom":"<NAME>","voix":56}]} | 95 |
1,927 | package com.bytedance.scenedemo.restore;
import android.os.Bundle;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.TextView;
import android.widget.Toast;
import com.bytedance.scene.Scene;
import com.bytedance.scenedemo.R;
import com.bytedance.scenedemo.utility.ColorUtil;
public class SupportRestoreRootScene extends Scene {
private CheckBox mCheckBox;
private TextView mTextView;
private int mClickCount;
@NonNull
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @NonNull ViewGroup container, @Nullable Bundle savedInstanceState) {
return inflater.inflate(R.layout.layout_support_restore_root_scene, container, false);
}
@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
mCheckBox = view.findViewById(R.id.checkbox);
mTextView = view.findViewById(R.id.textview);
getView().setBackgroundColor(ColorUtil.getMaterialColor(getResources(), 0));
}
@Override
public void onSaveInstanceState(@NonNull Bundle outState) {
super.onSaveInstanceState(outState);
outState.putInt("mClickCount", mClickCount);
}
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
String text = null;
if (savedInstanceState != null) {
text = getString(R.string.case_restore_toast_2);
} else {
text = getString(R.string.case_restore_toast_1);
}
Toast.makeText(requireActivity(), text, Toast.LENGTH_SHORT).show();
if (savedInstanceState != null) {
mClickCount = savedInstanceState.getInt("mClickCount");
}
mCheckBox.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mClickCount++;
showClickCount();
}
});
showClickCount();
}
@Override
public void onViewStateRestored(@Nullable Bundle savedInstanceState) {
super.onViewStateRestored(savedInstanceState);
Toast.makeText(requireActivity(), R.string.case_restore_toast_3, Toast.LENGTH_SHORT).show();
}
private void showClickCount() {
mTextView.setText(getString(R.string.case_restore_click, mClickCount));
}
}
| 1,006 |
4,184 | /*
* File: lrucache.hpp
* Author: <NAME>
*
* Created on June 20, 2013, 5:09 PM
*/
#ifndef _LRUCACHE_HPP_INCLUDED_
#define _LRUCACHE_HPP_INCLUDED_
#include <map>
#include <list>
#include <cstddef>
#include <stdexcept>
#include "optional.hpp"
namespace cache {
template<typename key_t, typename value_t>
class lru_cache {
public:
typedef typename std::pair<key_t, value_t> key_value_pair_t;
typedef typename std::list<key_value_pair_t>::iterator list_iterator_t;
lru_cache(size_t max_size) :
_max_size(max_size) {
}
void put(const key_t& key, const value_t& value) {
auto it = _cache_items_map.find(key);
_cache_items_list.push_front(key_value_pair_t(key, value));
if (it != _cache_items_map.end()) {
_cache_items_list.erase(it->second);
_cache_items_map.erase(it);
}
_cache_items_map[key] = _cache_items_list.begin();
if (_cache_items_map.size() > _max_size) {
auto last = _cache_items_list.end();
last--;
_cache_items_map.erase(last->first);
_cache_items_list.pop_back();
}
}
nonstd::optional<value_t> get(const key_t& key) {
auto it = _cache_items_map.find(key);
if (it == _cache_items_map.end()) {
return nonstd::nullopt;
}
_cache_items_list.splice(_cache_items_list.begin(), _cache_items_list, it->second);
return it->second->second;
}
bool exists(const key_t& key) const {
return _cache_items_map.find(key) != _cache_items_map.end();
}
size_t size() const {
return _cache_items_map.size();
}
void set_max_size(size_t max_size) {
this->_max_size = max_size;
}
void clear() {
this->_cache_items_map.clear();
this->_cache_items_list.clear();
}
private:
std::list<key_value_pair_t> _cache_items_list;
std::map<key_t, list_iterator_t> _cache_items_map;
size_t _max_size;
};
} // namespace cache
#endif /* _LRUCACHE_HPP_INCLUDED_ */
| 817 |
3,705 | #include "chainerx/native/im2col.h"
#include <algorithm>
#include <cstdint>
#include <vector>
#include "chainerx/array.h"
#include "chainerx/array_index.h"
#include "chainerx/backend.h"
#include "chainerx/constant.h"
#include "chainerx/device.h"
#include "chainerx/dims.h"
#include "chainerx/indexable_array.h"
#include "chainerx/indexer.h"
#include "chainerx/kernels/creation.h"
#include "chainerx/macro.h"
#include "chainerx/routines/connection.h"
#include "chainerx/routines/creation.h"
#include "chainerx/scalar.h"
#include "chainerx/shape.h"
#include "chainerx/slice.h"
namespace chainerx {
namespace native {
namespace native_internal {
namespace {
template <typename T, int8_t kKernelNdim>
void Im2ColImpl(
const Array& x,
const Array& out,
const Dims& kernel_size,
const Dims& stride,
const Dims& out_dims,
const Indexer<2>& batch_channel_indexer) {
static constexpr int8_t kInNdim = 2 + kKernelNdim;
static constexpr int8_t kOutNdim = 2 + 2 * kKernelNdim;
CHAINERX_ASSERT(kKernelNdim == static_cast<int8_t>(kernel_size.size()));
CHAINERX_ASSERT(kKernelNdim == static_cast<int8_t>(stride.size()));
CHAINERX_ASSERT(kKernelNdim == static_cast<int8_t>(out_dims.size()));
CHAINERX_ASSERT(kInNdim == x.ndim());
CHAINERX_ASSERT(kOutNdim == out.ndim());
Indexer<kKernelNdim> kernel_indexer{Shape{kernel_size.begin(), kernel_size.end()}};
Indexer<kKernelNdim> out_dims_indexer{Shape{out_dims.begin(), out_dims.end()}};
Indexer<kInNdim> x_indexer{x.shape()};
Indexer<kOutNdim> out_indexer{out.shape()};
IndexableArray<const T, kInNdim> x_iarray{x};
IndexableArray<T, kOutNdim> out_iarray{out};
NdimIndex img_index{kKernelNdim};
auto it_kernel = kernel_indexer.It(0);
auto it_out_dims = out_dims_indexer.It(0);
auto it_x = x_indexer.It(0);
auto it_out = out_indexer.It(0);
for (auto it_batch_channel = batch_channel_indexer.It(0); it_batch_channel; ++it_batch_channel) {
it_x.CopyIndex(it_batch_channel);
it_out.CopyIndex(it_batch_channel);
for (it_kernel.Restart(); it_kernel; ++it_kernel) {
it_out.CopyIndex(it_kernel, 2);
for (it_out_dims.Restart(); it_out_dims; ++it_out_dims) {
for (int i = 0; i < kKernelNdim; ++i) {
img_index.index()[i] = it_out_dims.index()[i] * stride[i] + it_kernel.index()[i];
}
it_x.CopyIndex(img_index, 2);
it_out.CopyIndex(it_out_dims, 2 + kKernelNdim);
out_iarray[it_out] = x_iarray[it_x];
}
}
}
}
} // namespace
Array Im2Col(const Array& x, const Dims& kernel_size, const Dims& stride, const Dims& pad, bool cover_all, Scalar pad_value) {
auto ndim = static_cast<int8_t>(kernel_size.size()); // Number of input image dimensions.
CHAINERX_ASSERT(ndim == static_cast<int8_t>(stride.size()));
CHAINERX_ASSERT(ndim == static_cast<int8_t>(pad.size()));
CHAINERX_ASSERT(ndim + 2 == x.ndim()); // Batch and channel dimensions.
Device& device = x.device();
// Create a padded copy of the input image.
// TODO(hvy): Use the Pad function when implemented.
Shape padded_shape = x.shape();
std::vector<ArrayIndex> unpadded_slice{ArrayIndex{Slice{}}, ArrayIndex{Slice{}}}; // All batch and channel dimensions.
for (int64_t i = 0; i < ndim; ++i) {
padded_shape[i + 2] += pad[i] * 2 + (cover_all ? stride[i] - 1 : 0); // Pad on both sides.
unpadded_slice.emplace_back(Slice{pad[i], pad[i] + x.shape()[i + 2]});
}
Array padded_x = static_cast<int64_t>(pad_value) == int64_t{0} ? Zeros(padded_shape, x.dtype(), device)
: Full(padded_shape, pad_value, x.dtype(), device);
device.backend().CallKernel<CopyKernel>(x, padded_x.At(unpadded_slice));
CHAINERX_ASSERT(ndim + 2 == padded_x.ndim());
// Create the output array.
Dims out_dims; // Number of patches along each axis
for (int8_t i = 0; i < ndim; ++i) {
out_dims.emplace_back(internal::GetConvOutDim(x.shape()[i + 2], kernel_size[i], stride[i], pad[i], cover_all));
CHAINERX_ASSERT(out_dims.back() > 0);
}
CHAINERX_ASSERT(ndim == static_cast<int8_t>(out_dims.size()));
int64_t batch_size = x.shape()[0];
int64_t channels = x.shape()[1];
Shape out_shape{batch_size, channels};
std::copy(kernel_size.begin(), kernel_size.end(), std::back_inserter(out_shape));
std::copy(out_dims.begin(), out_dims.end(), std::back_inserter(out_shape));
Array out = Empty(out_shape, x.dtype(), device);
CHAINERX_ASSERT(ndim * 2 + 2 == out.ndim());
// Write to the output array.
VisitDtype(x.dtype(), [&](auto pt) {
using T = typename decltype(pt)::type;
Indexer<2> batch_channel_indexer{Shape{batch_size, channels}};
static_assert(4 * 2 + 2 == kMaxNdim, "4 is the maximum kernel ndim whose output ndim does not exceed kMaxNdim");
switch (ndim) {
case 0:
Im2ColImpl<T, 0>(padded_x, out, kernel_size, stride, out_dims, batch_channel_indexer);
break;
case 1:
Im2ColImpl<T, 1>(padded_x, out, kernel_size, stride, out_dims, batch_channel_indexer);
break;
case 2:
Im2ColImpl<T, 2>(padded_x, out, kernel_size, stride, out_dims, batch_channel_indexer);
break;
case 3:
Im2ColImpl<T, 3>(padded_x, out, kernel_size, stride, out_dims, batch_channel_indexer);
break;
case 4:
Im2ColImpl<T, 4>(padded_x, out, kernel_size, stride, out_dims, batch_channel_indexer);
break;
default:
CHAINERX_NEVER_REACH(); // Never out.ndim() > kMaxNdim
break;
}
});
return out;
}
} // namespace native_internal
} // namespace native
} // namespace chainerx
| 2,820 |
772 | <reponame>code-dot-org/code-dot-org
{
"fi-FI": {
"data": {
"bubble_choice_description": {
"courseD_bee_nestedLoops8_2021": "Kerää kaikki mesi kukista ja tee hunaja hunajakennoihin. Käytä sisäkkäistä silmukkaa. "
}
}
}
} | 131 |
465 | <filename>ChangeTheme/app/src/main/java/com/mjj/changetheme/activity/SecondActivity.java<gh_stars>100-1000
package com.mjj.changetheme.activity;
import android.os.Bundle;
import android.support.v7.app.ActionBar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.MenuItem;
import com.mjj.changetheme.R;
import com.mjj.changetheme.app.MyAppliction;
public class SecondActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
setTheme(MyAppliction.getThemeResources());
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
ActionBar actionBar = getSupportActionBar();
actionBar.setDisplayHomeAsUpEnabled(true);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()){
case android.R.id.home:
SecondActivity.this.finish();
return true;
}
return super.onOptionsItemSelected(item);
}
}
| 464 |
475 | package org.micro.neural.config.event;
import org.micro.neural.extension.SPI;
/**
* The Event Notify.
*
* @author lry
**/
@SPI("log")
public interface IEventListener {
/**
* The initialize
*
* @param eventConfig {@link EventConfig}
*/
void initialize(EventConfig eventConfig);
/**
* The notify event
*
* @param eventType {@link IEventType}
* @param object parameter
*/
void onEvent(IEventType eventType, Object object);
/**
* The destroy store config
*/
void destroy();
}
| 221 |
552 | #include <iostream>
#include "writer.h"
Writer::Writer()
{ }
void Writer::Write(const std::string msg)
{
std::cout << msg << std::endl;
}
void Writer::WriteLine(const std::string msg)
{
this->Write(msg);
std::cout << std::endl;
}
void Writer::Write(const int number)
{
std::cout << number;
}
void Writer::WriteLine(const int number)
{
std::cout << "Writing number: " << number << std::endl;
} | 166 |
1,863 | //
// 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 NVIDIA 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 ``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.
//
// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#ifndef PX_FOUNDATION_DELAY_LOAD_HOOK
#define PX_FOUNDATION_DELAY_LOAD_HOOK
#include "foundation/PxPreprocessor.h"
/** \addtogroup foundation
@{
*/
#if !PX_DOXYGEN
namespace physx
{
#endif
/**
\brief PxFoundationDelayLoadHook
This is a helper class for delay loading the PxFoundation dll.
If a PxFoundation dll with a non-default file name needs to be loaded,
PxFoundationDelayLoadHook can be sub-classed to provide the custom file names.
Once the names are set, the instance must be set for use by the loading dll.
*/
class PxFoundationDelayLoadHook
{
public:
PxFoundationDelayLoadHook() {}
virtual ~PxFoundationDelayLoadHook() {}
virtual const char* getPxFoundationDEBUGDllName() const = 0;
virtual const char* getPxFoundationCHECKEDDllName() const = 0;
virtual const char* getPxFoundationPROFILEDllName() const = 0;
virtual const char* getPxFoundationDllName() const = 0;
protected:
private:
};
#if !PX_DOXYGEN
} // namespace physx
#endif
/** @} */
#endif
| 838 |
591 | #pragma once
template <typename... Args>
struct sumSizeOfArgs
{
static constexpr size_t totalSize = 0;
};
template <typename T, typename... Args>
struct sumSizeOfArgs<T, Args...>
{
static constexpr size_t totalSize = sizeof(typename std::decay<T>::type) + sumSizeOfArgs<Args...>::totalSize;
};
template <typename T>
struct sumSizeOfArgs<T>
{
static constexpr size_t totalSize = sizeof(typename std::decay<T>::type);
};
template <typename T>
struct function_traits_impl;
template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(ClassType::*)(Args...)>
{
static constexpr size_t arity = sizeof...(Args);
using result_type = ReturnType;
static constexpr size_t totalSize = sumSizeOfArgs<Args...>::totalSize;
using type_list = std::tuple<Args...>;
template <size_t i>
struct arg
{
using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
};
};
template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(ClassType::*)(Args...) const>
: function_traits_impl<ReturnType(ClassType::*)(Args...)> {};
template <typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(Args...)>
{
static constexpr size_t arity = sizeof...(Args);
using result_type = ReturnType;
static constexpr size_t totalSize = sumSizeOfArgs<Args...>::totalSize;
using type_list = std::tuple<Args...>;
template <size_t i>
struct arg
{
using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
};
};
template <typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(*)(Args...)> : function_traits_impl<ReturnType(Args...)> {};
template <typename T, typename V = void>
struct function_traits : function_traits_impl<T> {};
template <typename T>
struct function_traits<T, decltype((void)&T::operator())> : function_traits_impl<decltype(&T::operator())> {}; | 675 |
6,620 | <filename>numba/cuda/tests/cudapy/test_alignment.py
import numpy as np
from numba import from_dtype, cuda
from numba.cuda.testing import skip_on_cudasim, CUDATestCase
import unittest
class TestAlignment(CUDATestCase):
def test_record_alignment(self):
rec_dtype = np.dtype([('a', 'int32'), ('b', 'float64')], align=True)
rec = from_dtype(rec_dtype)
@cuda.jit((rec[:],))
def foo(a):
i = cuda.grid(1)
a[i].a = a[i].b
a_recarray = np.recarray(3, dtype=rec_dtype)
for i in range(a_recarray.size):
a_rec = a_recarray[i]
a_rec.a = 0
a_rec.b = (i + 1) * 123
foo[1, 3](a_recarray)
self.assertTrue(np.all(a_recarray.a == a_recarray.b))
@skip_on_cudasim('Simulator does not check alignment')
def test_record_alignment_error(self):
rec_dtype = np.dtype([('a', 'int32'), ('b', 'float64')])
rec = from_dtype(rec_dtype)
with self.assertRaises(Exception) as raises:
@cuda.jit((rec[:],))
def foo(a):
i = cuda.grid(1)
a[i].a = a[i].b
self.assertTrue('type float64 is not aligned' in str(raises.exception))
if __name__ == '__main__':
unittest.main()
| 655 |
679 | /**************************************************************
*
* 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.
*
*************************************************************/
package complex.dbaccess;
import com.sun.star.sdb.XSingleSelectQueryComposer;
import connectivity.tools.CRMDatabase;
import java.util.logging.Level;
import java.util.logging.Logger;
// ---------- junit imports -----------------
import org.junit.After;
import org.junit.Before;
import static org.junit.Assert.*;
// ------------------------------------------
public abstract class CRMBasedTestCase extends TestCase
{
protected CRMDatabase m_database;
// --------------------------------------------------------------------------------------------------------
protected void createTestCase()
{
try
{
m_database = new CRMDatabase( getMSF(), false );
}
catch ( Exception e )
{
e.printStackTrace( System.err );
fail( "caught an exception (" + e.getMessage() + ") while creating the test case");
}
}
// --------------------------------------------------------------------------------------------------------
@Before
@Override
public void before()
{
createTestCase();
}
// --------------------------------------------------------------------------------------------------------
@After
@Override
public void after()
{
try
{
if ( m_database != null )
{
m_database.saveAndClose();
}
}
catch ( Exception ex )
{
Logger.getLogger( this.getClass().getName() ).log( Level.SEVERE, null, ex );
}
}
// --------------------------------------------------------------------------------------------------------
/** creates a SingleSelectQueryComposer for our connection
*/
protected final XSingleSelectQueryComposer createQueryComposer() throws com.sun.star.uno.Exception
{
return m_database.getConnection().createSingleSelectQueryComposer();
}
}
| 870 |
782 | /*
* Copyright (c) 2021, <NAME>. All Rights Reserved.
*
* This file is part of BoofCV (http://boofcv.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.
*/
package boofcv.alg.fiducial.square;
import boofcv.abst.distort.FDistort;
import boofcv.alg.drawing.FiducialImageGenerator;
import boofcv.alg.drawing.FiducialRenderEngine;
import boofcv.alg.filter.binary.ThresholdImageOps;
import boofcv.alg.misc.PixelMath;
import boofcv.struct.image.GrayU8;
import lombok.Getter;
import lombok.Setter;
/**
* Generates images of square fiducials
*
* @author <NAME>
*/
public class FiducialSquareGenerator extends FiducialImageGenerator {
/** length of the white border surrounding the fiducial */
@Getter @Setter double whiteBorderDoc = 0;
/** length of the black border */
@Getter @Setter double blackBorder = 0.25;
public FiducialSquareGenerator( FiducialRenderEngine renderer ) {
this.renderer = renderer;
}
public void generate( GrayU8 image ) {
renderer.init();
// make sure the image is square and divisible by 8
int s = image.width - (image.width%8);
if (image.width != s || image.height != s) {
GrayU8 tmp = new GrayU8(s, s);
new FDistort(image, tmp).scaleExt().apply();
image = tmp;
}
GrayU8 binary = ThresholdImageOps.threshold(image, null, 125, false);
PixelMath.multiply(binary, 255, binary);
double whiteBorder = whiteBorderDoc/markerWidth;
double X0 = whiteBorder + blackBorder;
double Y0 = whiteBorder + blackBorder;
drawBorder();
// Draw the image inside
draw(image, X0, Y0, 1.0 - X0, 1.0 - Y0);
}
void drawBorder() {
double whiteBorder = whiteBorderDoc/markerWidth;
double X0 = whiteBorder + blackBorder;
double Y0 = whiteBorder + blackBorder;
// top and bottom
rectangle(whiteBorder, whiteBorder, 1.0 - whiteBorder, Y0);
rectangle(whiteBorder, 1.0 - Y0, 1.0 - whiteBorder, 1.0 - whiteBorder);
// left and right sides
rectangle(whiteBorder, Y0, X0, 1.0 - Y0);
rectangle(1.0 - X0, Y0, 1.0 - whiteBorder, 1.0 - Y0);
}
/**
* Renders a binary square fiducial
*
* @param value Value encoded in the fiducial
* @param gridWidth number of cells wide the grid is
*/
public void generate( long value, int gridWidth ) {
renderer.init();
drawBorder();
double whiteBorder = whiteBorderDoc/markerWidth;
double X0 = whiteBorder + blackBorder;
// double Y0 = whiteBorder+blackBorder;
double bw = (1.0 - 2*X0)/gridWidth;
// Draw the black corner used to ID the orientation
square(X0, 1.0 - whiteBorder - blackBorder - bw, bw);
final int bitCount = gridWidth*gridWidth - 4;
for (int j = 0; j < bitCount; j++) {
if ((value & (1L << j)) != 0) {
box(bw, j, gridWidth);
}
}
// int s2 = (int)Math.round(ret.width*borderFraction);
// int s5 = s2+square*(gridWidth-1);
//
// int N = gridWidth*gridWidth-4;
// for (int i = 0; i < N; i++) {
// if( (value& (1<<i)) != 0 )
// continue;
//
// int where = index(i, gridWidth);
// int x = where%gridWidth;
// int y = gridWidth-1-(where/gridWidth);
//
// x = s2 + square*x;
// y = s2 + square*y;
//
// ImageMiscOps.fillRectangle(ret,0xFF,x,y,square,square);
// }
// ImageMiscOps.fillRectangle(ret,0xFF,s2,s2,square,square);
// ImageMiscOps.fillRectangle(ret,0xFF,s5,s5,square,square);
// ImageMiscOps.fillRectangle(ret,0xFF,s5,s2,square,square);
}
private void box( double boxWidth, final int bit, int gridWidth ) {
double whiteBorder = whiteBorderDoc/markerWidth;
double X0 = whiteBorder + blackBorder;
double Y0 = whiteBorder + blackBorder;
int transitionBit0 = gridWidth - 3;
int transitionBit1 = transitionBit0 + gridWidth*(gridWidth - 2);
int transitionBit2 = transitionBit1 + gridWidth - 2;
final int adjustedBit;
if (bit <= transitionBit0)
adjustedBit = bit + 1;
else if (bit <= transitionBit1)
adjustedBit = bit + 2;
else if (bit <= transitionBit2)
adjustedBit = bit + 3;
else
throw new RuntimeException("Bit must be between 0 and " + transitionBit2);
int x = adjustedBit%gridWidth;
int y = gridWidth - (adjustedBit/gridWidth) - 1;
square(X0 + x*boxWidth, Y0 + y*boxWidth, boxWidth);
}
private void draw( GrayU8 image, double x0, double y0, double x1, double y1 ) {
renderer.draw(image, U(x0), U(y0), U(x1), U(y1));
}
private void rectangle( double x0, double y0, double x1, double y1 ) {
renderer.rectangle(U(x0), U(y0), U(x1), U(y1));
}
private void square( double x0, double y0, double width ) {
renderer.square(U(x0), U(y0), U(width));
}
/**
* Convert from fractional unit to document unit
*/
double U( double f ) {
return f*markerWidth;
}
}
| 1,885 |
672 | /*
* Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. The rights granted to you under the License
* may not be used to create, or enable the creation or redistribution of,
* unlawful or unlicensed copies of an Apple operating system, or to
* circumvent, violate, or enable the circumvention or violation of, any
* terms of an Apple operating system software license agreement.
*
* Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
/* @(#)semaphore.h 1.0 2/29/00 */
/*
* semaphore.h - POSIX semaphores
*
* HISTORY
* 29-Feb-00 A.Ramesh at Apple
* Created for Mac OS X
*/
#ifndef _SYS_SEMAPHORE_H_
#define _SYS_SEMAPHORE_H_
typedef int sem_t;
/* this should go in limits.h> */
#define SEM_VALUE_MAX 32767
#define SEM_FAILED ((sem_t *)-1)
#ifndef KERNEL
#include <sys/cdefs.h>
__BEGIN_DECLS
int sem_close(sem_t *);
int sem_destroy(sem_t *) __deprecated;
int sem_getvalue(sem_t * __restrict, int * __restrict) __deprecated;
int sem_init(sem_t *, int, unsigned int) __deprecated;
sem_t * sem_open(const char *, int, ...);
int sem_post(sem_t *);
int sem_trywait(sem_t *);
int sem_unlink(const char *);
int sem_wait(sem_t *) __DARWIN_ALIAS_C(sem_wait);
__END_DECLS
#else /* KERNEL */
void psem_lock_init(void);
void psem_cache_init(void);
#endif /* KERNEL */
#endif /* _SYS_SEMAPHORE_H_ */
| 751 |
1,845 | <filename>examples/blob_blob_table.h
// This table was created to illustrate usage of the table with untyped blobs.
// See `int_str_table.h` for more comments regarding the semantics of creating
// header files for use with C programs.
#ifndef BLOB_BLOB_TABLE_H
#define BLOB_BLOB_TABLE_H
// In C, assignment is not defined for raw arrays, but it is defined for all
// structs, including those containing arrays. Thus, since the hashtable
// requires that assignment is defined for key and mapped types, we wrap the
// blobs in a struct.
typedef struct { char blob[8]; } key_blob;
typedef struct { char blob[255]; } mapped_blob;
#define CUCKOO_TABLE_NAME blob_blob_table
#define CUCKOO_KEY_TYPE key_blob
#define CUCKOO_MAPPED_TYPE mapped_blob
#include <libcuckoo-c/cuckoo_table_template.h>
#endif // BLOB_BLOB_TABLE_H
| 270 |
892 | <reponame>westonsteimel/advisory-database-github
{
"schema_version": "1.2.0",
"id": "GHSA-94xh-5q62-p3f9",
"modified": "2022-05-01T17:53:52Z",
"published": "2022-05-01T17:53:52Z",
"aliases": [
"CVE-2007-1456"
],
"details": "** DISPUTED ** PHP remote file inclusion vulnerability in common.php in PHP Photo Album allows remote attackers to execute arbitrary PHP code via a URL in the db_file parameter. NOTE: CVE disputes this vulnerability, because versions 0.3.2.6 and 0.4.1beta do not contain this file. However, it is possible that the original researcher was referring to a different product.",
"severity": [
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2007-1456"
},
{
"type": "WEB",
"url": "http://securityreason.com/securityalert/2422"
},
{
"type": "WEB",
"url": "http://www.attrition.org/pipermail/vim/2007-March/001432.html"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/archive/1/462559/100/0/threaded"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/archive/1/462802/100/0/threaded"
}
],
"database_specific": {
"cwe_ids": [
],
"severity": "HIGH",
"github_reviewed": false
}
} | 562 |
33,601 | class balanceException(Exception):
pass | 11 |
964 | [
{
"queryName": "Operation Object Without 'produces'",
"severity": "MEDIUM",
"line": 9,
"filename": "positive1.json"
},
{
"queryName": "Operation Object Without 'produces'",
"severity": "MEDIUM",
"line": 7,
"filename": "positive2.yaml"
}
]
| 119 |
321 | /**
* Most of the code in the Qalingo project is copyrighted Hoteia and licensed
* under the Apache License Version 2.0 (release version 0.8.0)
* http://www.apache.org/licenses/LICENSE-2.0
*
* Copyright (c) Hoteia, 2012-2014
* http://www.hoteia.com - http://twitter.com/hoteia - <EMAIL>
*
*/
package org.hoteia.qalingo.core.domain;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Version;
import org.apache.commons.lang.StringUtils;
import org.hibernate.Hibernate;
import org.hoteia.qalingo.core.annotation.CacheEntityInformation;
import org.hoteia.qalingo.core.comparator.CatalogCategoryVirtualComparator;
import org.hoteia.qalingo.core.domain.impl.DomainEntity;
@Entity
@Table(name = "TECO_CATALOG_VIRTUAL_CATEGORY")
@CacheEntityInformation(cacheName="web_cache_catalog_category")
public class CatalogCategoryVirtual extends AbstractCatalogCategory<CatalogVirtual, CatalogCategoryVirtual, CatalogCategoryVirtualAttribute, CatalogCategoryVirtualProductSkuRel> implements DomainEntity {
/**
* Generated UID
*/
private static final long serialVersionUID = 4953461049508842305L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "ID", nullable = false)
private Long id;
@Version
@Column(name = "VERSION", nullable = false) // , columnDefinition = "int(11) default 1"
private int version;
@Column(name = "SCORING", nullable = false) // , columnDefinition = "default 1"
private long scoring;
@Column(name = "CODE", nullable = false)
private String code;
@Column(name = "NAME")
private String name;
@Column(name = "DESCRIPTION")
@Lob
private String description;
@Column(name = "IS_DEFAULT", nullable = false) // , columnDefinition = "tinyint(1) default 0"
private boolean isDefault = false;
@Column(name = "RANKING")
private Integer ranking;
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "VIRTUAL_CATALOG_ID", insertable = true, updatable = true)
private CatalogVirtual catalog;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "PARENT_CATEGORY_ID", insertable = true, updatable = true)
private CatalogCategoryVirtual parentCatalogCategory;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "MASTER_CATEGORY_ID", insertable = true, updatable = true)
private CatalogCategoryMaster categoryMaster;
@OneToMany(fetch = FetchType.LAZY)
@JoinColumn(name = "CATEGORY_ID")
private Set<CatalogCategoryVirtualAttribute> attributes = new HashSet<CatalogCategoryVirtualAttribute>();
@OneToMany(fetch = FetchType.LAZY, cascade=CascadeType.ALL, targetEntity = org.hoteia.qalingo.core.domain.CatalogCategoryVirtual.class)
@JoinColumn(name = "PARENT_CATEGORY_ID")
private Set<CatalogCategoryVirtual> catalogCategories = new HashSet<CatalogCategoryVirtual>();
@OneToMany(fetch = FetchType.LAZY, cascade=CascadeType.ALL, targetEntity = org.hoteia.qalingo.core.domain.CatalogCategoryVirtualProductSkuRel.class)
@JoinColumn(name = "VIRTUAL_CATEGORY_ID")
private Set<CatalogCategoryVirtualProductSkuRel> catalogCategoryProductSkuRels = new HashSet<CatalogCategoryVirtualProductSkuRel>();
@OneToMany(fetch = FetchType.LAZY)
@JoinColumn(name = "VIRTUAL_CATEGORY_ID")
private Set<Asset> assets = new HashSet<Asset>();
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "DATE_CREATE")
private Date dateCreate;
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "DATE_UPDATE")
private Date dateUpdate;
public CatalogCategoryVirtual() {
this.dateCreate = new Date();
this.dateUpdate = new Date();
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public int getVersion() {
return version;
}
public void setVersion(int version) {
this.version = version;
}
public long getScoring() {
return scoring;
}
public void setScoring(long scoring) {
this.scoring = scoring;
}
public String getCode() {
if(categoryMaster != null
&& Hibernate.isInitialized(categoryMaster)){
return categoryMaster.getCode();
}
return code;
}
public void setCode(String code) {
this.code = code;
}
public CatalogCategoryType getCatalogCategoryType() {
if(categoryMaster != null && Hibernate.isInitialized(categoryMaster)
&& Hibernate.isInitialized(categoryMaster.getCatalogCategoryType())){
return categoryMaster.getCatalogCategoryType();
}
return null;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public boolean isDefault() {
return isDefault;
}
public void setDefault(boolean isDefault) {
this.isDefault = isDefault;
}
public Integer getRanking() {
return ranking;
}
public void setRanking(Integer ranking) {
this.ranking = ranking;
}
public CatalogVirtual getCatalog() {
return catalog;
}
public void setCatalog(CatalogVirtual catalog) {
this.catalog = catalog;
}
public boolean isRoot() {
if (getParentCatalogCategory() == null) {
return true;
}
return false;
}
public CatalogCategoryVirtual getParentCatalogCategory() {
return parentCatalogCategory;
}
public void setParentCatalogCategory(CatalogCategoryVirtual parentCatalogCategory) {
this.parentCatalogCategory = parentCatalogCategory;
}
public CatalogCategoryMaster getCategoryMaster() {
return categoryMaster;
}
public void setCategoryMaster(CatalogCategoryMaster categoryMaster) {
this.categoryMaster = categoryMaster;
}
public Set<CatalogCategoryVirtualAttribute> getAttributes() {
return attributes;
}
public void setAttributes(Set<CatalogCategoryVirtualAttribute> attributes) {
this.attributes = attributes;
}
public Set<CatalogCategoryVirtual> getCatalogCategories() {
return catalogCategories;
}
public List<CatalogCategoryVirtual> getSortedChildCatalogCategories() {
List<CatalogCategoryVirtual> sortedCatalogCategories = null;
if (catalogCategories != null
&& Hibernate.isInitialized(catalogCategories)) {
sortedCatalogCategories = new LinkedList<CatalogCategoryVirtual>(catalogCategories);
Collections.sort(sortedCatalogCategories, new CatalogCategoryVirtualComparator());
}
return sortedCatalogCategories;
}
public void setCatalogCategories(Set<CatalogCategoryVirtual> catalogCategories) {
this.catalogCategories = catalogCategories;
}
public Set<CatalogCategoryVirtualProductSkuRel> getCatalogCategoryProductSkuRels() {
return catalogCategoryProductSkuRels;
}
public void setCatalogCategoryProductSkuRels(Set<CatalogCategoryVirtualProductSkuRel> catalogCategoryProductSkuRels) {
this.catalogCategoryProductSkuRels = catalogCategoryProductSkuRels;
}
public List<String> getProductSkuCodes() {
List<String> productSkuCodes = null;
if (catalogCategoryProductSkuRels != null
&& Hibernate.isInitialized(catalogCategoryProductSkuRels)) {
productSkuCodes = new ArrayList<String>();
for (Iterator<CatalogCategoryVirtualProductSkuRel> iterator = catalogCategoryProductSkuRels.iterator(); iterator.hasNext();) {
CatalogCategoryVirtualProductSkuRel catalogCategoryProductSkuRel = (CatalogCategoryVirtualProductSkuRel) iterator.next();
ProductSku productSku = catalogCategoryProductSkuRel.getProductSku();
if(productSku != null){
productSkuCodes.add(catalogCategoryProductSkuRel.getProductSku().getCode());
}
}
}
return productSkuCodes;
}
public List<ProductSku> getSortedProductSkus() {
List<ProductSku> productSkus = null;
List<ProductSku> sortedProductSkus = null;
if (catalogCategoryProductSkuRels != null
&& Hibernate.isInitialized(catalogCategoryProductSkuRels)) {
productSkus = new ArrayList<ProductSku>();
for (Iterator<CatalogCategoryVirtualProductSkuRel> iterator = catalogCategoryProductSkuRels.iterator(); iterator.hasNext();) {
CatalogCategoryVirtualProductSkuRel catalogCategoryVirtualProductSkuRel = (CatalogCategoryVirtualProductSkuRel) iterator.next();
ProductSku productSku = catalogCategoryVirtualProductSkuRel.getProductSku();
if(productSku != null){
productSku.setRanking(catalogCategoryVirtualProductSkuRel.getRanking());
productSkus.add(catalogCategoryVirtualProductSkuRel.getProductSku());
}
}
sortedProductSkus = new LinkedList<ProductSku>(productSkus);
Collections.sort(sortedProductSkus, new Comparator<ProductSku>() {
@Override
public int compare(ProductSku o1, ProductSku o2) {
if (o1 != null && o2 != null) {
return (o1.getRanking() < o2.getRanking() ? -1 : (o1.getRanking() == o2.getRanking() ? 0 : 1));
}
return 0;
}
});
int ranking = 1;
for (Iterator<ProductSku> iterator = sortedProductSkus.iterator(); iterator.hasNext();) {
ProductSku productSku = (ProductSku) iterator.next();
productSku.setRanking(ranking);
ranking++;
}
}
return sortedProductSkus;
}
public List<ProductMarketing> getSortedProductMarketings() {
List<ProductMarketing> productMarketings = null;
List<ProductSku> productSkus = getSortedProductSkus();
if (productSkus != null) {
Map<String, ProductMarketing> mapProductMarketing = new HashMap<String, ProductMarketing>();
int ranking = 1;
for (Iterator<ProductSku> iterator = productSkus.iterator(); iterator.hasNext();) {
ProductSku productSku = (ProductSku) iterator.next();
if (productSku.getProductMarketing() != null
&& Hibernate.isInitialized(productSku.getProductMarketing())) {
if(!mapProductMarketing.containsKey(productSku.getProductMarketing().getCode())){
productSku.getProductMarketing().setRanking(ranking);
mapProductMarketing.put(productSku.getProductMarketing().getCode(), productSku.getProductMarketing());
ranking++;
}
}
}
productMarketings = new ArrayList<ProductMarketing>(mapProductMarketing.values());
}
return productMarketings;
}
public Set<Asset> getAssets() {
return assets;
}
public void setAssets(Set<Asset> assets) {
this.assets = assets;
}
public List<Asset> getAssetsIsGlobal() {
List<Asset> assetsIsGlobal = null;
if (assets != null
&& Hibernate.isInitialized(assets)) {
assetsIsGlobal = new ArrayList<Asset>();
for (Iterator<Asset> iterator = assets.iterator(); iterator.hasNext();) {
Asset asset = (Asset) iterator.next();
if (asset != null && asset.isGlobal()) {
assetsIsGlobal.add(asset);
}
}
}
return assetsIsGlobal;
}
public List<Asset> getAssetsByMarketArea() {
List<Asset> assetsByMarketArea = null;
if (assets != null
&& Hibernate.isInitialized(assets)) {
assetsByMarketArea = new ArrayList<Asset>();
for (Iterator<Asset> iterator = assets.iterator(); iterator.hasNext();) {
Asset asset = (Asset) iterator.next();
if (asset != null && !asset.isGlobal()) {
assetsByMarketArea.add(asset);
}
}
}
return assetsByMarketArea;
}
public Date getDateCreate() {
return dateCreate;
}
public void setDateCreate(Date dateCreate) {
this.dateCreate = dateCreate;
}
public Date getDateUpdate() {
return dateUpdate;
}
public void setDateUpdate(Date dateUpdate) {
this.dateUpdate = dateUpdate;
}
// Attributes
public Object getValue(String attributeCode) {
return getValue(attributeCode, null, null);
}
public Object getValue(String attributeCode, Long marketAreaId, String localizationCode) {
AbstractAttribute attribute = getAttribute(attributeCode, marketAreaId, localizationCode);
if (attribute != null) {
return attribute.getValue();
}
return null;
}
public String getI18nName(String localizationCode) {
String i18nName = (String) getValue(CatalogCategoryMasterAttribute.CATALOG_CATEGORY_ATTRIBUTE_I18N_NAME, null, localizationCode);
if (StringUtils.isEmpty(i18nName)
&& categoryMaster != null && Hibernate.isInitialized(categoryMaster)) {
// FIND MASTER VALUE
i18nName = categoryMaster.getI18nName(localizationCode);
}
if (StringUtils.isEmpty(i18nName)) {
// SET DEFAULT VALUE
i18nName = getName();
}
return i18nName;
}
public String getI18nDescription(String localizationCode) {
String i18Description = (String) getValue(ProductBrandAttribute.CATALOG_CATEGORY_ATTRIBUTE_I18N_DESCRIPTION, null, localizationCode);
if (StringUtils.isEmpty(i18Description)
&& categoryMaster != null && Hibernate.isInitialized(categoryMaster)) {
// FIND MASTER VALUE
i18Description = categoryMaster.getI18nDescription(localizationCode);
}
if (StringUtils.isEmpty(i18Description)) {
// SET DEFAULT VALUE
i18Description = description;
}
return i18Description;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((code == null) ? 0 : code.hashCode());
result = prime * result + ((dateCreate == null) ? 0 : dateCreate.hashCode());
result = prime * result + ((id == null) ? 0 : id.hashCode());
return result;
}
@Override
public boolean equals(Object sourceObj) {
Object obj = deproxy(sourceObj);
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
CatalogCategoryVirtual other = (CatalogCategoryVirtual) obj;
if (code == null) {
if (other.code != null)
return false;
} else if (!code.equals(other.code))
return false;
if (dateCreate == null) {
if (other.dateCreate != null)
return false;
} else if (!dateCreate.equals(other.dateCreate))
return false;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
@Override
public String toString() {
return "CatalogCategoryVirtual [id=" + id + ", version=" + version + ", ranking=" + ranking + ", name=" + name + ", description=" + description + ", code=" + code + ", isDefault=" + isDefault
+ ", dateCreate=" + dateCreate + ", dateUpdate=" + dateUpdate + "]";
}
} | 7,428 |
1,180 | /*
* Copyright(c) 2019 Netflix, Inc.
* Copyright (c) 2016, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 2 Clause License and
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
* was not distributed with this source code in the LICENSE file, you can
* obtain it at https://www.aomedia.org/license/software-license. If the Alliance for Open
* Media Patent License 1.0 was not distributed with this source code in the
* PATENTS file, you can obtain it at https://www.aomedia.org/license/patent-license.
*/
#include "EbDefinitions.h"
#include "EbDecHandle.h"
#include "EbDecUtils.h"
#include "EbDecInverseQuantize.h"
#include "EbDecProcessFrame.h"
#include "EbDecRestoration.h"
#include "EbPictureOperators.h"
#include "EbRestoration.h"
#include "common_dsp_rtcd.h"
void save_tile_row_boundary_lines(uint8_t *src, int32_t src_stride, int32_t src_width,
int32_t src_height, int32_t use_highbd, int32_t plane,
Av1Common *cm, int32_t after_cdef,
RestorationStripeBoundaries *boundaries);
void lr_generate_padding(
EbByte src_pic, //output paramter, pointer to the source picture(0,0).
uint32_t src_stride, //input paramter, the stride of the source picture to be padded.
uint32_t
original_src_width, //input paramter, the width of the source picture which excludes the padding.
uint32_t
original_src_height) //input paramter, the heigth of the source picture which excludes the padding.
{
uint32_t vertical_idx;
EbByte temp_src_pic0;
EbByte temp_src_pic1;
EbByte temp_src_pic2;
EbByte temp_src_pic3;
temp_src_pic0 = src_pic;
for (vertical_idx = original_src_height; vertical_idx > 0; --vertical_idx) {
// horizontal padding
EB_MEMSET(temp_src_pic0 - LR_PAD_SIDE, *temp_src_pic0, LR_PAD_SIDE);
EB_MEMSET(temp_src_pic0 + original_src_width,
*(temp_src_pic0 + original_src_width - 1),
LR_PAD_SIDE);
temp_src_pic0 += src_stride;
}
// vertical padding
temp_src_pic0 = src_pic - LR_PAD_SIDE;
temp_src_pic1 = src_pic + (original_src_height - 1) * src_stride - LR_PAD_SIDE;
temp_src_pic2 = temp_src_pic0;
temp_src_pic3 = temp_src_pic1;
for (vertical_idx = LR_PAD_SIDE; vertical_idx > 0; --vertical_idx) {
// top part data copy
temp_src_pic2 -= src_stride;
svt_memcpy(
temp_src_pic2, temp_src_pic0, sizeof(uint8_t) * (original_src_width + LR_PAD_MAX));
// bottom part data copy
temp_src_pic3 += src_stride;
svt_memcpy(
temp_src_pic3, temp_src_pic1, sizeof(uint8_t) * (original_src_width + LR_PAD_MAX));
}
return;
}
void lr_generate_padding16_bit(
EbByte src_pic, //output paramter, pointer to the source picture to be padded.
uint32_t src_stride, //input paramter, the stride of the source picture to be padded.
uint32_t
original_src_width, //input paramter, the width of the source picture which excludes the padding.
uint32_t
original_src_height) //input paramter, the height of the source picture which excludes the padding.
{
uint32_t vertical_idx;
EbByte temp_src_pic0;
EbByte temp_src_pic1;
EbByte temp_src_pic2;
EbByte temp_src_pic3;
uint8_t use_highbd = 1;
temp_src_pic0 = src_pic;
for (vertical_idx = original_src_height; vertical_idx > 0; --vertical_idx) {
// horizontal padding
memset16bit((uint16_t *)(temp_src_pic0 - (LR_PAD_SIDE << use_highbd)),
((uint16_t *)(temp_src_pic0))[0],
LR_PAD_SIDE);
memset16bit((uint16_t *)(temp_src_pic0 + original_src_width),
((uint16_t *)(temp_src_pic0 + original_src_width - 2 /*1*/))[0],
LR_PAD_SIDE);
temp_src_pic0 += src_stride;
}
// vertical padding
temp_src_pic0 = src_pic - (LR_PAD_SIDE << use_highbd);
temp_src_pic1 = src_pic + (original_src_height - 1) * src_stride - (LR_PAD_SIDE << use_highbd);
temp_src_pic2 = temp_src_pic0;
temp_src_pic3 = temp_src_pic1;
for (vertical_idx = LR_PAD_SIDE; vertical_idx > 0; --vertical_idx) {
// top part data copy
temp_src_pic2 -= src_stride;
svt_memcpy(temp_src_pic2,
temp_src_pic0,
sizeof(uint8_t) * (original_src_width + (LR_PAD_MAX << use_highbd)));
// bottom part data copy
temp_src_pic3 += src_stride;
svt_memcpy(temp_src_pic3,
temp_src_pic1,
sizeof(uint8_t) * (original_src_width + (LR_PAD_MAX << use_highbd)));
}
return;
}
void lr_pad_pic(EbPictureBufferDesc *recon_picture_buf, FrameHeader *frame_hdr,
EbColorConfig *color_cfg) {
FrameSize *frame_size = &frame_hdr->frame_size;
uint8_t sx = color_cfg->subsampling_x;
uint8_t sy = color_cfg->subsampling_y;
if (recon_picture_buf->bit_depth == EB_EIGHT_BIT && (!recon_picture_buf->is_16bit_pipeline)) {
// Y samples
lr_generate_padding(recon_picture_buf->buffer_y + recon_picture_buf->origin_x +
recon_picture_buf->stride_y * recon_picture_buf->origin_y,
recon_picture_buf->stride_y,
frame_size->superres_upscaled_width,
frame_size->frame_height);
if (recon_picture_buf->color_format != EB_YUV400) {
// Cb samples
lr_generate_padding(
recon_picture_buf->buffer_cb + (recon_picture_buf->origin_x >> sx) +
recon_picture_buf->stride_cb * (recon_picture_buf->origin_y >> sy),
recon_picture_buf->stride_cb,
(frame_size->superres_upscaled_width + sx) >> sx,
(frame_size->frame_height + sy) >> sy);
// Cr samples
lr_generate_padding(
recon_picture_buf->buffer_cr + (recon_picture_buf->origin_x >> sx) +
recon_picture_buf->stride_cr * (recon_picture_buf->origin_y >> sy),
recon_picture_buf->stride_cr,
(frame_size->superres_upscaled_width + sx) >> sx,
(frame_size->frame_height + sy) >> sy);
}
} else {
// Y samples
lr_generate_padding16_bit(
recon_picture_buf->buffer_y + (recon_picture_buf->origin_x << 1) +
(recon_picture_buf->stride_y << 1) * recon_picture_buf->origin_y,
recon_picture_buf->stride_y << 1,
frame_size->superres_upscaled_width << 1,
frame_size->frame_height);
if (recon_picture_buf->color_format != EB_YUV400) {
// Cb samples
lr_generate_padding16_bit(
recon_picture_buf->buffer_cb + ((recon_picture_buf->origin_x >> sx) << 1) +
(recon_picture_buf->stride_cb << 1) * (recon_picture_buf->origin_y >> sy),
recon_picture_buf->stride_cb << 1,
((frame_size->superres_upscaled_width + sx) >> sx) << 1,
(frame_size->frame_height + sy) >> sy);
// Cr samples
lr_generate_padding16_bit(
recon_picture_buf->buffer_cr + (recon_picture_buf->origin_x >> sx << 1) +
(recon_picture_buf->stride_cr << 1) * (recon_picture_buf->origin_y >> sy),
recon_picture_buf->stride_cr << 1,
((frame_size->superres_upscaled_width + sx) >> sx) << 1,
(frame_size->frame_height + sy) >> sy);
}
}
}
static const StripeFilterFun stripe_filters[NUM_STRIPE_FILTERS] = {wiener_filter_stripe,
sgrproj_filter_stripe,
wiener_filter_stripe_highbd,
sgrproj_filter_stripe_highbd};
// Filter one restoration unit
// Duplicated to avoid frame level buffer copy ( frame to block level copy)
// and unnecessary block copy based on LR_Type
void svt_dec_av1_loop_restoration_filter_unit(
uint8_t need_bounadaries, const RestorationTileLimits *limits, const RestorationUnitInfo *rui,
const RestorationStripeBoundaries *rsb, RestorationLineBuffers *rlbs,
const Av1PixelRect *tile_rect, int32_t tile_stripe0, int32_t ss_x, int32_t ss_y, int32_t highbd,
int32_t bit_depth, uint8_t *data8, int32_t stride, uint8_t *dst8, int32_t dst_stride,
int32_t *tmpbuf, int32_t optimized_lr) {
RestorationType unit_rtype = rui->restoration_type;
int32_t unit_h = limits->v_end - limits->v_start;
int32_t unit_w = limits->h_end - limits->h_start;
uint8_t *data8_tl = data8 + limits->v_start * stride + limits->h_start;
uint8_t *dst8_tl = dst8;
if (unit_rtype == RESTORE_NONE)
return;
const int32_t filter_idx = 2 * highbd + (unit_rtype == RESTORE_SGRPROJ);
assert(filter_idx < NUM_STRIPE_FILTERS);
const StripeFilterFun stripe_filter = stripe_filters[filter_idx];
const int32_t procunit_width = RESTORATION_PROC_UNIT_SIZE >> ss_x;
// Convolve the whole tile one stripe at a time
RestorationTileLimits remaining_stripes = *limits;
int32_t i = 0;
while (i < unit_h) {
int32_t copy_above, copy_below;
remaining_stripes.v_start = limits->v_start + i;
get_stripe_boundary_info(&remaining_stripes, tile_rect, ss_y, ©_above, ©_below);
const int32_t full_stripe_height = RESTORATION_PROC_UNIT_SIZE >> ss_y;
const int32_t runit_offset = RESTORATION_UNIT_OFFSET >> ss_y;
// Work out where this stripe's boundaries are within
// rsb->stripe_boundary_{above,below}
const int32_t tile_stripe = (remaining_stripes.v_start - tile_rect->top + runit_offset) /
full_stripe_height;
const int32_t frame_stripe = tile_stripe0 + tile_stripe;
const int32_t rsb_row = RESTORATION_CTX_VERT * frame_stripe;
/* Calculate this stripe's height, based on two rules:
The topmost stripe in each tile is 8 luma pixels shorter
than usual. We can't extend past the end of the current
restoration unit */
const int32_t nominal_stripe_height = full_stripe_height -
((tile_stripe == 0) ? runit_offset : 0);
/*In wiener filter leaf level function assumes always h to be multiple of 2.
we can see assert related to h in this function->svt_av1_wiener_convolve_add_src_avx2*/
const int32_t h = AOMMIN(nominal_stripe_height,
((remaining_stripes.v_end - remaining_stripes.v_start) + 1) & ~1);
if (need_bounadaries)
setup_processing_stripe_boundary(&remaining_stripes,
rsb,
rsb_row,
highbd,
h,
data8,
stride,
rlbs,
copy_above,
copy_below,
optimized_lr);
stripe_filter(rui,
unit_w,
h,
procunit_width,
data8_tl + i * stride,
stride,
dst8_tl + i * dst_stride,
dst_stride,
tmpbuf,
bit_depth);
if (need_bounadaries)
restore_processing_stripe_boundary(&remaining_stripes,
rlbs,
highbd,
h,
data8,
stride,
copy_above,
copy_below,
optimized_lr);
i += h;
}
// copy block level dst buffer to src buffer
copy_tile(unit_w, unit_h, dst8_tl, dst_stride, data8_tl, stride, highbd);
}
void dec_av1_loop_restoration_filter_row(EbDecHandle *dec_handle, int32_t sb_row,
uint8_t **rec_buff, int *rec_stride,
Av1PixelRect *tile_rect, int optimized_lr, uint8_t *dst,
int thread_cnt) {
RestorationTileLimits tile_limit;
RestorationUnitInfo *lr_unit;
LrCtxt *lr_ctxt = (LrCtxt *)dec_handle->pv_lr_ctxt;
const int32_t num_planes = av1_num_planes(&dec_handle->seq_header.color_config);
int bit_depth = dec_handle->seq_header.color_config.bit_depth;
int use_highbd = (bit_depth > EB_EIGHT_BIT || dec_handle->is_16bit_pipeline);
int w_y = 0, tile_stripe0 = 0;
int tile_w_y = tile_rect[AOM_PLANE_Y].right - tile_rect[AOM_PLANE_Y].left;
int tile_h_y = tile_rect[AOM_PLANE_Y].bottom - tile_rect[AOM_PLANE_Y].top;
uint8_t dst_stride = RESTORATION_PROC_UNIT_SIZE;
volatile int32_t *sb_lr_completed_in_prev_row = NULL;
int32_t *sb_lr_completed_in_row, nsync = 1;
Bool is_mt = dec_handle->dec_config.threads > 1;
int32_t sb_row_idx = (is_mt == 0) ? 0 : sb_row;
int32_t index = lr_ctxt->is_thread_min ? thread_cnt : sb_row_idx;
if (is_mt) {
DecMtFrameData *dec_mt_frame_data =
&dec_handle->main_frame_buf.cur_frame_bufs[0].dec_mt_frame_data;
if (sb_row) {
sb_lr_completed_in_prev_row =
(volatile int32_t *)&dec_mt_frame_data->sb_lr_completed_in_row[sb_row - 1];
}
sb_lr_completed_in_row = &dec_mt_frame_data->sb_lr_completed_in_row[sb_row];
}
for (int col_y = 0, sb_col_y = 0; col_y < tile_w_y; col_y += w_y, sb_col_y++) {
int remaining_w_y = tile_w_y - col_y;
int proc_width_y = RESTORATION_PROC_UNIT_SIZE;
w_y = (remaining_w_y < proc_width_y) ? remaining_w_y : proc_width_y;
/* Top-Right Sync*/
if (is_mt) {
if (sb_row) {
if (col_y >= tile_w_y - w_y)
nsync = 0;
while (*sb_lr_completed_in_prev_row < (sb_col_y + nsync))
;
}
}
int sx = 0, sy = 0;
uint8_t *src = NULL;
uint32_t src_stride = 0;
for (int32_t plane = 0; plane < num_planes; plane++) {
LrParams *lr_params = &dec_handle->frame_header.lr_params[plane];
if (lr_params->frame_restoration_type == RESTORE_NONE)
continue;
uint16_t lr_size = lr_params->loop_restoration_size;
src = rec_buff[plane];
src_stride = rec_stride[plane];
if (plane) {
sx = dec_handle->seq_header.color_config.subsampling_x;
sy = dec_handle->seq_header.color_config.subsampling_y;
}
int plane_tile_w = (tile_w_y + sx) >> sx;
int plane_tile_h = (tile_h_y + sy) >> sy;
int col = (col_y + sx) >> sx;
int sb_log2 = dec_handle->seq_header.sb_size_log2 - sy;
int16_t sb_size = (1 << sb_log2);
int row = sb_row << sb_log2;
int remaining_h = plane_tile_h - row;
int h = remaining_h < sb_size ? remaining_h : sb_size;
tile_limit.v_start = tile_rect[plane].top + row;
tile_limit.v_end = tile_rect[plane].top + row + h;
assert(tile_limit.v_end <= tile_rect[plane].bottom);
/* Offset the tile upwards to align with
the restoration processing stripe */
const int voffset = RESTORATION_UNIT_OFFSET >> sy;
tile_limit.v_start = AOMMAX(tile_rect[plane].top, tile_limit.v_start - voffset);
if (tile_limit.v_end < tile_rect[plane].bottom)
tile_limit.v_end -= voffset;
int remaining_w = plane_tile_w - col;
//remaining_w = remaining_w >> sx;
int proc_width = RESTORATION_PROC_UNIT_SIZE >> sx;
int block_w = (remaining_w < proc_width) ? remaining_w : proc_width;
tile_limit.h_start = tile_rect[plane].left + col;
tile_limit.h_end = tile_rect[plane].left + col + block_w;
uint8_t lr_size_log2 = lr_params->lr_size_log2;
uint8_t unit_row = row >> lr_size_log2;
uint8_t unit_col = col >> lr_size_log2;
uint8_t lr_size_by_2 = lr_size >> 1;
/* To use previous LR_info, remaining width/height
should be less than 0.5 times of lr_size */
if ((plane_tile_w - (unit_col << lr_size_log2)) < lr_size_by_2)
unit_col = (col < lr_size_by_2) ? 0 : (col - lr_size_by_2) >> lr_size_log2;
if (plane_tile_h - (unit_row << lr_size_log2) < lr_size_by_2)
unit_row = (row < lr_size_by_2) ? 0 : (row - lr_size_by_2) >> lr_size_log2;
// lr_info retrieval
lr_unit = lr_ctxt->lr_unit[plane] + (unit_row * lr_ctxt->lr_stride[plane]) + unit_col;
uint8_t *bdry_cdef = (uint8_t *)lr_ctxt->rlbs[index][plane]->tmp_save_cdef;
uint8_t *bdry_cdef_ptr = bdry_cdef;
uint8_t *bdry_lr = (uint8_t *)lr_ctxt->rlbs[index][plane]->tmp_save_lr;
uint8_t *bdry_lr_ptr = bdry_lr;
int width = RESTORATION_EXTRA_HORZ << use_highbd;
int height = tile_limit.v_end - tile_limit.v_start;
assert(height <= MAX_SB_SIZE + voffset);
int stride = use_highbd ? src_stride << use_highbd : src_stride;
proc_width = proc_width << use_highbd;
uint8_t *src_proc = src + tile_limit.v_start * stride +
(tile_limit.h_start << use_highbd) + proc_width - width;
uint8_t *src_ptr = src_proc;
for (int proc = 0; proc < height; proc++) {
/* save cdef_data of current block to temp
_buf before LR processing */
svt_memcpy(bdry_cdef_ptr, src_ptr, width);
src_ptr += stride;
bdry_cdef_ptr += width;
}
if (!use_highbd)
svt_dec_av1_loop_restoration_filter_unit(1,
&tile_limit,
lr_unit,
&lr_ctxt->boundaries[plane],
lr_ctxt->rlbs[index][plane],
&tile_rect[plane],
tile_stripe0,
sx,
sy,
use_highbd,
bit_depth,
src,
src_stride,
dst,
dst_stride,
lr_ctxt->rst_tmpbuf[index],
optimized_lr);
else
svt_dec_av1_loop_restoration_filter_unit(1,
&tile_limit,
lr_unit,
&lr_ctxt->boundaries[plane],
lr_ctxt->rlbs[index][plane],
&tile_rect[plane],
tile_stripe0,
sx,
sy,
use_highbd,
bit_depth,
CONVERT_TO_BYTEPTR(src),
src_stride,
CONVERT_TO_BYTEPTR(dst),
dst_stride,
lr_ctxt->rst_tmpbuf[index],
optimized_lr);
src_ptr = src_proc - proc_width;
// restore LR_data of previous block
if (col)
for (int proc = 0; proc < height; proc++) {
svt_memcpy(src_ptr, bdry_lr_ptr, width);
src_ptr += stride;
bdry_lr_ptr += width;
}
if ((col + block_w) < plane_tile_w)
for (int proc = 0; proc < height; proc++) {
// save lr_data of current block to temp_buf
svt_memcpy(bdry_lr, src_proc, width);
// save cdef_data of current block to src
svt_memcpy(src_proc, bdry_cdef, width);
src_proc += stride;
bdry_cdef += width;
bdry_lr += width;
}
}
if (is_mt) {
*sb_lr_completed_in_row = sb_col_y;
}
}
}
void dec_av1_loop_restoration_filter_frame(EbDecHandle *dec_handle, int optimized_lr,
int enable_flag) {
if (!enable_flag)
return;
assert(!dec_handle->frame_header.all_lossless);
int32_t y, sb_row;
uint8_t *curr_blk_recon_buf[MAX_MB_PLANE];
int32_t curr_recon_stride[MAX_MB_PLANE];
Av1PixelRect tile_rect[MAX_MB_PLANE];
EbPictureBufferDesc *recon_picture_ptr = dec_handle->cur_pic_buf[0]->ps_pic_buf;
const int32_t num_planes = av1_num_planes(&dec_handle->seq_header.color_config);
lr_pad_pic(recon_picture_ptr, &dec_handle->frame_header, &dec_handle->seq_header.color_config);
LrCtxt *lr_ctxt = (LrCtxt *)dec_handle->pv_lr_ctxt;
uint8_t *dst = lr_ctxt->dst;
for (int32_t pli = 0; pli < num_planes; pli++) {
int32_t sub_x = (pli == 0) ? 0 : dec_handle->seq_header.color_config.subsampling_x;
int32_t sub_y = (pli == 0) ? 0 : dec_handle->seq_header.color_config.subsampling_y;
/*Deriveing recon pict buffer ptr's*/
derive_blk_pointers(recon_picture_ptr,
pli,
0,
0,
(void *)&curr_blk_recon_buf[pli],
&curr_recon_stride[pli],
sub_x,
sub_y);
tile_rect[pli] = whole_frame_rect(
&dec_handle->frame_header.frame_size, sub_x, sub_y, pli > 0);
}
int tile_h = tile_rect[AOM_PLANE_Y].bottom - tile_rect[AOM_PLANE_Y].top;
int sb_size = 1 << dec_handle->seq_header.sb_size_log2;
for (y = 0, sb_row = 0; y < tile_h; y += sb_size, sb_row++) {
dec_av1_loop_restoration_filter_row(dec_handle,
sb_row,
&curr_blk_recon_buf[AOM_PLANE_Y],
&curr_recon_stride[AOM_PLANE_Y],
tile_rect,
optimized_lr,
dst,
0);
}
}
void dec_av1_loop_restoration_save_boundary_lines(EbDecHandle *dec_handle, int after_cdef) {
const int num_planes = av1_num_planes(&dec_handle->seq_header.color_config);
const int use_highbd = (dec_handle->seq_header.color_config.bit_depth > EB_EIGHT_BIT ||
dec_handle->is_16bit_pipeline);
for (int p = 0; p < num_planes; ++p) {
LrCtxt *lr_ctxt = (LrCtxt *)dec_handle->pv_lr_ctxt;
FrameSize *frame_size = &dec_handle->frame_header.frame_size;
int32_t sx = 0, sy = 0;
uint8_t *src;
int32_t stride;
if (p) {
sx = dec_handle->seq_header.color_config.subsampling_x;
sy = dec_handle->seq_header.color_config.subsampling_y;
}
int32_t crop_width = frame_size->frame_width >> sx;
int32_t crop_height = frame_size->frame_height >> sy;
EbPictureBufferDesc *cur_pic_buf = dec_handle->cur_pic_buf[0]->ps_pic_buf;
derive_blk_pointers(cur_pic_buf, p, 0, 0, (void *)&src, &stride, sx, sy);
uint8_t *src_buf = REAL_PTR(use_highbd, use_highbd ? CONVERT_TO_BYTEPTR(src) : src);
int32_t src_stride = stride;
RestorationStripeBoundaries *boundaries = &lr_ctxt->boundaries[p];
save_tile_row_boundary_lines(src_buf,
src_stride,
crop_width,
crop_height,
use_highbd,
p,
&dec_handle->cm,
after_cdef,
boundaries);
}
}
| 15,076 |
14,668 | <gh_stars>1000+
// 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 THIRD_PARTY_BLINK_PUBLIC_COMMON_CSS_NAVIGATION_CONTROLS_H_
#define THIRD_PARTY_BLINK_PUBLIC_COMMON_CSS_NAVIGATION_CONTROLS_H_
namespace blink {
// Use for passing navigation controls from the OS to the renderer.
enum class NavigationControls {
kNone,
kBackButton,
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_PUBLIC_COMMON_CSS_NAVIGATION_CONTROLS_H_
| 200 |
4,036 |
typedef struct
{
int x, y;
} MyCoords;
int getX(MyCoords *coords);
void doSomething(void *something);
typedef struct
{
char isTrue;
} MyBool;
void myTest_with_local_flow(MyBool *b, int pos)
{
MyCoords coords = {0};
if (b->isTrue) {
goto next;
}
next:
coords.x = coords.y = pos + 1;
// There is flow from `{0}` to `coords` in `&coords` on the next line.
coords.x = getX(&coords);
doSomething((void *)&pos);
}
| 190 |
852 | import FWCore.ParameterSet.Config as cms
BtagPerformanceESProducer_TTBARWPBTAGCSVL = cms.ESProducer("BtagPerformanceESProducer",
# this is what it makes available
ComponentName = cms.string('TTBARWPBTAGCSVL'),
# this is where it gets the payload from
PayloadName = cms.string('TTBARWPBTAGCSVL_T'),
WorkingPointName = cms.string('TTBARWPBTAGCSVL_WP')
)
BtagPerformanceESProducer_TTBARWPBTAGCSVM = cms.ESProducer("BtagPerformanceESProducer",
# this is what it makes available
ComponentName = cms.string('TTBARWPBTAGCSVM'),
# this is where it gets the payload from
PayloadName = cms.string('TTBARWPBTAGCSVM_T'),
WorkingPointName = cms.string('TTBARWPBTAGCSVM_WP')
)
BtagPerformanceESProducer_TTBARWPBTAGCSVT = cms.ESProducer("BtagPerformanceESProducer",
# this is what it makes available
ComponentName = cms.string('TTBARWPBTAGCSVT'),
# this is where it gets the payload from
PayloadName = cms.string('TTBARWPBTAGCSVT_T'),
WorkingPointName = cms.string('TTBARWPBTAGCSVT_WP')
)
BtagPerformanceESProducer_TTBARWPBTAGJPL = cms.ESProducer("BtagPerformanceESProducer",
# this is what it makes available
ComponentName = cms.string('TTBARWPBTAGJPL'),
# this is where it gets the payload from
PayloadName = cms.string('TTBARWPBTAGJPL_T'),
WorkingPointName = cms.string('TTBARWPBTAGJPL_WP')
)
BtagPerformanceESProducer_TTBARWPBTAGJPM = cms.ESProducer("BtagPerformanceESProducer",
# this is what it makes available
ComponentName = cms.string('TTBARWPBTAGJPM'),
# this is where it gets the payload from
PayloadName = cms.string('TTBARWPBTAGJPM_T'),
WorkingPointName = cms.string('TTBARWPBTAGJPM_WP')
)
BtagPerformanceESProducer_TTBARWPBTAGJPT = cms.ESProducer("BtagPerformanceESProducer",
# this is what it makes available
ComponentName = cms.string('TTBARWPBTAGJPT'),
# this is where it gets the payload from
PayloadName = cms.string('TTBARWPBTAGJPT_T'),
WorkingPointName = cms.string('TTBARWPBTAGJPT_WP')
)
BtagPerformanceESProducer_TTBARWPBTAGTCHPT = cms.ESProducer("BtagPerformanceESProducer",
# this is what it makes available
ComponentName = cms.string('TTBARWPBTAGTCHPT'),
# this is where it gets the payload from
PayloadName = cms.string('TTBARWPBTAGTCHPT_T'),
WorkingPointName = cms.string('TTBARWPBTAGTCHPT_WP')
)
| 1,199 |
455 | <gh_stars>100-1000
/* Copyright (c) 2001 <NAME>.
* Copyright (c) 2001-2004, <NAME>.
* Copyright (c) 2004-2006, <NAME>, <NAME>.
* Copyright (c) 2007-2019, The Tor Project, Inc. */
/* See LICENSE for licensing information */
/**
* \file loadkey.h
* \brief Header file for loadkey.c
**/
#ifndef TOR_LOADKEY_H
#define TOR_LOADKEY_H
#include "lib/crypt_ops/crypto_ed25519.h"
crypto_pk_t *init_key_from_file(const char *fname, int generate,
int severity, bool *created_out);
#define INIT_ED_KEY_CREATE (1u<<0)
#define INIT_ED_KEY_REPLACE (1u<<1)
#define INIT_ED_KEY_SPLIT (1u<<2)
#define INIT_ED_KEY_MISSING_SECRET_OK (1u<<3)
#define INIT_ED_KEY_NEEDCERT (1u<<4)
#define INIT_ED_KEY_EXTRA_STRONG (1u<<5)
#define INIT_ED_KEY_INCLUDE_SIGNING_KEY_IN_CERT (1u<<6)
#define INIT_ED_KEY_OMIT_SECRET (1u<<7)
#define INIT_ED_KEY_TRY_ENCRYPTED (1u<<8)
#define INIT_ED_KEY_NO_REPAIR (1u<<9)
#define INIT_ED_KEY_SUGGEST_KEYGEN (1u<<10)
#define INIT_ED_KEY_OFFLINE_SECRET (1u<<11)
#define INIT_ED_KEY_EXPLICIT_FNAME (1u<<12)
struct tor_cert_st;
ed25519_keypair_t *ed_key_init_from_file(const char *fname, uint32_t flags,
int severity,
const ed25519_keypair_t *signing_key,
time_t now,
time_t lifetime,
uint8_t cert_type,
struct tor_cert_st **cert_out,
const or_options_t *options);
ed25519_keypair_t *ed_key_new(const ed25519_keypair_t *signing_key,
uint32_t flags,
time_t now,
time_t lifetime,
uint8_t cert_type,
struct tor_cert_st **cert_out);
int read_encrypted_secret_key(ed25519_secret_key_t *out,
const char *fname);
int write_encrypted_secret_key(const ed25519_secret_key_t *out,
const char *fname);
#endif
| 1,411 |
356 | import os
import itertools
import numpy as np
from PIL import Image
from torch.utils.data import Dataset
import torchvision.transforms as transforms
from torch.utils.data.sampler import Sampler
NO_LABEL = -1
class DataSetWarpper(Dataset):
"""Enable dataset to output index of sample
"""
def __init__(self, dataset, num_classes):
self.dataset = dataset
self.num_classes = num_classes
def __getitem__(self, index):
sample, label = self.dataset[index]
return sample, label, index
def __len__(self):
return len(self.dataset)
class TransformTwice:
def __init__(self, transform):
self.transform = transform
def __call__(self, inp):
out1 = self.transform(inp)
out2 = self.transform(inp)
return out1, out2
class TransformWeakStrong:
def __init__(self, trans1, trans2):
self.transform1 = trans1
self.transform2 = trans2
def __call__(self, inp):
out1 = self.transform1(inp)
out2 = self.transform2(inp)
return out1, out2
class TwoStreamBatchSampler(Sampler):
"""Iterate two sets of indices
"""
def __init__(self, primary_indices, secondary_indices, batch_size, secondary_batch_size):
self.primary_indices = primary_indices
self.primary_batch_size = batch_size - secondary_batch_size
self.secondary_indices = secondary_indices
self.secondary_batch_size = secondary_batch_size
assert len(self.primary_indices) >= self.primary_batch_size > 0
assert len(self.secondary_indices) >= self.secondary_batch_size > 0
def __iter__(self):
primary_iter = iterate_once(self.primary_indices)
secondary_iter = iterate_eternally(self.secondary_indices)
return (
secondary_batch + primary_batch
for (primary_batch, secondary_batch)
in zip(grouper(primary_iter, self.primary_batch_size),
grouper(secondary_iter, self.secondary_batch_size))
)
def __len__(self):
return len(self.primary_indices) // self.primary_batch_size
def iterate_once(iterable):
return np.random.permutation(iterable)
def iterate_eternally(indices, is_shuffle=True):
shuffleFunc = np.random.permutation if is_shuffle else lambda x: x
def infinite_shuffles():
while True:
yield shuffleFunc(indices)
return itertools.chain.from_iterable(infinite_shuffles())
def grouper(iterable, n):
args = [iter(iterable)]*n
return zip(*args)
| 1,119 |
311 | package org.javacs.lsp;
public class ReferenceContext {
public boolean includeDeclaration;
}
| 30 |
416 | <filename>iPhoneOS10.3.sdk/System/Library/Frameworks/ReplayKit.framework/Headers/RPBroadcastConfiguration.h
//
// RPBroadcastConfiguration.h
// ReplayKit
//
// Copyright © 2016 Apple Inc. All rights reserved.
//
#import <Foundation/Foundation.h>
NS_CLASS_AVAILABLE_IOS(10_0)
NS_ASSUME_NONNULL_BEGIN
@interface RPBroadcastConfiguration : NSObject <NSCoding, NSSecureCoding>
/* @abstract Specify the duration of a movie clip before it is delivered to the movie clip handler extension. Default is 5 seconds. */
@property (nonatomic, assign) NSTimeInterval clipDuration;
/* @abstract Override the video compression properties used to encode movie clips. See AVVideoCompressionPropertiesKey in <AVFoundation/AVVideoSettings.h> for available properties. */
@property (nonatomic, strong, nullable) NSDictionary <NSString *, NSObject <NSCoding, NSSecureCoding> *> *videoCompressionProperties;
@end
NS_ASSUME_NONNULL_END
| 282 |
439 | <gh_stars>100-1000
/**
* Baidu.com,Inc.
* Copyright (c) 2000-2013 All Rights Reserved.
*/
package com.baidu.hsb.server.response;
import java.nio.ByteBuffer;
import com.baidu.hsb.mysql.PreparedStatement;
import com.baidu.hsb.net.FrontendConnection;
import com.baidu.hsb.net.mysql.EOFPacket;
import com.baidu.hsb.net.mysql.FieldPacket;
import com.baidu.hsb.net.mysql.PreparedOkPacket;
/**
* @author <EMAIL> 2012-8-28
*/
public class PreparedStmtResponse {
public static void response(PreparedStatement pstmt, FrontendConnection c) {
byte packetId = 0;
// write preparedOk packet
PreparedOkPacket preparedOk = new PreparedOkPacket();
preparedOk.packetId = ++packetId;
preparedOk.statementId = pstmt.getId();
preparedOk.columnsNumber = pstmt.getColumnsNumber();
preparedOk.parametersNumber = pstmt.getParametersNumber();
ByteBuffer buffer = preparedOk.write(c.allocate(), c);
// write parameter field packet
int parametersNumber = preparedOk.parametersNumber;
if (parametersNumber > 0) {
for (int i = 0; i < parametersNumber; i++) {
FieldPacket field = new FieldPacket();
field.packetId = ++packetId;
buffer = field.write(buffer, c);
}
EOFPacket eof = new EOFPacket();
eof.packetId = ++packetId;
buffer = eof.write(buffer, c);
}
// write column field packet
int columnsNumber = preparedOk.columnsNumber;
if (columnsNumber > 0) {
for (int i = 0; i < columnsNumber; i++) {
FieldPacket field = new FieldPacket();
field.packetId = ++packetId;
buffer = field.write(buffer, c);
}
EOFPacket eof = new EOFPacket();
eof.packetId = ++packetId;
buffer = eof.write(buffer, c);
}
// send buffer
c.write(buffer);
}
}
| 902 |
847 | <gh_stars>100-1000
package com.crazysunj.multityperecyclerviewadapter.testlevel;
import androidx.annotation.Nullable;
import static com.crazysunj.multityperecyclerviewadapter.testlevel.TestLevelAdapter.TYPE_LEVEL_SECOND_ERROR;
/**
* @author: sunjian
* created on: 2019/1/7 上午10:21
* description:
*/
public class LevelSecondErrorItem implements MultiTypeTitleEntity {
private String msg;
public LevelSecondErrorItem(String msg) {
this.msg = msg;
}
@Override
public String getMsg() {
return msg;
}
@Override
public int getItemType() {
return TYPE_LEVEL_SECOND_ERROR;
}
@Override
public boolean equals(@Nullable Object obj) {
if (!(obj instanceof LevelSecondErrorItem)) {
return false;
}
if (msg == null) {
return false;
}
return msg.equals(((LevelSecondErrorItem) obj).msg);
}
}
| 379 |
1,431 | package com.asura.monitor.configure.entity;
/**
* <p></p>
*
* <PRE>
* <BR> 修改记录
* <BR>-----------------------------------------------
* <BR> 修改日期 修改人 修改内容
* </PRE>
*
* @author zhaozq
* @version 1.0
* @since 1.0
*/
public class SysinfoDataEntity {
// 数据名称
private String name;
// 标签组
private String lable;
// 数据结果
private Object result;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLable() {
return lable;
}
public void setLable(String lable) {
this.lable = lable;
}
public Object getResult() {
return result;
}
public void setResult(String result) {
this.result = result;
}
}
| 439 |
419 | {
"PlaceholderDesc_Hours": "Hours of the time",
"PlaceholderDesc_Minutes": "Minutes of the time",
"PlaceholderDesc_TotalMinutes": "Total minutes of the time. Will be calculated as Hours * MinutesPerHour + Minutes."
} | 75 |
764 | {"symbol": "TSX","address": "0x734C90044a0bA31B3F2e640c10dC5d3540499Bfd","overview":{"en": ""},"email": "","website": "https://tradestars.app/","state": "NORMAL","links": {"blog": "https://www.facebook.com/TradeStarsOK","twitter": "https://twitter.com/tradestarsOK","telegram": "","github": ""}} | 114 |
347 | <reponame>hbraha/ovirt-engine
package org.ovirt.engine.core.common.action;
import org.ovirt.engine.core.common.businessentities.VmRngDevice;
/**
* Unifies command parameters of commands manipulating RNG devices.
*/
public interface HasRngDevice {
VmRngDevice getRngDevice();
void setRngDevice(VmRngDevice rngDevice);
boolean isUpdateRngDevice();
void setUpdateRngDevice(boolean updateRngDevice);
}
| 143 |
5,169 | {
"name": "MyFirstCocoaPodTest",
"version": "0.1.0",
"summary": "This is test pod. it can be remove any time",
"description": "'This is test pod. it can be remove any timeThis is test pod. it can be remove any timeThis is test pod. it can be remove any time'",
"homepage": "https://github.com/RajaReddyiOS/MyFirstCocoaPodTest.git",
"license": {
"type": "MIT",
"file": "LICENSE"
},
"authors": {
"Raja": "<EMAIL>"
},
"source": {
"git": "https://github.com/RajaReddyiOS/MyFirstCocoaPodTest.git",
"tag": "0.1.0"
},
"platforms": {
"ios": "9.0"
},
"source_files": "Source/**/*",
"swift_versions": "5.0",
"swift_version": "5.0"
}
| 283 |
2,458 | {
"$schema": "https://developer.microsoft.com/json-schemas/heft/heft.schema.json",
"extends": "@rushstack/heft-web-rig/profiles/library/config/heft.json",
"eventActions": [
{
"actionKind": "copyFiles",
"heftEvent": "bundle",
"actionId": "add-dts-file",
"copyOperations": [
{
"sourceFolder": "lib/beta",
"destinationFolders": ["lib-commonjs/beta"],
"fileExtensions": [".d.ts"]
}
]
}
]
}
| 264 |
686 | /*
* Implementation of hyperlinking (hlink.dll)
*
* Copyright 2005 <NAME> for CodeWeavers
*
* This 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.
*
* This 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 this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "hlink_private.h"
#include "winreg.h"
#include "rpcproxy.h"
#include "hlguids.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(hlink);
static HINSTANCE instance;
typedef HRESULT (*LPFNCREATEINSTANCE)(IUnknown*, REFIID, LPVOID*);
typedef struct
{
IClassFactory IClassFactory_iface;
LPFNCREATEINSTANCE lpfnCI;
} CFImpl;
static inline CFImpl *impl_from_IClassFactory(IClassFactory *iface)
{
return CONTAINING_RECORD(iface, CFImpl, IClassFactory_iface);
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
TRACE("%p %d %p\n", hinstDLL, fdwReason, lpvReserved);
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
instance = hinstDLL;
DisableThreadLibraryCalls(hinstDLL);
break;
}
return TRUE;
}
/***********************************************************************
* DllCanUnloadNow (HLINK.@)
*/
HRESULT WINAPI DllCanUnloadNow( void )
{
return S_FALSE;
}
/***********************************************************************
* HlinkCreateFromMoniker (HLINK.@)
*/
HRESULT WINAPI HlinkCreateFromMoniker( IMoniker *pimkTrgt, LPCWSTR pwzLocation,
LPCWSTR pwzFriendlyName, IHlinkSite* pihlsite, DWORD dwSiteData,
IUnknown* piunkOuter, REFIID riid, void** ppvObj)
{
IHlink *hl = NULL;
HRESULT r;
TRACE("%p %s %s %p %i %p %s %p\n", pimkTrgt, debugstr_w(pwzLocation),
debugstr_w(pwzFriendlyName), pihlsite, dwSiteData, piunkOuter,
debugstr_guid(riid), ppvObj);
r = CoCreateInstance(&CLSID_StdHlink, piunkOuter, CLSCTX_INPROC_SERVER, riid, (LPVOID*)&hl);
if (FAILED(r))
return r;
IHlink_SetMonikerReference(hl, HLINKSETF_LOCATION | HLINKSETF_TARGET, pimkTrgt, pwzLocation);
if (pwzFriendlyName)
IHlink_SetFriendlyName(hl, pwzFriendlyName);
if (pihlsite)
IHlink_SetHlinkSite(hl, pihlsite, dwSiteData);
*ppvObj = hl;
TRACE("Returning %i\n",r);
return r;
}
/***********************************************************************
* HlinkCreateFromString (HLINK.@)
*/
HRESULT WINAPI HlinkCreateFromString( LPCWSTR pwzTarget, LPCWSTR pwzLocation,
LPCWSTR pwzFriendlyName, IHlinkSite* pihlsite, DWORD dwSiteData,
IUnknown* piunkOuter, REFIID riid, void** ppvObj)
{
IHlink *hl = NULL;
HRESULT r;
WCHAR *hash, *tgt;
const WCHAR *loc;
TRACE("%s %s %s %p %i %p %s %p\n", debugstr_w(pwzTarget),
debugstr_w(pwzLocation), debugstr_w(pwzFriendlyName), pihlsite,
dwSiteData, piunkOuter, debugstr_guid(riid), ppvObj);
r = CoCreateInstance(&CLSID_StdHlink, piunkOuter, CLSCTX_INPROC_SERVER, riid, (LPVOID*)&hl);
if (FAILED(r))
return r;
if (pwzTarget)
{
hash = wcschr(pwzTarget, '#');
if (hash)
{
if (hash == pwzTarget)
tgt = NULL;
else
{
int tgt_len = hash - pwzTarget;
tgt = heap_alloc((tgt_len + 1) * sizeof(WCHAR));
if (!tgt)
return E_OUTOFMEMORY;
memcpy(tgt, pwzTarget, tgt_len * sizeof(WCHAR));
tgt[tgt_len] = 0;
}
if (!pwzLocation)
loc = hash + 1;
else
loc = pwzLocation;
}
else
{
tgt = hlink_strdupW(pwzTarget);
if (!tgt)
return E_OUTOFMEMORY;
loc = pwzLocation;
}
}
else
{
tgt = NULL;
loc = pwzLocation;
}
IHlink_SetStringReference(hl, HLINKSETF_TARGET | HLINKSETF_LOCATION, tgt, loc);
heap_free(tgt);
if (pwzFriendlyName)
IHlink_SetFriendlyName(hl, pwzFriendlyName);
if (pihlsite)
IHlink_SetHlinkSite(hl, pihlsite, dwSiteData);
TRACE("Returning %i\n",r);
*ppvObj = hl;
return r;
}
/***********************************************************************
* HlinkCreateBrowseContext (HLINK.@)
*/
HRESULT WINAPI HlinkCreateBrowseContext( IUnknown* piunkOuter, REFIID riid, void** ppvObj)
{
TRACE("%p %s %p\n", piunkOuter, debugstr_guid(riid), ppvObj);
return CoCreateInstance(&CLSID_StdHlinkBrowseContext, piunkOuter, CLSCTX_INPROC_SERVER, riid, ppvObj);
}
/***********************************************************************
* HlinkNavigate (HLINK.@)
*/
HRESULT WINAPI HlinkNavigate(IHlink *phl, IHlinkFrame *phlFrame,
DWORD grfHLNF, LPBC pbc, IBindStatusCallback *pbsc,
IHlinkBrowseContext *phlbc)
{
HRESULT r = S_OK;
TRACE("%p %p %i %p %p %p\n", phl, phlFrame, grfHLNF, pbc, pbsc, phlbc);
if (phlFrame)
r = IHlinkFrame_Navigate(phlFrame, grfHLNF, pbc, pbsc, phl);
else if (phl)
r = IHlink_Navigate(phl, grfHLNF, pbc, pbsc, phlbc);
return r;
}
/***********************************************************************
* HlinkOnNavigate (HLINK.@)
*/
HRESULT WINAPI HlinkOnNavigate( IHlinkFrame *phlFrame,
IHlinkBrowseContext* phlbc, DWORD grfHLNF, IMoniker *pmkTarget,
LPCWSTR pwzLocation, LPCWSTR pwzFriendlyName, ULONG* puHLID)
{
HRESULT r;
TRACE("%p %p %i %p %s %s %p\n",phlFrame, phlbc, grfHLNF, pmkTarget,
debugstr_w(pwzLocation), debugstr_w(pwzFriendlyName), puHLID);
r = IHlinkBrowseContext_OnNavigateHlink(phlbc, grfHLNF, pmkTarget,
pwzLocation, pwzFriendlyName, puHLID);
if (phlFrame)
r = IHlinkFrame_OnNavigate(phlFrame,grfHLNF,pmkTarget, pwzLocation,
pwzFriendlyName, 0);
return r;
}
/***********************************************************************
* HlinkCreateFromData (HLINK.@)
*/
HRESULT WINAPI HlinkCreateFromData(IDataObject *piDataObj,
IHlinkSite *pihlsite, DWORD dwSiteData, IUnknown *piunkOuter,
REFIID riid, void **ppvObj)
{
FIXME("%p, %p, %d, %p, %s, %p\n", piDataObj, pihlsite, dwSiteData,
piunkOuter, debugstr_guid(riid), ppvObj);
*ppvObj = NULL;
return E_NOTIMPL;
}
/***********************************************************************
* HlinkQueryCreateFromData (HLINK.@)
*/
HRESULT WINAPI HlinkQueryCreateFromData(IDataObject* piDataObj)
{
FIXME("%p\n", piDataObj);
return E_NOTIMPL;
}
/***********************************************************************
* HlinkNavigateToStringReference (HLINK.@)
*/
HRESULT WINAPI HlinkNavigateToStringReference( LPCWSTR pwzTarget,
LPCWSTR pwzLocation, IHlinkSite *pihlsite, DWORD dwSiteData,
IHlinkFrame *pihlframe, DWORD grfHLNF, LPBC pibc,
IBindStatusCallback *pibsc, IHlinkBrowseContext *pihlbc)
{
HRESULT r;
IHlink *hlink = NULL;
TRACE("%s %s %p %08x %p %08x %p %p %p\n",
debugstr_w(pwzTarget), debugstr_w(pwzLocation), pihlsite,
dwSiteData, pihlframe, grfHLNF, pibc, pibsc, pihlbc);
r = HlinkCreateFromString( pwzTarget, pwzLocation, NULL, pihlsite,
dwSiteData, NULL, &IID_IHlink, (LPVOID*) &hlink );
if (SUCCEEDED(r)) {
r = HlinkNavigate(hlink, pihlframe, grfHLNF, pibc, pibsc, pihlbc);
IHlink_Release(hlink);
}
return r;
}
/***********************************************************************
* HlinkIsShortcut (HLINK.@)
*/
HRESULT WINAPI HlinkIsShortcut(LPCWSTR pwzFileName)
{
int len;
TRACE("(%s)\n", debugstr_w(pwzFileName));
if(!pwzFileName)
return E_INVALIDARG;
len = lstrlenW(pwzFileName)-4;
if(len < 0)
return S_FALSE;
return wcsicmp(pwzFileName+len, L".url") ? S_FALSE : S_OK;
}
/***********************************************************************
* HlinkGetSpecialReference (HLINK.@)
*/
HRESULT WINAPI HlinkGetSpecialReference(ULONG uReference, LPWSTR *ppwzReference)
{
DWORD res, type, size = 100;
LPCWSTR value_name;
WCHAR *buf;
HKEY hkey;
TRACE("(%u %p)\n", uReference, ppwzReference);
*ppwzReference = NULL;
switch(uReference) {
case HLSR_HOME:
value_name = L"Start Page";
break;
case HLSR_SEARCHPAGE:
value_name = L"Search Page";
break;
case HLSR_HISTORYFOLDER:
return E_NOTIMPL;
default:
return E_INVALIDARG;
}
res = RegOpenKeyW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Internet Explorer\\Main", &hkey);
if(res != ERROR_SUCCESS) {
WARN("Could not open key: %u\n", res);
return HRESULT_FROM_WIN32(res);
}
buf = CoTaskMemAlloc(size);
res = RegQueryValueExW(hkey, value_name, NULL, &type, (PBYTE)buf, &size);
buf = CoTaskMemRealloc(buf, size);
if(res == ERROR_MORE_DATA)
res = RegQueryValueExW(hkey, value_name, NULL, &type, (PBYTE)buf, &size);
RegCloseKey(hkey);
if(res != ERROR_SUCCESS) {
WARN("Could not query value %s: %u\n", debugstr_w(value_name), res);
CoTaskMemFree(buf);
return HRESULT_FROM_WIN32(res);
}
*ppwzReference = buf;
return S_OK;
}
/***********************************************************************
* HlinkTranslateURL (HLINK.@)
*/
HRESULT WINAPI HlinkTranslateURL(LPCWSTR pwzURL, DWORD grfFlags, LPWSTR *ppwzTranslatedURL)
{
FIXME("(%s %08x %p)\n", debugstr_w(pwzURL), grfFlags, ppwzTranslatedURL);
return E_NOTIMPL;
}
/***********************************************************************
* HlinkUpdateStackItem (HLINK.@)
*/
HRESULT WINAPI HlinkUpdateStackItem(IHlinkFrame *frame, IHlinkBrowseContext *bc,
ULONG hlid, IMoniker *target, LPCWSTR location, LPCWSTR friendly_name)
{
HRESULT hr;
TRACE("(%p %p 0x%x %p %s %s)\n", frame, bc, hlid, target, debugstr_w(location), debugstr_w(friendly_name));
if (!frame && !bc) return E_INVALIDARG;
if (frame)
hr = IHlinkFrame_UpdateHlink(frame, hlid, target, location, friendly_name);
else
hr = IHlinkBrowseContext_UpdateHlink(bc, hlid, target, location, friendly_name);
return hr;
}
/***********************************************************************
* HlinkParseDisplayName (HLINK.@)
*/
HRESULT WINAPI HlinkParseDisplayName(LPBC pibc, LPCWSTR pwzDisplayName, BOOL fNoForceAbs,
ULONG *pcchEaten, IMoniker **ppimk)
{
ULONG eaten = 0, len;
HRESULT hres;
TRACE("(%p %s %x %p %p)\n", pibc, debugstr_w(pwzDisplayName), fNoForceAbs, pcchEaten, ppimk);
if(fNoForceAbs)
FIXME("Unsupported fNoForceAbs\n");
len = ARRAY_SIZE(L"file:") - 1;
if(!wcsnicmp(pwzDisplayName, L"file:", len)) {
pwzDisplayName += len;
eaten += len;
while(*pwzDisplayName == '/') {
pwzDisplayName++;
eaten++;
}
}else {
hres = MkParseDisplayNameEx(pibc, pwzDisplayName, pcchEaten, ppimk);
if(SUCCEEDED(hres))
return hres;
hres = MkParseDisplayName(pibc, pwzDisplayName, pcchEaten, ppimk);
if(SUCCEEDED(hres))
return hres;
}
hres = CreateFileMoniker(pwzDisplayName, ppimk);
if(SUCCEEDED(hres))
*pcchEaten = eaten + lstrlenW(pwzDisplayName);
return hres;
}
/***********************************************************************
* HlinkResolveMonikerForData (HLINK.@)
*/
HRESULT WINAPI HlinkResolveMonikerForData(LPMONIKER pimkReference, DWORD reserved, LPBC pibc,
ULONG cFmtetc, FORMATETC *rgFmtetc, IBindStatusCallback *pibsc, LPMONIKER pimkBase)
{
LPOLESTR name = NULL;
IBindCtx *bctx;
DWORD mksys = 0;
void *obj = NULL;
HRESULT hres;
TRACE("(%p %x %p %d %p %p %p)\n", pimkReference, reserved, pibc, cFmtetc, rgFmtetc, pibsc, pimkBase);
if(cFmtetc || rgFmtetc || pimkBase)
FIXME("Unsupported args\n");
hres = RegisterBindStatusCallback(pibc, pibsc, NULL /* FIXME */, 0);
if(FAILED(hres))
return hres;
hres = IMoniker_IsSystemMoniker(pimkReference, &mksys);
if(SUCCEEDED(hres) && mksys != MKSYS_URLMONIKER)
WARN("sysmk = %x\n", mksys);
/* FIXME: What is it for? */
CreateBindCtx(0, &bctx);
hres = IMoniker_GetDisplayName(pimkReference, bctx, NULL, &name);
IBindCtx_Release(bctx);
if(SUCCEEDED(hres)) {
TRACE("got display name %s\n", debugstr_w(name));
CoTaskMemFree(name);
}
return IMoniker_BindToStorage(pimkReference, pibc, NULL, &IID_IUnknown, &obj);
}
/***********************************************************************
* HlinkClone (HLINK.@)
*/
HRESULT WINAPI HlinkClone(IHlink *hlink, REFIID riid, IHlinkSite *hls,
DWORD site_data, void **obj)
{
IMoniker *mk, *clone_mk = NULL;
WCHAR *loc, *name = NULL;
HRESULT hres;
if(!hlink || !riid || !obj)
return E_INVALIDARG;
*obj = NULL;
hres = IHlink_GetMonikerReference(hlink, HLINKGETREF_DEFAULT, &mk, &loc);
if(FAILED(hres))
return hres;
if(mk) {
IStream *strm;
LARGE_INTEGER lgint;
hres = CreateStreamOnHGlobal(NULL, TRUE, &strm);
if(FAILED(hres)) {
IMoniker_Release(mk);
goto cleanup;
}
hres = OleSaveToStream((IPersistStream*)mk, strm);
if(FAILED(hres)) {
IStream_Release(strm);
IMoniker_Release(mk);
goto cleanup;
}
IMoniker_Release(mk);
lgint.QuadPart = 0;
hres = IStream_Seek(strm, lgint, STREAM_SEEK_SET, NULL);
if(FAILED(hres)) {
IStream_Release(strm);
goto cleanup;
}
hres = OleLoadFromStream(strm, &IID_IMoniker, (void**)&clone_mk);
IStream_Release(strm);
if(FAILED(hres))
goto cleanup;
}
hres = IHlink_GetFriendlyName(hlink, HLFNAMEF_DEFAULT, &name);
if(FAILED(hres))
goto cleanup;
hres = HlinkCreateFromMoniker(clone_mk, loc, name, hls, site_data, NULL,
&IID_IHlink, obj);
cleanup:
if(clone_mk)
IMoniker_Release(clone_mk);
CoTaskMemFree(loc);
CoTaskMemFree(name);
return hres;
}
static HRESULT WINAPI HLinkCF_fnQueryInterface ( LPCLASSFACTORY iface,
REFIID riid, LPVOID *ppvObj)
{
CFImpl *This = impl_from_IClassFactory(iface);
TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObj);
*ppvObj = NULL;
if (IsEqualIID(riid, &IID_IUnknown) ||
IsEqualIID(riid, &IID_IClassFactory))
{
*ppvObj = &This->IClassFactory_iface;
return S_OK;
}
TRACE("-- E_NOINTERFACE\n");
return E_NOINTERFACE;
}
static ULONG WINAPI HLinkCF_fnAddRef (LPCLASSFACTORY iface)
{
return 2;
}
static ULONG WINAPI HLinkCF_fnRelease(LPCLASSFACTORY iface)
{
return 1;
}
static HRESULT WINAPI HLinkCF_fnCreateInstance( LPCLASSFACTORY iface,
LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObject)
{
CFImpl *This = impl_from_IClassFactory(iface);
TRACE("%p->(%p,%s,%p)\n", This, pUnkOuter, debugstr_guid(riid), ppvObject);
*ppvObject = NULL;
return This->lpfnCI(pUnkOuter, riid, ppvObject);
}
static HRESULT WINAPI HLinkCF_fnLockServer(LPCLASSFACTORY iface, BOOL fLock)
{
FIXME("%p %d\n", iface, fLock);
return E_NOTIMPL;
}
static const IClassFactoryVtbl hlcfvt =
{
HLinkCF_fnQueryInterface,
HLinkCF_fnAddRef,
HLinkCF_fnRelease,
HLinkCF_fnCreateInstance,
HLinkCF_fnLockServer
};
static CFImpl HLink_cf = { { &hlcfvt }, HLink_Constructor };
static CFImpl HLinkBrowseContext_cf = { { &hlcfvt }, HLinkBrowseContext_Constructor };
/***********************************************************************
* DllGetClassObject (HLINK.@)
*/
HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
{
IClassFactory *pcf = NULL;
TRACE("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(iid), ppv);
if (!ppv)
return E_INVALIDARG;
*ppv = NULL;
if (IsEqualIID(rclsid, &CLSID_StdHlink))
pcf = &HLink_cf.IClassFactory_iface;
else if (IsEqualIID(rclsid, &CLSID_StdHlinkBrowseContext))
pcf = &HLinkBrowseContext_cf.IClassFactory_iface;
else
return CLASS_E_CLASSNOTAVAILABLE;
return IClassFactory_QueryInterface(pcf, iid, ppv);
}
/***********************************************************************
* DllRegisterServer (HLINK.@)
*/
HRESULT WINAPI DllRegisterServer(void)
{
return __wine_register_resources( instance );
}
/***********************************************************************
* DllUnregisterServer (HLINK.@)
*/
HRESULT WINAPI DllUnregisterServer(void)
{
return __wine_unregister_resources( instance );
}
| 7,989 |
326 | package com.bihell.dice.system.service;
import com.bihell.dice.system.entity.AuthContent;
/**
* @author haseochen
*/
@Deprecated
public interface AuthContentService {
AuthContent save(AuthContent authContent);
AuthContent update(AuthContent authContent) ;
}
| 85 |
3,112 | #pragma once
#include "engine/input_system.h"
namespace Lumix
{
struct ControllerDevice : InputSystem::Device
{
static void init(InputSystem& input_system);
static void frame(float dt);
static void shutdown();
const char* getName() const override { return "controller"; }
};
} // namespace Lumix | 92 |
721 | package com.github.tminglei.slickpg;
/**
* Used by [[PgEnumSupportSuite]]
*
* Created by gwilson on 6/24/16.
*/
public enum Languages {
SCALA("Scala"),
JAVA("Java"),
CLOJURE("Clojure");
private final String value;
Languages(final String value) {
this.value = value;
}
public String toString() {
return value;
}
}
| 154 |
687 | <gh_stars>100-1000
// Copyright 2021 The XLS Authors
//
// 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 XLS_NOC_SIMULATION_RANDOM_NUMBER_INTERFACE_H_
#define XLS_NOC_SIMULATION_RANDOM_NUMBER_INTERFACE_H_
#include <random>
// This file contains classes used manage and obtain random numbers
// from different distributions.
namespace xls::noc {
// Interface to generate random outcomes from a seeded random number generator.
class RandomNumberInterface {
public:
RandomNumberInterface() {
// Default to a deterministic seed if nothing else is done.
random_engine_.seed(0);
}
// Sets seed of random number generator.
void SetSeed(int16_t seed) { random_engine_.seed(seed); }
// Set a random seed to the random number generator.
void SetRandomSeed() { SetSeed(std::random_device()()); }
// These distributions have no internal state.
// Returns True with probability p.
bool BernoilliDistribution(double p) {
return std::bernoulli_distribution(p)(random_engine_);
}
// Return number of trails until success.
// - sucess at each trail is with probability p
// - mean is 1/p
int64_t GeometricDistribution(double p) {
return std::geometric_distribution<int64_t>(p)(random_engine_);
}
// Returns next inter-arrival time.
// https://ieeexplore.ieee.org/document/9153030
//
// - average arrival time is 1/lambda
// - probability of a burst is burst_prob
int64_t GeneralizedGeometric(double lambda, double burst_prob) {
bool burst = BernoilliDistribution(burst_prob);
if (burst) {
return 0;
}
double geo_p = lambda * (1.0 - burst_prob);
return 1 + GeometricDistribution(geo_p);
}
private:
// Random engine with a single int as state.
std::minstd_rand random_engine_;
};
} // namespace xls::noc
#endif // XLS_NOC_SIMULATION_RANDOM_NUMBER_INTERFACE_H_
| 746 |
348 | {"nom":"Achun","circ":"2ème circonscription","dpt":"Nièvre","inscrits":108,"abs":40,"votants":68,"blancs":8,"nuls":0,"exp":60,"res":[{"nuance":"REM","nom":"M. <NAME>","voix":35},{"nuance":"SOC","nom":"M. <NAME>","voix":25}]} | 94 |
558 | <filename>src/main/java/com/endava/cats/args/CheckArguments.java
package com.endava.cats.args;
import lombok.Getter;
import picocli.CommandLine;
import javax.inject.Singleton;
/**
* Holds all args related to category of Fuzzers to run.
*/
@Singleton
@Getter
public class CheckArguments {
@CommandLine.Option(names = {"-H", "--checkHeaders"},
description = "Run only Header Fuzzers")
private boolean checkHeaders;
@CommandLine.Option(names = {"-F", "--checkFields"},
description = "Run only Fields Fuzzers")
private boolean checkFields;
@CommandLine.Option(names = {"-T", "--checkHttp"},
description = "Run only HTTP Fuzzers")
private boolean checkHttp;
@CommandLine.Option(names = {"-C", "--checkContract"},
description = "Run only Contract Fuzzers")
private boolean checkContract;
@CommandLine.Option(names = {"-W", "--includeWhitespaces"},
description = "Include Whitespaces Fuzzers")
private boolean includeWhitespaces;
@CommandLine.Option(names = {"-E", "--includeEmojis"},
description = "Include Emojis Fuzzers")
private boolean includeEmojis;
@CommandLine.Option(names = {"-U", "--includeControlChars"},
description = "Include ControlChars Fuzzers")
private boolean includeControlChars;
}
| 493 |
3,200 | # Copyright 2020 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
import numpy as np
import pytest
import mindspore.context as context
import mindspore.nn as nn
from mindspore import Tensor
from mindspore.ops import composite as C
from mindspore.ops import operations as P
context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
class Net(nn.Cell):
def __init__(self, reduction="none"):
super(Net, self).__init__()
self.BinaryCrossEntropy = P.BinaryCrossEntropy(reduction)
def construct(self, x, y, weight=None):
return self.BinaryCrossEntropy(x, y, weight)
@pytest.mark.level0
@pytest.mark.platform_x86_gpu_training
@pytest.mark.env_onecard
def test_binary_cross_entropy_loss():
np.random.seed(42)
prediction = np.random.rand(20).astype(np.float32)
target = np.random.rand(20).astype(np.float32)
weight = np.random.rand(20).astype(np.float32)
net = Net()
loss = net(Tensor(prediction), Tensor(target), Tensor(weight))
expect = [0.09555826, 1.2861121, 0.03518666, 0.6969416, 0.24313456, 0.99062896,
0.19205657, 0.5465214, 0.36964455, 0.21999404, 2.2953863, 2.2566645,
1.5803775, 1.3266402, 0.9883408, 1.2997618, 0.05439841, 0.14389999,
0.03405444, 0.23934692]
assert np.allclose(loss.asnumpy(), expect)
def test_binary_cross_entropy_loss_sum_without_weight():
np.random.seed(42)
prediction = np.random.rand(20).astype(np.float32)
target = np.random.rand(20).astype(np.float32)
reduction = "sum"
net = Net(reduction)
loss = net(Tensor(prediction), Tensor(target))
expect = [25.48195216753522]
assert np.allclose(loss.asnumpy(), expect)
class Grad(nn.Cell):
def __init__(self, network):
super(Grad, self).__init__()
self.grad = C.GradOperation(get_all=True, sens_param=True)
self.network = network
def construct(self, x1, x2, sens, weight=None):
gout = self.grad(self.network)(x1, x2, sens, weight)
return gout
@pytest.mark.level0
@pytest.mark.platform_x86_gpu_training
@pytest.mark.env_onecard
def test_binary_cross_entropy_loss_grad():
np.random.seed(42)
prediction = np.random.rand(20).astype(np.float32)
target = np.random.rand(20).astype(np.float32)
sens = np.random.rand(20).astype(np.float32)
weight = np.random.rand(20).astype(np.float32)
grad = Grad(Net())
dx = grad(Tensor(prediction), Tensor(target), Tensor(sens), Tensor(weight))
dx1_expect = [-4.80516590e-02, 2.32625079e+00, 6.38972521e-02, 3.13642323e-01,
-1.65661633e-01, -1.71821892e+00, -1.13685496e-01, 1.26669514e+00,
1.47891801e-03, 5.83921909e-01, -2.17992840e+01, 4.21899414e+00,
2.85430793e-02, -3.21346498e+00, -2.22674108e+00, -2.80453944e+00,
-1.19787852e-04, 2.48514321e-02, -1.66696273e-02, -2.71965731e-02]
assert np.allclose(dx[0].asnumpy(), dx1_expect)
| 1,592 |
17,703 | #include <iostream>
#include <string>
#include "source/common/common/fancy_logger.h"
#include "source/common/common/logger.h"
#include "benchmark/benchmark.h"
namespace Envoy {
/**
* Benchmark for the main slow path, i.e. new logger creation here.
*/
static void fancySlowPath(benchmark::State& state) {
FANCY_LOG(info, "Slow path test begins.");
std::atomic<spdlog::logger*> logger;
for (auto _ : state) {
UNREFERENCED_PARAMETER(_);
for (int i = 0; i < state.range(0); i++) {
std::string key = "k" + std::to_string(i + (state.thread_index << 8));
getFancyContext().initFancyLogger(key, logger);
}
}
}
#define FL FANCY_LOG(trace, "Default")
#define FL_8 \
FL; \
FL; \
FL; \
FL; \
FL; \
FL; \
FL; \
FL;
#define FL_64 \
{ FL_8 FL_8 FL_8 FL_8 FL_8 FL_8 FL_8 FL_8 }
#define FL_512 \
{ FL_64 FL_64 FL_64 FL_64 FL_64 FL_64 FL_64 FL_64 }
#define FL_1024 \
{ FL_512 FL_512 }
/**
* Benchmark for medium path, i.e. new site initialization within the same file.
*/
static void fancyMediumPath(benchmark::State& state) {
FANCY_LOG(info, "Medium path test begins.");
for (auto _ : state) {
UNREFERENCED_PARAMETER(_);
// create different call sites for medium path
for (int i = 0; i < state.range(0); i++) {
FL_1024
}
}
}
/**
* Benchmark for fast path, i.e. integration test of common scenario.
*/
static void fancyFastPath(benchmark::State& state) {
// control log length to be the same as normal Envoy below
std::string msg(100 - strlen(__FILE__) + 4, '.');
spdlog::level::level_enum lv = state.range(1) ? spdlog::level::trace : spdlog::level::info;
getFancyContext().setFancyLogger(FANCY_KEY, lv);
for (auto _ : state) {
UNREFERENCED_PARAMETER(_);
for (int i = 0; i < state.range(0); i++) {
FANCY_LOG(trace, "Fast path: {}", msg);
}
}
}
/**
* Benchmark for ENVOY_LOG to compare.
*/
static void envoyNormal(benchmark::State& state) {
spdlog::level::level_enum lv = state.range(1) ? spdlog::level::trace : spdlog::level::info;
std::string msg(100, '.');
GET_MISC_LOGGER().set_level(lv);
for (auto _ : state) {
UNREFERENCED_PARAMETER(_);
for (int i = 0; i < state.range(0); i++) {
ENVOY_LOG_MISC(trace, "Fast path: {}", msg);
}
}
}
/**
* Benchmark for a large number of level setting.
*/
static void fancyLevelSetting(benchmark::State& state) {
FANCY_LOG(info, "Level setting test begins.");
for (auto _ : state) {
UNREFERENCED_PARAMETER(_);
for (int i = 0; i < state.range(0); i++) {
getFancyContext().setFancyLogger(__FILE__, spdlog::level::warn);
}
}
}
/**
* Comparison with Envoy's level setting.
*/
static void envoyLevelSetting(benchmark::State& state) {
ENVOY_LOG_MISC(info, "Envoy's level setting begins.");
for (auto _ : state) {
UNREFERENCED_PARAMETER(_);
for (int i = 0; i < state.range(0); i++) {
GET_MISC_LOGGER().set_level(spdlog::level::warn);
}
}
}
/**
* Benchmarks in detail starts.
*/
BENCHMARK(fancySlowPath)->Arg(1 << 10);
BENCHMARK(fancySlowPath)->Arg(1 << 10)->Threads(20)->MeasureProcessCPUTime();
BENCHMARK(fancySlowPath)->Arg(1 << 10)->Threads(200)->MeasureProcessCPUTime();
BENCHMARK(fancyMediumPath)->Arg(1)->Iterations(1);
// Seems medium path's concurrency test doesn't make sense (hard to do as well)
BENCHMARK(fancyFastPath)->Args({1024, 0})->Args({1024, 1}); // First no actual log, then log
BENCHMARK(fancyFastPath)->Args({1 << 10, 0})->Threads(20)->MeasureProcessCPUTime();
BENCHMARK(fancyFastPath)->Args({1 << 10, 1})->Threads(20)->MeasureProcessCPUTime();
BENCHMARK(fancyFastPath)->Args({1 << 10, 0})->Threads(200)->MeasureProcessCPUTime();
BENCHMARK(fancyFastPath)->Args({1 << 10, 1})->Threads(200)->MeasureProcessCPUTime();
BENCHMARK(envoyNormal)->Args({1024, 0})->Args({1024, 1});
BENCHMARK(envoyNormal)->Args({1 << 10, 0})->Threads(20)->MeasureProcessCPUTime();
BENCHMARK(envoyNormal)->Args({1 << 10, 1})->Threads(20)->MeasureProcessCPUTime();
BENCHMARK(envoyNormal)->Args({1 << 10, 0})->Threads(200)->MeasureProcessCPUTime();
BENCHMARK(envoyNormal)->Args({1 << 10, 1})->Threads(200)->MeasureProcessCPUTime();
BENCHMARK(fancyLevelSetting)->Arg(1 << 10);
BENCHMARK(envoyLevelSetting)->Arg(1 << 10);
} // namespace Envoy
| 2,706 |
539 | DEF_STATIC_CONST_VAL_STRING(val_0000,"pau");
DEF_STATIC_CONST_VAL_STRING(val_0001,"BB");
DEF_STATIC_CONST_VAL_FLOAT(val_0002,2.000000);
#define CTNODE_cmu_us_awb_dur_NO_0001 3
DEF_STATIC_CONST_VAL_FLOAT(val_0003,0.000000);
#define CTNODE_cmu_us_awb_dur_NO_0000 4
DEF_STATIC_CONST_VAL_FLOAT(val_0004,1.200000);
DEF_STATIC_CONST_VAL_STRING(val_0005,"0");
DEF_STATIC_CONST_VAL_STRING(val_0006,"pau_141");
DEF_STATIC_CONST_VAL_STRING(val_0007,"pau_142");
DEF_STATIC_CONST_VAL_STRING(val_0008,"f");
DEF_STATIC_CONST_VAL_FLOAT(val_0009,0.006928);
#define CTNODE_cmu_us_awb_dur_NO_0010 12
DEF_STATIC_CONST_VAL_STRING(val_0010,"-");
DEF_STATIC_CONST_VAL_FLOAT(val_0011,-0.250347);
#define CTNODE_cmu_us_awb_dur_NO_0012 14
DEF_STATIC_CONST_VAL_STRING(val_0012,"+");
DEF_STATIC_CONST_VAL_FLOAT(val_0013,-0.380618);
#define CTNODE_cmu_us_awb_dur_NO_0014 16
DEF_STATIC_CONST_VAL_FLOAT(val_0014,-0.671541);
#define CTNODE_cmu_us_awb_dur_NO_0009 17
DEF_STATIC_CONST_VAL_STRING(val_0015,"pau_143");
DEF_STATIC_CONST_VAL_STRING(val_0016,"1");
DEF_STATIC_CONST_VAL_FLOAT(val_0017,0.833610);
#define CTNODE_cmu_us_awb_dur_NO_0019 21
DEF_STATIC_CONST_VAL_STRING(val_0018,"2");
DEF_STATIC_CONST_VAL_FLOAT(val_0019,0.709840);
#define CTNODE_cmu_us_awb_dur_NO_0021 23
DEF_STATIC_CONST_VAL_FLOAT(val_0020,0.641522);
#define CTNODE_cmu_us_awb_dur_NO_0018 24
DEF_STATIC_CONST_VAL_STRING(val_0021,"coda");
DEF_STATIC_CONST_VAL_STRING(val_0022,"d");
DEF_STATIC_CONST_VAL_FLOAT(val_0023,0.753467);
#define CTNODE_cmu_us_awb_dur_NO_0025 27
DEF_STATIC_CONST_VAL_FLOAT(val_0024,0.417072);
#define CTNODE_cmu_us_awb_dur_NO_0027 29
DEF_STATIC_CONST_VAL_FLOAT(val_0025,0.644236);
#define CTNODE_cmu_us_awb_dur_NO_0024 30
DEF_STATIC_CONST_VAL_STRING(val_0026,"l");
DEF_STATIC_CONST_VAL_FLOAT(val_0027,-0.053562);
#define CTNODE_cmu_us_awb_dur_NO_0030 32
DEF_STATIC_CONST_VAL_FLOAT(val_0028,0.007898);
#define CTNODE_cmu_us_awb_dur_NO_0032 34
DEF_STATIC_CONST_VAL_FLOAT(val_0029,0.219522);
#define CTNODE_cmu_us_awb_dur_NO_0017 35
DEF_STATIC_CONST_VAL_STRING(val_0030,"a");
DEF_STATIC_CONST_VAL_FLOAT(val_0031,1.176860);
#define CTNODE_cmu_us_awb_dur_NO_0036 38
DEF_STATIC_CONST_VAL_FLOAT(val_0032,1.117630);
#define CTNODE_cmu_us_awb_dur_NO_0035 39
DEF_STATIC_CONST_VAL_FLOAT(val_0033,1.072470);
#define CTNODE_cmu_us_awb_dur_NO_0039 41
DEF_STATIC_CONST_VAL_FLOAT(val_0034,0.938140);
#define CTNODE_cmu_us_awb_dur_NO_0008 42
DEF_STATIC_CONST_VAL_FLOAT(val_0035,0.625539);
#define CTNODE_cmu_us_awb_dur_NO_0043 45
DEF_STATIC_CONST_VAL_FLOAT(val_0036,0.557812);
#define CTNODE_cmu_us_awb_dur_NO_0042 46
DEF_STATIC_CONST_VAL_FLOAT(val_0037,3.494200);
#define CTNODE_cmu_us_awb_dur_NO_0046 48
DEF_STATIC_CONST_VAL_FLOAT(val_0038,3.319910);
#define CTNODE_cmu_us_awb_dur_NO_0048 50
DEF_STATIC_CONST_VAL_FLOAT(val_0039,3.201160);
#define CTNODE_cmu_us_awb_dur_NO_0007 51
DEF_STATIC_CONST_VAL_FLOAT(val_0040,0.087308);
#define CTNODE_cmu_us_awb_dur_NO_0053 55
DEF_STATIC_CONST_VAL_FLOAT(val_0041,-0.147753);
#define CTNODE_cmu_us_awb_dur_NO_0055 57
DEF_STATIC_CONST_VAL_STRING(val_0042,"s");
DEF_STATIC_CONST_VAL_FLOAT(val_0043,-0.050855);
#define CTNODE_cmu_us_awb_dur_NO_0058 60
DEF_STATIC_CONST_VAL_FLOAT(val_0044,0.132183);
#define CTNODE_cmu_us_awb_dur_NO_0057 61
DEF_STATIC_CONST_VAL_STRING(val_0045,"hh");
DEF_STATIC_CONST_VAL_FLOAT(val_0046,-0.115699);
#define CTNODE_cmu_us_awb_dur_NO_0061 63
DEF_STATIC_CONST_VAL_FLOAT(val_0047,0.005250);
#define CTNODE_cmu_us_awb_dur_NO_0063 65
DEF_STATIC_CONST_VAL_STRING(val_0048,"r");
DEF_STATIC_CONST_VAL_FLOAT(val_0049,-0.072961);
#define CTNODE_cmu_us_awb_dur_NO_0065 67
DEF_STATIC_CONST_VAL_FLOAT(val_0050,-0.026835);
#define CTNODE_cmu_us_awb_dur_NO_0067 69
DEF_STATIC_CONST_VAL_FLOAT(val_0051,-0.050523);
#define CTNODE_cmu_us_awb_dur_NO_0069 71
DEF_STATIC_CONST_VAL_FLOAT(val_0052,-0.052446);
#define CTNODE_cmu_us_awb_dur_NO_0052 72
DEF_STATIC_CONST_VAL_STRING(val_0053,"ay");
DEF_STATIC_CONST_VAL_FLOAT(val_0054,-0.265283);
#define CTNODE_cmu_us_awb_dur_NO_0072 74
DEF_STATIC_CONST_VAL_STRING(val_0055,"w");
DEF_STATIC_CONST_VAL_FLOAT(val_0056,-0.252462);
#define CTNODE_cmu_us_awb_dur_NO_0074 76
DEF_STATIC_CONST_VAL_FLOAT(val_0057,-0.150332);
#define CTNODE_cmu_us_awb_dur_NO_0077 79
DEF_STATIC_CONST_VAL_FLOAT(val_0058,0.032748);
#define CTNODE_cmu_us_awb_dur_NO_0076 80
DEF_STATIC_CONST_VAL_STRING(val_0059,"n");
DEF_STATIC_CONST_VAL_FLOAT(val_0060,-0.048920);
#define CTNODE_cmu_us_awb_dur_NO_0080 82
DEF_STATIC_CONST_VAL_FLOAT(val_0061,-0.123331);
#define CTNODE_cmu_us_awb_dur_NO_0082 84
DEF_STATIC_CONST_VAL_FLOAT(val_0062,-0.205755);
#define CTNODE_cmu_us_awb_dur_NO_0084 86
DEF_STATIC_CONST_VAL_FLOAT(val_0063,-0.188847);
#define CTNODE_cmu_us_awb_dur_NO_0086 88
DEF_STATIC_CONST_VAL_FLOAT(val_0064,-0.166656);
#define CTNODE_cmu_us_awb_dur_NO_0088 90
DEF_STATIC_CONST_VAL_FLOAT(val_0065,-0.088988);
#define CTNODE_cmu_us_awb_dur_NO_0051 91
DEF_STATIC_CONST_VAL_FLOAT(val_0066,0.089477);
#define CTNODE_cmu_us_awb_dur_NO_0093 95
DEF_STATIC_CONST_VAL_FLOAT(val_0067,0.070970);
#define CTNODE_cmu_us_awb_dur_NO_0092 96
DEF_STATIC_CONST_VAL_FLOAT(val_0068,0.282195);
#define CTNODE_cmu_us_awb_dur_NO_0096 98
DEF_STATIC_CONST_VAL_FLOAT(val_0069,0.622814);
#define CTNODE_cmu_us_awb_dur_NO_0098 100
DEF_STATIC_CONST_VAL_FLOAT(val_0070,0.901067);
#define CTNODE_cmu_us_awb_dur_NO_0100 102
DEF_STATIC_CONST_VAL_FLOAT(val_0071,0.957346);
#define CTNODE_cmu_us_awb_dur_NO_0091 103
DEF_STATIC_CONST_VAL_FLOAT(val_0072,0.438400);
#define CTNODE_cmu_us_awb_dur_NO_0104 106
DEF_STATIC_CONST_VAL_FLOAT(val_0073,0.144612);
#define CTNODE_cmu_us_awb_dur_NO_0103 107
DEF_STATIC_CONST_VAL_FLOAT(val_0074,-0.205938);
#define CTNODE_cmu_us_awb_dur_NO_0107 109
DEF_STATIC_CONST_VAL_FLOAT(val_0075,-0.156953);
#define CTNODE_cmu_us_awb_dur_NO_0110 112
DEF_STATIC_CONST_VAL_FLOAT(val_0076,-0.139392);
#define CTNODE_cmu_us_awb_dur_NO_0109 113
DEF_STATIC_CONST_VAL_STRING(val_0077,"hh_81");
DEF_STATIC_CONST_VAL_FLOAT(val_0078,-0.144378);
#define CTNODE_cmu_us_awb_dur_NO_0115 117
DEF_STATIC_CONST_VAL_FLOAT(val_0079,-0.190571);
#define CTNODE_cmu_us_awb_dur_NO_0114 118
DEF_STATIC_CONST_VAL_FLOAT(val_0080,0.075650);
#define CTNODE_cmu_us_awb_dur_NO_0113 119
DEF_STATIC_CONST_VAL_FLOAT(val_0081,0.378111);
#define CTNODE_cmu_us_awb_dur_NO_0119 121
DEF_STATIC_CONST_VAL_FLOAT(val_0082,-0.142254);
#define CTNODE_cmu_us_awb_dur_NO_0121 123
DEF_STATIC_CONST_VAL_FLOAT(val_0083,-0.005939);
#define CTNODE_cmu_us_awb_dur_NO_0123 125
DEF_STATIC_CONST_VAL_FLOAT(val_0084,0.117448);
#define CTNODE_cmu_us_awb_dur_NO_0006 126
DEF_STATIC_CONST_VAL_FLOAT(val_0085,-1.348120);
#define CTNODE_cmu_us_awb_dur_NO_0128 130
DEF_STATIC_CONST_VAL_FLOAT(val_0086,-0.945071);
#define CTNODE_cmu_us_awb_dur_NO_0127 131
DEF_STATIC_CONST_VAL_STRING(val_0087,"3");
DEF_STATIC_CONST_VAL_FLOAT(val_0088,-0.703528);
#define CTNODE_cmu_us_awb_dur_NO_0132 134
DEF_STATIC_CONST_VAL_FLOAT(val_0089,-0.504830);
#define CTNODE_cmu_us_awb_dur_NO_0131 135
DEF_STATIC_CONST_VAL_FLOAT(val_0090,-1.090340);
#define CTNODE_cmu_us_awb_dur_NO_0135 137
DEF_STATIC_CONST_VAL_FLOAT(val_0091,-0.830350);
#define CTNODE_cmu_us_awb_dur_NO_0139 141
DEF_STATIC_CONST_VAL_FLOAT(val_0092,-0.608223);
#define CTNODE_cmu_us_awb_dur_NO_0138 142
DEF_STATIC_CONST_VAL_FLOAT(val_0093,-0.829131);
#define CTNODE_cmu_us_awb_dur_NO_0142 144
DEF_STATIC_CONST_VAL_FLOAT(val_0094,-1.024070);
#define CTNODE_cmu_us_awb_dur_NO_0137 145
DEF_STATIC_CONST_VAL_FLOAT(val_0095,-0.573472);
#define CTNODE_cmu_us_awb_dur_NO_0126 146
DEF_STATIC_CONST_VAL_FLOAT(val_0096,-0.420008);
#define CTNODE_cmu_us_awb_dur_NO_0150 152
DEF_STATIC_CONST_VAL_FLOAT(val_0097,-0.336701);
#define CTNODE_cmu_us_awb_dur_NO_0149 153
DEF_STATIC_CONST_VAL_FLOAT(val_0098,-0.440620);
#define CTNODE_cmu_us_awb_dur_NO_0148 154
DEF_STATIC_CONST_VAL_FLOAT(val_0099,-0.482222);
#define CTNODE_cmu_us_awb_dur_NO_0154 156
DEF_STATIC_CONST_VAL_FLOAT(val_0100,-0.499151);
#define CTNODE_cmu_us_awb_dur_NO_0157 159
DEF_STATIC_CONST_VAL_FLOAT(val_0101,-0.502605);
#define CTNODE_cmu_us_awb_dur_NO_0156 160
DEF_STATIC_CONST_VAL_FLOAT(val_0102,-0.494481);
#define CTNODE_cmu_us_awb_dur_NO_0161 163
DEF_STATIC_CONST_VAL_FLOAT(val_0103,-0.499374);
#define CTNODE_cmu_us_awb_dur_NO_0160 164
DEF_STATIC_CONST_VAL_FLOAT(val_0104,-0.490715);
#define CTNODE_cmu_us_awb_dur_NO_0164 166
DEF_STATIC_CONST_VAL_FLOAT(val_0105,-0.496557);
#define CTNODE_cmu_us_awb_dur_NO_0147 167
DEF_STATIC_CONST_VAL_FLOAT(val_0106,-0.466106);
#define CTNODE_cmu_us_awb_dur_NO_0168 170
DEF_STATIC_CONST_VAL_FLOAT(val_0107,-0.493161);
#define CTNODE_cmu_us_awb_dur_NO_0170 172
DEF_STATIC_CONST_VAL_FLOAT(val_0108,-0.498382);
#define CTNODE_cmu_us_awb_dur_NO_0167 173
DEF_STATIC_CONST_VAL_FLOAT(val_0109,-0.463525);
#define CTNODE_cmu_us_awb_dur_NO_0175 177
DEF_STATIC_CONST_VAL_FLOAT(val_0110,-0.442114);
#define CTNODE_cmu_us_awb_dur_NO_0174 178
DEF_STATIC_CONST_VAL_STRING(val_0111,"er");
DEF_STATIC_CONST_VAL_FLOAT(val_0112,-0.487777);
#define CTNODE_cmu_us_awb_dur_NO_0178 180
DEF_STATIC_CONST_VAL_FLOAT(val_0113,-0.466629);
#define CTNODE_cmu_us_awb_dur_NO_0173 181
DEF_STATIC_CONST_VAL_FLOAT(val_0114,-0.503331);
#define CTNODE_cmu_us_awb_dur_NO_0181 183
DEF_STATIC_CONST_VAL_FLOAT(val_0115,-0.399494);
#define CTNODE_cmu_us_awb_dur_NO_0183 185
DEF_STATIC_CONST_VAL_FLOAT(val_0116,-0.392555);
#define CTNODE_cmu_us_awb_dur_NO_0185 187
DEF_STATIC_CONST_VAL_FLOAT(val_0117,-0.340019);
#define CTNODE_cmu_us_awb_dur_NO_0187 189
DEF_STATIC_CONST_VAL_FLOAT(val_0118,0.197829);
#define CTNODE_cmu_us_awb_dur_NO_0146 190
DEF_STATIC_CONST_VAL_STRING(val_0119,"s_151");
DEF_STATIC_CONST_VAL_STRING(val_0120,"t_166");
DEF_STATIC_CONST_VAL_FLOAT(val_0121,-1.113190);
#define CTNODE_cmu_us_awb_dur_NO_0193 195
DEF_STATIC_CONST_VAL_FLOAT(val_0122,-0.866787);
#define CTNODE_cmu_us_awb_dur_NO_0195 197
DEF_STATIC_CONST_VAL_FLOAT(val_0123,-0.749350);
#define CTNODE_cmu_us_awb_dur_NO_0192 198
DEF_STATIC_CONST_VAL_FLOAT(val_0124,-0.701075);
#define CTNODE_cmu_us_awb_dur_NO_0198 200
DEF_STATIC_CONST_VAL_FLOAT(val_0125,-0.267836);
#define CTNODE_cmu_us_awb_dur_NO_0201 203
DEF_STATIC_CONST_VAL_FLOAT(val_0126,0.138971);
#define CTNODE_cmu_us_awb_dur_NO_0200 204
DEF_STATIC_CONST_VAL_FLOAT(val_0127,5.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0128,4.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0129,-0.588336);
#define CTNODE_cmu_us_awb_dur_NO_0206 208
DEF_STATIC_CONST_VAL_FLOAT(val_0130,0.200000);
DEF_STATIC_CONST_VAL_STRING(val_0131,"det");
DEF_STATIC_CONST_VAL_FLOAT(val_0132,-0.432242);
#define CTNODE_cmu_us_awb_dur_NO_0209 211
DEF_STATIC_CONST_VAL_FLOAT(val_0133,-0.540819);
#define CTNODE_cmu_us_awb_dur_NO_0208 212
DEF_STATIC_CONST_VAL_FLOAT(val_0134,-0.307929);
#define CTNODE_cmu_us_awb_dur_NO_0205 213
DEF_STATIC_CONST_VAL_FLOAT(val_0135,-0.227346);
#define CTNODE_cmu_us_awb_dur_NO_0204 214
DEF_STATIC_CONST_VAL_FLOAT(val_0136,1.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_0137,-0.129452);
#define CTNODE_cmu_us_awb_dur_NO_0215 217
DEF_STATIC_CONST_VAL_FLOAT(val_0138,0.158540);
#define CTNODE_cmu_us_awb_dur_NO_0214 218
DEF_STATIC_CONST_VAL_FLOAT(val_0139,-0.457659);
#define CTNODE_cmu_us_awb_dur_NO_0218 220
DEF_STATIC_CONST_VAL_FLOAT(val_0140,-0.134447);
#define CTNODE_cmu_us_awb_dur_NO_0191 221
DEF_STATIC_CONST_VAL_STRING(val_0141,"dh_51");
DEF_STATIC_CONST_VAL_FLOAT(val_0142,1.219650);
#define CTNODE_cmu_us_awb_dur_NO_0222 224
DEF_STATIC_CONST_VAL_FLOAT(val_0143,-0.612105);
#define CTNODE_cmu_us_awb_dur_NO_0224 226
DEF_STATIC_CONST_VAL_STRING(val_0144,"ax_28");
DEF_STATIC_CONST_VAL_FLOAT(val_0145,6.000000);
DEF_STATIC_CONST_VAL_STRING(val_0146,"initial");
DEF_STATIC_CONST_VAL_FLOAT(val_0147,0.492365);
#define CTNODE_cmu_us_awb_dur_NO_0229 231
DEF_STATIC_CONST_VAL_FLOAT(val_0148,0.047774);
#define CTNODE_cmu_us_awb_dur_NO_0232 234
DEF_STATIC_CONST_VAL_FLOAT(val_0149,0.485601);
#define CTNODE_cmu_us_awb_dur_NO_0231 235
DEF_STATIC_CONST_VAL_FLOAT(val_0150,-0.059852);
#define CTNODE_cmu_us_awb_dur_NO_0228 236
DEF_STATIC_CONST_VAL_FLOAT(val_0151,-0.187623);
#define CTNODE_cmu_us_awb_dur_NO_0227 237
DEF_STATIC_CONST_VAL_FLOAT(val_0152,3.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0153,-0.519713);
#define CTNODE_cmu_us_awb_dur_NO_0238 240
DEF_STATIC_CONST_VAL_FLOAT(val_0154,4.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0155,-0.383573);
#define CTNODE_cmu_us_awb_dur_NO_0240 242
DEF_STATIC_CONST_VAL_FLOAT(val_0156,-0.231439);
#define CTNODE_cmu_us_awb_dur_NO_0237 243
DEF_STATIC_CONST_VAL_FLOAT(val_0157,0.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_0158,0.559279);
#define CTNODE_cmu_us_awb_dur_NO_0244 246
DEF_STATIC_CONST_VAL_FLOAT(val_0159,-0.052613);
#define CTNODE_cmu_us_awb_dur_NO_0243 247
DEF_STATIC_CONST_VAL_STRING(val_0160,"ih");
DEF_STATIC_CONST_VAL_FLOAT(val_0161,0.247068);
#define CTNODE_cmu_us_awb_dur_NO_0247 249
DEF_STATIC_CONST_VAL_FLOAT(val_0162,-0.221011);
#define CTNODE_cmu_us_awb_dur_NO_0251 253
DEF_STATIC_CONST_VAL_FLOAT(val_0163,0.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0164,-0.489720);
#define CTNODE_cmu_us_awb_dur_NO_0253 255
DEF_STATIC_CONST_VAL_FLOAT(val_0165,-0.498112);
#define CTNODE_cmu_us_awb_dur_NO_0250 256
DEF_STATIC_CONST_VAL_FLOAT(val_0166,-0.362842);
#define CTNODE_cmu_us_awb_dur_NO_0256 258
DEF_STATIC_CONST_VAL_FLOAT(val_0167,-0.041645);
#define CTNODE_cmu_us_awb_dur_NO_0249 259
DEF_STATIC_CONST_VAL_FLOAT(val_0168,0.292489);
#define CTNODE_cmu_us_awb_dur_NO_0259 261
DEF_STATIC_CONST_VAL_FLOAT(val_0169,-0.417714);
#define CTNODE_cmu_us_awb_dur_NO_0226 262
DEF_STATIC_CONST_VAL_FLOAT(val_0170,0.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0171,0.564829);
#define CTNODE_cmu_us_awb_dur_NO_0266 268
DEF_STATIC_CONST_VAL_FLOAT(val_0172,0.225225);
#define CTNODE_cmu_us_awb_dur_NO_0265 269
DEF_STATIC_CONST_VAL_FLOAT(val_0173,3.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0174,3.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0175,0.087059);
#define CTNODE_cmu_us_awb_dur_NO_0271 273
DEF_STATIC_CONST_VAL_FLOAT(val_0176,0.698366);
#define CTNODE_cmu_us_awb_dur_NO_0270 274
DEF_STATIC_CONST_VAL_FLOAT(val_0177,-0.193059);
#define CTNODE_cmu_us_awb_dur_NO_0274 276
DEF_STATIC_CONST_VAL_FLOAT(val_0178,-0.100360);
#define CTNODE_cmu_us_awb_dur_NO_0276 278
DEF_STATIC_CONST_VAL_FLOAT(val_0179,0.242042);
#define CTNODE_cmu_us_awb_dur_NO_0269 279
DEF_STATIC_CONST_VAL_FLOAT(val_0180,-0.364551);
#define CTNODE_cmu_us_awb_dur_NO_0279 281
DEF_STATIC_CONST_VAL_FLOAT(val_0181,-0.184071);
#define CTNODE_cmu_us_awb_dur_NO_0264 282
DEF_STATIC_CONST_VAL_FLOAT(val_0182,0.154859);
#define CTNODE_cmu_us_awb_dur_NO_0282 284
DEF_STATIC_CONST_VAL_FLOAT(val_0183,0.711777);
#define CTNODE_cmu_us_awb_dur_NO_0263 285
DEF_STATIC_CONST_VAL_STRING(val_0184,"er_63");
DEF_STATIC_CONST_VAL_FLOAT(val_0185,0.165307);
#define CTNODE_cmu_us_awb_dur_NO_0286 288
DEF_STATIC_CONST_VAL_FLOAT(val_0186,-0.300300);
#define CTNODE_cmu_us_awb_dur_NO_0290 292
DEF_STATIC_CONST_VAL_FLOAT(val_0187,0.078012);
#define CTNODE_cmu_us_awb_dur_NO_0289 293
DEF_STATIC_CONST_VAL_FLOAT(val_0188,-0.441894);
#define CTNODE_cmu_us_awb_dur_NO_0294 296
DEF_STATIC_CONST_VAL_FLOAT(val_0189,-0.220184);
#define CTNODE_cmu_us_awb_dur_NO_0293 297
DEF_STATIC_CONST_VAL_FLOAT(val_0190,-0.617896);
#define CTNODE_cmu_us_awb_dur_NO_0288 298
DEF_STATIC_CONST_VAL_FLOAT(val_0191,0.237098);
#define CTNODE_cmu_us_awb_dur_NO_0298 300
DEF_STATIC_CONST_VAL_FLOAT(val_0192,-0.155828);
#define CTNODE_cmu_us_awb_dur_NO_0285 301
DEF_STATIC_CONST_VAL_FLOAT(val_0193,0.448674);
#define CTNODE_cmu_us_awb_dur_NO_0302 304
DEF_STATIC_CONST_VAL_FLOAT(val_0194,-0.123398);
#define CTNODE_cmu_us_awb_dur_NO_0305 307
DEF_STATIC_CONST_VAL_FLOAT(val_0195,0.035530);
#define CTNODE_cmu_us_awb_dur_NO_0304 308
DEF_STATIC_CONST_VAL_FLOAT(val_0196,0.165264);
#define CTNODE_cmu_us_awb_dur_NO_0309 311
DEF_STATIC_CONST_VAL_FLOAT(val_0197,0.562414);
#define CTNODE_cmu_us_awb_dur_NO_0308 312
DEF_STATIC_CONST_VAL_FLOAT(val_0198,0.011075);
#define CTNODE_cmu_us_awb_dur_NO_0301 313
DEF_STATIC_CONST_VAL_FLOAT(val_0199,2.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0200,0.441542);
#define CTNODE_cmu_us_awb_dur_NO_0316 318
DEF_STATIC_CONST_VAL_FLOAT(val_0201,-0.118973);
#define CTNODE_cmu_us_awb_dur_NO_0315 319
DEF_STATIC_CONST_VAL_FLOAT(val_0202,0.076969);
#define CTNODE_cmu_us_awb_dur_NO_0319 321
DEF_STATIC_CONST_VAL_FLOAT(val_0203,-0.207512);
#define CTNODE_cmu_us_awb_dur_NO_0314 322
DEF_STATIC_CONST_VAL_FLOAT(val_0204,-0.231964);
#define CTNODE_cmu_us_awb_dur_NO_0313 323
DEF_STATIC_CONST_VAL_FLOAT(val_0205,7.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0206,-0.155303);
#define CTNODE_cmu_us_awb_dur_NO_0323 325
DEF_STATIC_CONST_VAL_FLOAT(val_0207,-0.576485);
#define CTNODE_cmu_us_awb_dur_NO_0262 326
DEF_STATIC_CONST_VAL_STRING(val_0208,"t");
DEF_STATIC_CONST_VAL_FLOAT(val_0209,0.961862);
#define CTNODE_cmu_us_awb_dur_NO_0326 328
DEF_STATIC_CONST_VAL_STRING(val_0210,"s_153");
DEF_STATIC_CONST_VAL_FLOAT(val_0211,-0.315894);
#define CTNODE_cmu_us_awb_dur_NO_0328 330
DEF_STATIC_CONST_VAL_FLOAT(val_0212,0.559625);
#define CTNODE_cmu_us_awb_dur_NO_0331 333
DEF_STATIC_CONST_VAL_FLOAT(val_0213,0.588611);
#define CTNODE_cmu_us_awb_dur_NO_0334 336
DEF_STATIC_CONST_VAL_FLOAT(val_0214,-0.017070);
#define CTNODE_cmu_us_awb_dur_NO_0333 337
DEF_STATIC_CONST_VAL_FLOAT(val_0215,-0.169532);
#define CTNODE_cmu_us_awb_dur_NO_0338 340
DEF_STATIC_CONST_VAL_FLOAT(val_0216,-0.610082);
#define CTNODE_cmu_us_awb_dur_NO_0337 341
DEF_STATIC_CONST_VAL_FLOAT(val_0217,2.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_0218,0.623551);
#define CTNODE_cmu_us_awb_dur_NO_0342 344
DEF_STATIC_CONST_VAL_FLOAT(val_0219,0.081452);
#define CTNODE_cmu_us_awb_dur_NO_0341 345
DEF_STATIC_CONST_VAL_FLOAT(val_0220,-0.188122);
#define CTNODE_cmu_us_awb_dur_NO_0345 347
DEF_STATIC_CONST_VAL_FLOAT(val_0221,0.157156);
#define CTNODE_cmu_us_awb_dur_NO_0330 348
DEF_STATIC_CONST_VAL_FLOAT(val_0222,1.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_0223,0.242600);
#define CTNODE_cmu_us_awb_dur_NO_0350 352
DEF_STATIC_CONST_VAL_FLOAT(val_0224,0.499050);
#define CTNODE_cmu_us_awb_dur_NO_0349 353
DEF_STATIC_CONST_VAL_FLOAT(val_0225,-0.040245);
#define CTNODE_cmu_us_awb_dur_NO_0353 355
DEF_STATIC_CONST_VAL_FLOAT(val_0226,-0.258057);
#define CTNODE_cmu_us_awb_dur_NO_0348 356
DEF_STATIC_CONST_VAL_STRING(val_0227,"content");
DEF_STATIC_CONST_VAL_FLOAT(val_0228,0.975832);
#define CTNODE_cmu_us_awb_dur_NO_0359 361
DEF_STATIC_CONST_VAL_FLOAT(val_0229,2.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0230,0.863833);
#define CTNODE_cmu_us_awb_dur_NO_0361 363
DEF_STATIC_CONST_VAL_FLOAT(val_0231,0.442354);
#define CTNODE_cmu_us_awb_dur_NO_0358 364
DEF_STATIC_CONST_VAL_FLOAT(val_0232,0.386258);
#define CTNODE_cmu_us_awb_dur_NO_0357 365
DEF_STATIC_CONST_VAL_FLOAT(val_0233,2.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0234,0.072275);
#define CTNODE_cmu_us_awb_dur_NO_0367 369
DEF_STATIC_CONST_VAL_FLOAT(val_0235,0.389217);
#define CTNODE_cmu_us_awb_dur_NO_0366 370
DEF_STATIC_CONST_VAL_FLOAT(val_0236,-0.190334);
#define CTNODE_cmu_us_awb_dur_NO_0365 371
DEF_STATIC_CONST_VAL_FLOAT(val_0237,0.196456);
#define CTNODE_cmu_us_awb_dur_NO_0371 373
DEF_STATIC_CONST_VAL_FLOAT(val_0238,0.952711);
#define CTNODE_cmu_us_awb_dur_NO_0373 375
DEF_STATIC_CONST_VAL_FLOAT(val_0239,0.650455);
#define CTNODE_cmu_us_awb_dur_NO_0356 376
DEF_STATIC_CONST_VAL_FLOAT(val_0240,-0.094517);
#define CTNODE_cmu_us_awb_dur_NO_0376 378
DEF_STATIC_CONST_VAL_FLOAT(val_0241,0.230913);
#define CTNODE_cmu_us_awb_dur_NO_0221 379
DEF_STATIC_CONST_VAL_STRING(val_0242,"d_48");
DEF_STATIC_CONST_VAL_FLOAT(val_0243,2.166620);
#define CTNODE_cmu_us_awb_dur_NO_0381 383
DEF_STATIC_CONST_VAL_FLOAT(val_0244,2.128060);
#define CTNODE_cmu_us_awb_dur_NO_0383 385
DEF_STATIC_CONST_VAL_FLOAT(val_0245,0.759405);
#define CTNODE_cmu_us_awb_dur_NO_0380 386
DEF_STATIC_CONST_VAL_FLOAT(val_0246,0.384983);
#define CTNODE_cmu_us_awb_dur_NO_0388 390
DEF_STATIC_CONST_VAL_FLOAT(val_0247,0.660173);
#define CTNODE_cmu_us_awb_dur_NO_0387 391
DEF_STATIC_CONST_VAL_FLOAT(val_0248,0.173778);
#define CTNODE_cmu_us_awb_dur_NO_0392 394
DEF_STATIC_CONST_VAL_FLOAT(val_0249,-0.424430);
#define CTNODE_cmu_us_awb_dur_NO_0394 396
DEF_STATIC_CONST_VAL_FLOAT(val_0250,-0.298443);
#define CTNODE_cmu_us_awb_dur_NO_0396 398
DEF_STATIC_CONST_VAL_FLOAT(val_0251,-0.037542);
#define CTNODE_cmu_us_awb_dur_NO_0391 399
DEF_STATIC_CONST_VAL_FLOAT(val_0252,0.291343);
#define CTNODE_cmu_us_awb_dur_NO_0386 400
DEF_STATIC_CONST_VAL_FLOAT(val_0253,-0.821530);
#define CTNODE_cmu_us_awb_dur_NO_0401 403
DEF_STATIC_CONST_VAL_FLOAT(val_0254,-0.587665);
#define CTNODE_cmu_us_awb_dur_NO_0400 404
DEF_STATIC_CONST_VAL_FLOAT(val_0255,-0.570412);
#define CTNODE_cmu_us_awb_dur_NO_0404 406
DEF_STATIC_CONST_VAL_FLOAT(val_0256,0.135441);
#define CTNODE_cmu_us_awb_dur_NO_0406 408
DEF_STATIC_CONST_VAL_FLOAT(val_0257,6.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0258,0.094564);
#define CTNODE_cmu_us_awb_dur_NO_0409 411
DEF_STATIC_CONST_VAL_FLOAT(val_0259,-0.266310);
#define CTNODE_cmu_us_awb_dur_NO_0408 412
DEF_STATIC_CONST_VAL_FLOAT(val_0260,-0.459667);
#define CTNODE_cmu_us_awb_dur_NO_0413 415
DEF_STATIC_CONST_VAL_FLOAT(val_0261,-0.343886);
#define CTNODE_cmu_us_awb_dur_NO_0412 416
DEF_STATIC_CONST_VAL_FLOAT(val_0262,-0.146023);
#define CTNODE_cmu_us_awb_dur_NO_0379 417
DEF_STATIC_CONST_VAL_FLOAT(val_0263,0.424388);
#define CTNODE_cmu_us_awb_dur_NO_0419 421
DEF_STATIC_CONST_VAL_FLOAT(val_0264,0.099436);
#define CTNODE_cmu_us_awb_dur_NO_0421 423
DEF_STATIC_CONST_VAL_FLOAT(val_0265,0.026406);
#define CTNODE_cmu_us_awb_dur_NO_0418 424
DEF_STATIC_CONST_VAL_STRING(val_0266,"m_113");
DEF_STATIC_CONST_VAL_FLOAT(val_0267,-0.451780);
#define CTNODE_cmu_us_awb_dur_NO_0426 428
DEF_STATIC_CONST_VAL_FLOAT(val_0268,-0.158923);
#define CTNODE_cmu_us_awb_dur_NO_0425 429
DEF_STATIC_CONST_VAL_FLOAT(val_0269,0.023752);
#define CTNODE_cmu_us_awb_dur_NO_0429 431
DEF_STATIC_CONST_VAL_FLOAT(val_0270,-0.063986);
#define CTNODE_cmu_us_awb_dur_NO_0424 432
DEF_STATIC_CONST_VAL_FLOAT(val_0271,-0.368985);
#define CTNODE_cmu_us_awb_dur_NO_0432 434
DEF_STATIC_CONST_VAL_FLOAT(val_0272,-0.604456);
#define CTNODE_cmu_us_awb_dur_NO_0435 437
DEF_STATIC_CONST_VAL_FLOAT(val_0273,-0.571980);
#define CTNODE_cmu_us_awb_dur_NO_0437 439
DEF_STATIC_CONST_VAL_FLOAT(val_0274,-0.398624);
#define CTNODE_cmu_us_awb_dur_NO_0439 441
DEF_STATIC_CONST_VAL_FLOAT(val_0275,-0.507391);
#define CTNODE_cmu_us_awb_dur_NO_0434 442
DEF_STATIC_CONST_VAL_STRING(val_0276,"iy_93");
DEF_STATIC_CONST_VAL_FLOAT(val_0277,-0.545755);
#define CTNODE_cmu_us_awb_dur_NO_0442 444
DEF_STATIC_CONST_VAL_FLOAT(val_0278,-0.617876);
#define CTNODE_cmu_us_awb_dur_NO_0444 446
DEF_STATIC_CONST_VAL_FLOAT(val_0279,-0.617875);
#define CTNODE_cmu_us_awb_dur_NO_0446 448
DEF_STATIC_CONST_VAL_FLOAT(val_0280,-0.600906);
#define CTNODE_cmu_us_awb_dur_NO_0417 449
DEF_STATIC_CONST_VAL_STRING(val_0281,"ax");
DEF_STATIC_CONST_VAL_FLOAT(val_0282,1.035680);
#define CTNODE_cmu_us_awb_dur_NO_0450 452
DEF_STATIC_CONST_VAL_FLOAT(val_0283,0.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_0284,0.341604);
#define CTNODE_cmu_us_awb_dur_NO_0454 456
DEF_STATIC_CONST_VAL_FLOAT(val_0285,1.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0286,-0.410802);
#define CTNODE_cmu_us_awb_dur_NO_0458 460
DEF_STATIC_CONST_VAL_FLOAT(val_0287,-0.127974);
#define CTNODE_cmu_us_awb_dur_NO_0457 461
DEF_STATIC_CONST_VAL_FLOAT(val_0288,0.032306);
#define CTNODE_cmu_us_awb_dur_NO_0456 462
DEF_STATIC_CONST_VAL_FLOAT(val_0289,-0.413655);
#define CTNODE_cmu_us_awb_dur_NO_0462 464
DEF_STATIC_CONST_VAL_FLOAT(val_0290,-0.660879);
#define CTNODE_cmu_us_awb_dur_NO_0453 465
DEF_STATIC_CONST_VAL_FLOAT(val_0291,9.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0292,0.046531);
#define CTNODE_cmu_us_awb_dur_NO_0467 469
DEF_STATIC_CONST_VAL_FLOAT(val_0293,4.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0294,-0.359473);
#define CTNODE_cmu_us_awb_dur_NO_0471 473
DEF_STATIC_CONST_VAL_FLOAT(val_0295,-0.129769);
#define CTNODE_cmu_us_awb_dur_NO_0473 475
DEF_STATIC_CONST_VAL_FLOAT(val_0296,-0.181994);
#define CTNODE_cmu_us_awb_dur_NO_0470 476
DEF_STATIC_CONST_VAL_FLOAT(val_0297,-0.594337);
#define CTNODE_cmu_us_awb_dur_NO_0469 477
DEF_STATIC_CONST_VAL_FLOAT(val_0298,0.071990);
#define CTNODE_cmu_us_awb_dur_NO_0466 478
DEF_STATIC_CONST_VAL_FLOAT(val_0299,0.196736);
#define CTNODE_cmu_us_awb_dur_NO_0465 479
DEF_STATIC_CONST_VAL_FLOAT(val_0300,0.652241);
#define CTNODE_cmu_us_awb_dur_NO_0480 482
DEF_STATIC_CONST_VAL_FLOAT(val_0301,0.350936);
#define CTNODE_cmu_us_awb_dur_NO_0482 484
DEF_STATIC_CONST_VAL_FLOAT(val_0302,0.075110);
#define CTNODE_cmu_us_awb_dur_NO_0479 485
DEF_STATIC_CONST_VAL_FLOAT(val_0303,-0.059240);
#define CTNODE_cmu_us_awb_dur_NO_0452 486
DEF_STATIC_CONST_VAL_STRING(val_0304,"in");
DEF_STATIC_CONST_VAL_STRING(val_0305,"ao_16");
DEF_STATIC_CONST_VAL_FLOAT(val_0306,0.212500);
#define CTNODE_cmu_us_awb_dur_NO_0487 489
DEF_STATIC_CONST_VAL_FLOAT(val_0307,-0.385647);
#define CTNODE_cmu_us_awb_dur_NO_0489 491
DEF_STATIC_CONST_VAL_FLOAT(val_0308,-0.054709);
#define CTNODE_cmu_us_awb_dur_NO_0491 493
DEF_STATIC_CONST_VAL_FLOAT(val_0309,0.138905);
#define CTNODE_cmu_us_awb_dur_NO_0486 494
DEF_STATIC_CONST_VAL_STRING(val_0310,"aa");
DEF_STATIC_CONST_VAL_FLOAT(val_0311,0.680078);
#define CTNODE_cmu_us_awb_dur_NO_0497 499
DEF_STATIC_CONST_VAL_FLOAT(val_0312,0.154889);
#define CTNODE_cmu_us_awb_dur_NO_0496 500
DEF_STATIC_CONST_VAL_FLOAT(val_0313,1.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0314,-0.303524);
#define CTNODE_cmu_us_awb_dur_NO_0501 503
DEF_STATIC_CONST_VAL_FLOAT(val_0315,-0.101386);
#define CTNODE_cmu_us_awb_dur_NO_0500 504
DEF_STATIC_CONST_VAL_FLOAT(val_0316,0.087277);
#define CTNODE_cmu_us_awb_dur_NO_0495 505
DEF_STATIC_CONST_VAL_STRING(val_0317,"n_118");
DEF_STATIC_CONST_VAL_FLOAT(val_0318,-0.090038);
#define CTNODE_cmu_us_awb_dur_NO_0505 507
DEF_STATIC_CONST_VAL_FLOAT(val_0319,0.020410);
#define CTNODE_cmu_us_awb_dur_NO_0510 512
DEF_STATIC_CONST_VAL_FLOAT(val_0320,0.252305);
#define CTNODE_cmu_us_awb_dur_NO_0509 513
DEF_STATIC_CONST_VAL_FLOAT(val_0321,0.575870);
#define CTNODE_cmu_us_awb_dur_NO_0508 514
DEF_STATIC_CONST_VAL_FLOAT(val_0322,0.230660);
#define CTNODE_cmu_us_awb_dur_NO_0514 516
DEF_STATIC_CONST_VAL_FLOAT(val_0323,-0.101167);
#define CTNODE_cmu_us_awb_dur_NO_0507 517
DEF_STATIC_CONST_VAL_STRING(val_0324,"ow_126");
DEF_STATIC_CONST_VAL_FLOAT(val_0325,0.114987);
#define CTNODE_cmu_us_awb_dur_NO_0517 519
DEF_STATIC_CONST_VAL_STRING(val_0326,"single");
DEF_STATIC_CONST_VAL_FLOAT(val_0327,0.339771);
#define CTNODE_cmu_us_awb_dur_NO_0520 522
DEF_STATIC_CONST_VAL_FLOAT(val_0328,0.986203);
#define CTNODE_cmu_us_awb_dur_NO_0522 524
DEF_STATIC_CONST_VAL_FLOAT(val_0329,0.564907);
#define CTNODE_cmu_us_awb_dur_NO_0519 525
DEF_STATIC_CONST_VAL_FLOAT(val_0330,0.262842);
#define CTNODE_cmu_us_awb_dur_NO_0494 526
DEF_STATIC_CONST_VAL_FLOAT(val_0331,0.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_0332,0.180560);
#define CTNODE_cmu_us_awb_dur_NO_0528 530
DEF_STATIC_CONST_VAL_FLOAT(val_0333,-0.250968);
#define CTNODE_cmu_us_awb_dur_NO_0527 531
DEF_STATIC_CONST_VAL_FLOAT(val_0334,3.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0335,0.271173);
#define CTNODE_cmu_us_awb_dur_NO_0532 534
DEF_STATIC_CONST_VAL_FLOAT(val_0336,0.481804);
#define CTNODE_cmu_us_awb_dur_NO_0531 535
DEF_STATIC_CONST_VAL_FLOAT(val_0337,0.058636);
#define CTNODE_cmu_us_awb_dur_NO_0526 536
DEF_STATIC_CONST_VAL_FLOAT(val_0338,0.288124);
#define CTNODE_cmu_us_awb_dur_NO_0537 539
DEF_STATIC_CONST_VAL_FLOAT(val_0339,-0.024856);
#define CTNODE_cmu_us_awb_dur_NO_0539 541
DEF_STATIC_CONST_VAL_FLOAT(val_0340,-0.301715);
#define CTNODE_cmu_us_awb_dur_NO_0536 542
DEF_STATIC_CONST_VAL_FLOAT(val_0341,-0.449208);
#define CTNODE_cmu_us_awb_dur_NO_0449 543
DEF_STATIC_CONST_VAL_FLOAT(val_0342,-0.240626);
#define CTNODE_cmu_us_awb_dur_NO_0546 548
DEF_STATIC_CONST_VAL_FLOAT(val_0343,0.553337);
#define CTNODE_cmu_us_awb_dur_NO_0548 550
DEF_STATIC_CONST_VAL_FLOAT(val_0344,-0.123330);
#define CTNODE_cmu_us_awb_dur_NO_0550 552
DEF_STATIC_CONST_VAL_FLOAT(val_0345,0.364866);
#define CTNODE_cmu_us_awb_dur_NO_0545 553
DEF_STATIC_CONST_VAL_FLOAT(val_0346,0.151667);
#define CTNODE_cmu_us_awb_dur_NO_0553 555
DEF_STATIC_CONST_VAL_FLOAT(val_0347,0.333200);
#define CTNODE_cmu_us_awb_dur_NO_0555 557
DEF_STATIC_CONST_VAL_FLOAT(val_0348,0.415369);
#define CTNODE_cmu_us_awb_dur_NO_0557 559
DEF_STATIC_CONST_VAL_FLOAT(val_0349,0.639914);
#define CTNODE_cmu_us_awb_dur_NO_0560 562
DEF_STATIC_CONST_VAL_FLOAT(val_0350,0.660110);
#define CTNODE_cmu_us_awb_dur_NO_0559 563
DEF_STATIC_CONST_VAL_FLOAT(val_0351,0.893055);
#define CTNODE_cmu_us_awb_dur_NO_0544 564
DEF_STATIC_CONST_VAL_FLOAT(val_0352,7.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0353,-0.554305);
#define CTNODE_cmu_us_awb_dur_NO_0565 567
DEF_STATIC_CONST_VAL_FLOAT(val_0354,-0.364596);
#define CTNODE_cmu_us_awb_dur_NO_0564 568
DEF_STATIC_CONST_VAL_FLOAT(val_0355,-0.351573);
#define CTNODE_cmu_us_awb_dur_NO_0568 570
DEF_STATIC_CONST_VAL_FLOAT(val_0356,0.146275);
#define CTNODE_cmu_us_awb_dur_NO_0570 572
DEF_STATIC_CONST_VAL_FLOAT(val_0357,-0.099258);
#define CTNODE_cmu_us_awb_dur_NO_0543 573
DEF_STATIC_CONST_VAL_STRING(val_0358,"f_73");
DEF_STATIC_CONST_VAL_FLOAT(val_0359,-0.443490);
#define CTNODE_cmu_us_awb_dur_NO_0575 577
DEF_STATIC_CONST_VAL_FLOAT(val_0360,-0.011131);
#define CTNODE_cmu_us_awb_dur_NO_0574 578
DEF_STATIC_CONST_VAL_FLOAT(val_0361,-0.638727);
#define CTNODE_cmu_us_awb_dur_NO_0579 581
DEF_STATIC_CONST_VAL_FLOAT(val_0362,-0.690414);
#define CTNODE_cmu_us_awb_dur_NO_0578 582
DEF_STATIC_CONST_VAL_FLOAT(val_0363,-0.580619);
#define CTNODE_cmu_us_awb_dur_NO_0582 584
DEF_STATIC_CONST_VAL_FLOAT(val_0364,-0.345086);
#define CTNODE_cmu_us_awb_dur_NO_0573 585
DEF_STATIC_CONST_VAL_STRING(val_0365,"eh");
DEF_STATIC_CONST_VAL_FLOAT(val_0366,1.374780);
#define CTNODE_cmu_us_awb_dur_NO_0587 589
DEF_STATIC_CONST_VAL_FLOAT(val_0367,0.668926);
#define CTNODE_cmu_us_awb_dur_NO_0589 591
DEF_STATIC_CONST_VAL_FLOAT(val_0368,0.484560);
#define CTNODE_cmu_us_awb_dur_NO_0591 593
DEF_STATIC_CONST_VAL_FLOAT(val_0369,0.662166);
#define CTNODE_cmu_us_awb_dur_NO_0595 597
DEF_STATIC_CONST_VAL_FLOAT(val_0370,0.123574);
#define CTNODE_cmu_us_awb_dur_NO_0594 598
DEF_STATIC_CONST_VAL_FLOAT(val_0371,-0.116691);
#define CTNODE_cmu_us_awb_dur_NO_0593 599
DEF_STATIC_CONST_VAL_FLOAT(val_0372,2.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0373,0.173191);
#define CTNODE_cmu_us_awb_dur_NO_0600 602
DEF_STATIC_CONST_VAL_FLOAT(val_0374,-0.257634);
#define CTNODE_cmu_us_awb_dur_NO_0602 604
DEF_STATIC_CONST_VAL_FLOAT(val_0375,0.017999);
#define CTNODE_cmu_us_awb_dur_NO_0599 605
DEF_STATIC_CONST_VAL_FLOAT(val_0376,-0.303431);
#define CTNODE_cmu_us_awb_dur_NO_0586 606
DEF_STATIC_CONST_VAL_STRING(val_0377,"ng_123");
DEF_STATIC_CONST_VAL_FLOAT(val_0378,0.914292);
#define CTNODE_cmu_us_awb_dur_NO_0608 610
DEF_STATIC_CONST_VAL_FLOAT(val_0379,0.328113);
#define CTNODE_cmu_us_awb_dur_NO_0610 612
DEF_STATIC_CONST_VAL_FLOAT(val_0380,-0.115073);
#define CTNODE_cmu_us_awb_dur_NO_0607 613
DEF_STATIC_CONST_VAL_FLOAT(val_0381,1.089190);
#define CTNODE_cmu_us_awb_dur_NO_0615 617
DEF_STATIC_CONST_VAL_FLOAT(val_0382,0.128564);
#define CTNODE_cmu_us_awb_dur_NO_0618 620
DEF_STATIC_CONST_VAL_FLOAT(val_0383,0.039548);
#define CTNODE_cmu_us_awb_dur_NO_0620 622
DEF_STATIC_CONST_VAL_FLOAT(val_0384,-0.138060);
#define CTNODE_cmu_us_awb_dur_NO_0622 624
DEF_STATIC_CONST_VAL_FLOAT(val_0385,-0.302082);
#define CTNODE_cmu_us_awb_dur_NO_0617 625
DEF_STATIC_CONST_VAL_FLOAT(val_0386,0.159960);
#define CTNODE_cmu_us_awb_dur_NO_0626 628
DEF_STATIC_CONST_VAL_FLOAT(val_0387,0.551066);
#define CTNODE_cmu_us_awb_dur_NO_0625 629
DEF_STATIC_CONST_VAL_FLOAT(val_0388,0.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0389,0.047089);
#define CTNODE_cmu_us_awb_dur_NO_0630 632
DEF_STATIC_CONST_VAL_FLOAT(val_0390,0.320536);
#define CTNODE_cmu_us_awb_dur_NO_0629 633
DEF_STATIC_CONST_VAL_FLOAT(val_0391,-0.119589);
#define CTNODE_cmu_us_awb_dur_NO_0614 634
DEF_STATIC_CONST_VAL_FLOAT(val_0392,1.042490);
#define CTNODE_cmu_us_awb_dur_NO_0635 637
DEF_STATIC_CONST_VAL_FLOAT(val_0393,1.184970);
#define CTNODE_cmu_us_awb_dur_NO_0637 639
DEF_STATIC_CONST_VAL_FLOAT(val_0394,0.540633);
#define CTNODE_cmu_us_awb_dur_NO_0639 641
DEF_STATIC_CONST_VAL_STRING(val_0395,"ax_27");
DEF_STATIC_CONST_VAL_FLOAT(val_0396,-0.373527);
#define CTNODE_cmu_us_awb_dur_NO_0643 645
DEF_STATIC_CONST_VAL_FLOAT(val_0397,-0.547624);
#define CTNODE_cmu_us_awb_dur_NO_0642 646
DEF_STATIC_CONST_VAL_FLOAT(val_0398,0.268133);
#define CTNODE_cmu_us_awb_dur_NO_0646 648
DEF_STATIC_CONST_VAL_FLOAT(val_0399,-0.478479);
#define CTNODE_cmu_us_awb_dur_NO_0649 651
DEF_STATIC_CONST_VAL_FLOAT(val_0400,-0.278924);
#define CTNODE_cmu_us_awb_dur_NO_0648 652
DEF_STATIC_CONST_VAL_FLOAT(val_0401,0.015123);
#define CTNODE_cmu_us_awb_dur_NO_0641 653
DEF_STATIC_CONST_VAL_FLOAT(val_0402,0.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0403,0.208372);
#define CTNODE_cmu_us_awb_dur_NO_0655 657
DEF_STATIC_CONST_VAL_FLOAT(val_0404,0.708818);
#define CTNODE_cmu_us_awb_dur_NO_0654 658
DEF_STATIC_CONST_VAL_STRING(val_0405,"z_201");
DEF_STATIC_CONST_VAL_FLOAT(val_0406,0.586862);
#define CTNODE_cmu_us_awb_dur_NO_0659 661
DEF_STATIC_CONST_VAL_STRING(val_0407,"z");
DEF_STATIC_CONST_VAL_FLOAT(val_0408,-0.112717);
#define CTNODE_cmu_us_awb_dur_NO_0662 664
DEF_STATIC_CONST_VAL_FLOAT(val_0409,-0.417624);
#define CTNODE_cmu_us_awb_dur_NO_0661 665
DEF_STATIC_CONST_VAL_STRING(val_0410,"k");
DEF_STATIC_CONST_VAL_FLOAT(val_0411,-0.186980);
#define CTNODE_cmu_us_awb_dur_NO_0665 667
DEF_STATIC_CONST_VAL_STRING(val_0412,"b");
DEF_STATIC_CONST_VAL_FLOAT(val_0413,-0.207450);
#define CTNODE_cmu_us_awb_dur_NO_0667 669
DEF_STATIC_CONST_VAL_FLOAT(val_0414,0.013424);
#define CTNODE_cmu_us_awb_dur_NO_0671 673
DEF_STATIC_CONST_VAL_FLOAT(val_0415,0.473807);
#define CTNODE_cmu_us_awb_dur_NO_0670 674
DEF_STATIC_CONST_VAL_FLOAT(val_0416,-0.138922);
#define CTNODE_cmu_us_awb_dur_NO_0669 675
DEF_STATIC_CONST_VAL_FLOAT(val_0417,0.597787);
#define CTNODE_cmu_us_awb_dur_NO_0675 677
DEF_STATIC_CONST_VAL_FLOAT(val_0418,0.193422);
#define CTNODE_cmu_us_awb_dur_NO_0658 678
DEF_STATIC_CONST_VAL_FLOAT(val_0419,-0.294138);
#define CTNODE_cmu_us_awb_dur_NO_0679 681
DEF_STATIC_CONST_VAL_FLOAT(val_0420,0.538743);
#define CTNODE_cmu_us_awb_dur_NO_0682 684
DEF_STATIC_CONST_VAL_FLOAT(val_0421,0.200994);
#define CTNODE_cmu_us_awb_dur_NO_0684 686
DEF_STATIC_CONST_VAL_FLOAT(val_0422,0.063526);
#define CTNODE_cmu_us_awb_dur_NO_0681 687
DEF_STATIC_CONST_VAL_FLOAT(val_0423,-0.033761);
#define CTNODE_cmu_us_awb_dur_NO_0678 688
DEF_STATIC_CONST_VAL_FLOAT(val_0424,-0.477920);
#define CTNODE_cmu_us_awb_dur_NO_0690 692
DEF_STATIC_CONST_VAL_FLOAT(val_0425,-0.268482);
#define CTNODE_cmu_us_awb_dur_NO_0689 693
DEF_STATIC_CONST_VAL_STRING(val_0426,"ax_26");
DEF_STATIC_CONST_VAL_FLOAT(val_0427,-0.215904);
#define CTNODE_cmu_us_awb_dur_NO_0694 696
DEF_STATIC_CONST_VAL_FLOAT(val_0428,0.121101);
#define CTNODE_cmu_us_awb_dur_NO_0693 697
DEF_STATIC_CONST_VAL_FLOAT(val_0429,-0.416732);
#define CTNODE_cmu_us_awb_dur_NO_0697 699
DEF_STATIC_CONST_VAL_FLOAT(val_0430,-0.177063);
#define CTNODE_cmu_us_awb_dur_NO_0688 700
DEF_STATIC_CONST_VAL_FLOAT(val_0431,0.027513);
#define CTNODE_cmu_us_awb_dur_NO_0653 701
DEF_STATIC_CONST_VAL_STRING(val_0432,"dh_53");
DEF_STATIC_CONST_VAL_FLOAT(val_0433,3.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0434,-0.494046);
#define CTNODE_cmu_us_awb_dur_NO_0703 705
DEF_STATIC_CONST_VAL_FLOAT(val_0435,0.148854);
#define CTNODE_cmu_us_awb_dur_NO_0705 707
DEF_STATIC_CONST_VAL_FLOAT(val_0436,0.094844);
#define CTNODE_cmu_us_awb_dur_NO_0707 709
DEF_STATIC_CONST_VAL_FLOAT(val_0437,-0.155344);
#define CTNODE_cmu_us_awb_dur_NO_0709 711
DEF_STATIC_CONST_VAL_FLOAT(val_0438,-0.360980);
#define CTNODE_cmu_us_awb_dur_NO_0702 712
DEF_STATIC_CONST_VAL_FLOAT(val_0439,0.188466);
#define CTNODE_cmu_us_awb_dur_NO_0713 715
DEF_STATIC_CONST_VAL_FLOAT(val_0440,0.788779);
#define CTNODE_cmu_us_awb_dur_NO_0712 716
DEF_STATIC_CONST_VAL_FLOAT(val_0441,0.123821);
#define CTNODE_cmu_us_awb_dur_NO_0701 717
DEF_STATIC_CONST_VAL_FLOAT(val_0442,0.174367);
#define CTNODE_cmu_us_awb_dur_NO_0717 719
DEF_STATIC_CONST_VAL_FLOAT(val_0443,-0.325575);
#define CTNODE_cmu_us_awb_dur_NO_0720 722
DEF_STATIC_CONST_VAL_FLOAT(val_0444,-0.488453);
#define CTNODE_cmu_us_awb_dur_NO_0719 723
DEF_STATIC_CONST_VAL_FLOAT(val_0445,-0.490041);
#define CTNODE_cmu_us_awb_dur_NO_0724 726
DEF_STATIC_CONST_VAL_STRING(val_0446,"m");
DEF_STATIC_CONST_VAL_FLOAT(val_0447,-0.397903);
#define CTNODE_cmu_us_awb_dur_NO_0726 728
DEF_STATIC_CONST_VAL_FLOAT(val_0448,8.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0449,-0.280739);
#define CTNODE_cmu_us_awb_dur_NO_0728 730
DEF_STATIC_CONST_VAL_FLOAT(val_0450,-0.092722);
#define CTNODE_cmu_us_awb_dur_NO_0723 731
DEF_STATIC_CONST_VAL_FLOAT(val_0451,-0.233555);
#define CTNODE_cmu_us_awb_dur_NO_0735 737
DEF_STATIC_CONST_VAL_FLOAT(val_0452,-0.330061);
#define CTNODE_cmu_us_awb_dur_NO_0734 738
DEF_STATIC_CONST_VAL_FLOAT(val_0453,0.078569);
#define CTNODE_cmu_us_awb_dur_NO_0733 739
DEF_STATIC_CONST_VAL_FLOAT(val_0454,0.371011);
#define CTNODE_cmu_us_awb_dur_NO_0739 741
DEF_STATIC_CONST_VAL_FLOAT(val_0455,0.242210);
#define CTNODE_cmu_us_awb_dur_NO_0741 743
DEF_STATIC_CONST_VAL_FLOAT(val_0456,-0.223621);
#define CTNODE_cmu_us_awb_dur_NO_0732 744
DEF_STATIC_CONST_VAL_FLOAT(val_0457,0.058085);
#define CTNODE_cmu_us_awb_dur_NO_0744 746
DEF_STATIC_CONST_VAL_FLOAT(val_0458,-0.114271);
#define CTNODE_cmu_us_awb_dur_NO_0746 748
DEF_STATIC_CONST_VAL_FLOAT(val_0459,-0.301215);
#define CTNODE_cmu_us_awb_dur_NO_0748 750
DEF_STATIC_CONST_VAL_FLOAT(val_0460,-0.402991);
#define CTNODE_cmu_us_awb_dur_NO_0731 751
DEF_STATIC_CONST_VAL_FLOAT(val_0461,-0.428615);
#define CTNODE_cmu_us_awb_dur_NO_0751 753
DEF_STATIC_CONST_VAL_FLOAT(val_0462,-0.255457);
#define CTNODE_cmu_us_awb_dur_NO_0634 754
DEF_STATIC_CONST_VAL_STRING(val_0463,"ih_88");
DEF_STATIC_CONST_VAL_FLOAT(val_0464,-0.417126);
#define CTNODE_cmu_us_awb_dur_NO_0757 759
DEF_STATIC_CONST_VAL_FLOAT(val_0465,0.032295);
#define CTNODE_cmu_us_awb_dur_NO_0759 761
DEF_STATIC_CONST_VAL_FLOAT(val_0466,0.723116);
#define CTNODE_cmu_us_awb_dur_NO_0756 762
DEF_STATIC_CONST_VAL_FLOAT(val_0467,0.159088);
#define CTNODE_cmu_us_awb_dur_NO_0762 764
DEF_STATIC_CONST_VAL_FLOAT(val_0468,-0.501785);
#define CTNODE_cmu_us_awb_dur_NO_0764 766
DEF_STATIC_CONST_VAL_FLOAT(val_0469,0.106668);
#define CTNODE_cmu_us_awb_dur_NO_0766 768
DEF_STATIC_CONST_VAL_FLOAT(val_0470,-0.178785);
#define CTNODE_cmu_us_awb_dur_NO_0769 771
DEF_STATIC_CONST_VAL_FLOAT(val_0471,-0.553103);
#define CTNODE_cmu_us_awb_dur_NO_0768 772
DEF_STATIC_CONST_VAL_FLOAT(val_0472,-0.035031);
#define CTNODE_cmu_us_awb_dur_NO_0773 775
DEF_STATIC_CONST_VAL_FLOAT(val_0473,-0.109037);
#define CTNODE_cmu_us_awb_dur_NO_0775 777
DEF_STATIC_CONST_VAL_FLOAT(val_0474,-0.453979);
#define CTNODE_cmu_us_awb_dur_NO_0772 778
DEF_STATIC_CONST_VAL_FLOAT(val_0475,0.098561);
#define CTNODE_cmu_us_awb_dur_NO_0778 780
DEF_STATIC_CONST_VAL_FLOAT(val_0476,-0.138668);
#define CTNODE_cmu_us_awb_dur_NO_0755 781
DEF_STATIC_CONST_VAL_FLOAT(val_0477,-0.096997);
#define CTNODE_cmu_us_awb_dur_NO_0783 785
DEF_STATIC_CONST_VAL_FLOAT(val_0478,0.481865);
#define CTNODE_cmu_us_awb_dur_NO_0782 786
DEF_STATIC_CONST_VAL_FLOAT(val_0479,-0.325321);
#define CTNODE_cmu_us_awb_dur_NO_0786 788
DEF_STATIC_CONST_VAL_FLOAT(val_0480,-0.005968);
#define CTNODE_cmu_us_awb_dur_NO_0781 789
DEF_STATIC_CONST_VAL_STRING(val_0481,"pps");
DEF_STATIC_CONST_VAL_FLOAT(val_0482,0.165739);
#define CTNODE_cmu_us_awb_dur_NO_0789 791
DEF_STATIC_CONST_VAL_FLOAT(val_0483,0.084241);
#define CTNODE_cmu_us_awb_dur_NO_0791 793
DEF_STATIC_CONST_VAL_FLOAT(val_0484,-0.716723);
#define CTNODE_cmu_us_awb_dur_NO_0793 795
DEF_STATIC_CONST_VAL_FLOAT(val_0485,-0.587340);
#define CTNODE_cmu_us_awb_dur_NO_0795 797
DEF_STATIC_CONST_VAL_FLOAT(val_0486,0.009302);
#define CTNODE_cmu_us_awb_dur_NO_0797 799
DEF_STATIC_CONST_VAL_FLOAT(val_0487,-0.080231);
#define CTNODE_cmu_us_awb_dur_NO_0799 801
DEF_STATIC_CONST_VAL_STRING(val_0488,"final");
DEF_STATIC_CONST_VAL_FLOAT(val_0489,-0.207340);
#define CTNODE_cmu_us_awb_dur_NO_0804 806
DEF_STATIC_CONST_VAL_FLOAT(val_0490,-0.391905);
#define CTNODE_cmu_us_awb_dur_NO_0806 808
DEF_STATIC_CONST_VAL_FLOAT(val_0491,-0.573943);
#define CTNODE_cmu_us_awb_dur_NO_0803 809
DEF_STATIC_CONST_VAL_FLOAT(val_0492,-0.591717);
#define CTNODE_cmu_us_awb_dur_NO_0810 812
DEF_STATIC_CONST_VAL_FLOAT(val_0493,-0.228834);
#define CTNODE_cmu_us_awb_dur_NO_0809 813
DEF_STATIC_CONST_VAL_FLOAT(val_0494,-0.368367);
#define CTNODE_cmu_us_awb_dur_NO_0815 817
DEF_STATIC_CONST_VAL_FLOAT(val_0495,-0.526095);
#define CTNODE_cmu_us_awb_dur_NO_0814 818
DEF_STATIC_CONST_VAL_FLOAT(val_0496,-0.208173);
#define CTNODE_cmu_us_awb_dur_NO_0813 819
DEF_STATIC_CONST_VAL_FLOAT(val_0497,12.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0498,-0.090911);
#define CTNODE_cmu_us_awb_dur_NO_0821 823
DEF_STATIC_CONST_VAL_FLOAT(val_0499,-0.339571);
#define CTNODE_cmu_us_awb_dur_NO_0820 824
DEF_STATIC_CONST_VAL_FLOAT(val_0500,0.195694);
#define CTNODE_cmu_us_awb_dur_NO_0824 826
DEF_STATIC_CONST_VAL_FLOAT(val_0501,-0.206182);
#define CTNODE_cmu_us_awb_dur_NO_0819 827
DEF_STATIC_CONST_VAL_FLOAT(val_0502,-0.347195);
#define CTNODE_cmu_us_awb_dur_NO_0802 828
DEF_STATIC_CONST_VAL_FLOAT(val_0503,-0.508084);
#define CTNODE_cmu_us_awb_dur_NO_0801 829
DEF_STATIC_CONST_VAL_FLOAT(val_0504,-0.175116);
#define CTNODE_cmu_us_awb_dur_NO_0829 831
DEF_STATIC_CONST_VAL_FLOAT(val_0505,-0.683948);
#define CTNODE_cmu_us_awb_dur_NO_0831 833
DEF_STATIC_CONST_VAL_FLOAT(val_0506,-0.467017);
#define CTNODE_cmu_us_awb_dur_NO_0754 834
DEF_STATIC_CONST_VAL_STRING(val_0507,"v");
DEF_STATIC_CONST_VAL_FLOAT(val_0508,-0.273765);
#define CTNODE_cmu_us_awb_dur_NO_0838 840
DEF_STATIC_CONST_VAL_FLOAT(val_0509,0.035751);
#define CTNODE_cmu_us_awb_dur_NO_0837 841
DEF_STATIC_CONST_VAL_FLOAT(val_0510,-0.431187);
#define CTNODE_cmu_us_awb_dur_NO_0836 842
DEF_STATIC_CONST_VAL_STRING(val_0511,"t_164");
DEF_STATIC_CONST_VAL_FLOAT(val_0512,-0.380865);
#define CTNODE_cmu_us_awb_dur_NO_0842 844
DEF_STATIC_CONST_VAL_FLOAT(val_0513,-0.247030);
#define CTNODE_cmu_us_awb_dur_NO_0844 846
DEF_STATIC_CONST_VAL_FLOAT(val_0514,0.176798);
#define CTNODE_cmu_us_awb_dur_NO_0847 849
DEF_STATIC_CONST_VAL_FLOAT(val_0515,0.797629);
#define CTNODE_cmu_us_awb_dur_NO_0849 851
DEF_STATIC_CONST_VAL_FLOAT(val_0516,0.322092);
#define CTNODE_cmu_us_awb_dur_NO_0846 852
DEF_STATIC_CONST_VAL_FLOAT(val_0517,0.514961);
#define CTNODE_cmu_us_awb_dur_NO_0852 854
DEF_STATIC_CONST_VAL_FLOAT(val_0518,0.039575);
#define CTNODE_cmu_us_awb_dur_NO_0855 857
DEF_STATIC_CONST_VAL_FLOAT(val_0519,0.353755);
#define CTNODE_cmu_us_awb_dur_NO_0854 858
DEF_STATIC_CONST_VAL_FLOAT(val_0520,-0.171769);
#define CTNODE_cmu_us_awb_dur_NO_0835 859
DEF_STATIC_CONST_VAL_STRING(val_0521,"g_76");
DEF_STATIC_CONST_VAL_FLOAT(val_0522,0.375458);
#define CTNODE_cmu_us_awb_dur_NO_0859 861
DEF_STATIC_CONST_VAL_FLOAT(val_0523,-0.410983);
#define CTNODE_cmu_us_awb_dur_NO_0862 864
DEF_STATIC_CONST_VAL_FLOAT(val_0524,-0.259335);
#define CTNODE_cmu_us_awb_dur_NO_0861 865
DEF_STATIC_CONST_VAL_FLOAT(val_0525,-0.451172);
#define CTNODE_cmu_us_awb_dur_NO_0867 869
DEF_STATIC_CONST_VAL_FLOAT(val_0526,-0.314140);
#define CTNODE_cmu_us_awb_dur_NO_0866 870
DEF_STATIC_CONST_VAL_FLOAT(val_0527,0.122632);
#define CTNODE_cmu_us_awb_dur_NO_0870 872
DEF_STATIC_CONST_VAL_FLOAT(val_0528,-0.187086);
#define CTNODE_cmu_us_awb_dur_NO_0865 873
DEF_STATIC_CONST_VAL_FLOAT(val_0529,0.098979);
#define CTNODE_cmu_us_awb_dur_NO_0875 877
DEF_STATIC_CONST_VAL_FLOAT(val_0530,-0.116297);
#define CTNODE_cmu_us_awb_dur_NO_0874 878
DEF_STATIC_CONST_VAL_STRING(val_0531,"pau_161");
DEF_STATIC_CONST_VAL_FLOAT(val_0532,-0.597136);
#define CTNODE_cmu_us_awb_dur_NO_0879 881
DEF_STATIC_CONST_VAL_FLOAT(val_0533,-0.442459);
#define CTNODE_cmu_us_awb_dur_NO_0878 882
DEF_STATIC_CONST_VAL_FLOAT(val_0534,-0.300532);
#define CTNODE_cmu_us_awb_dur_NO_0882 884
DEF_STATIC_CONST_VAL_FLOAT(val_0535,-0.168542);
#define CTNODE_cmu_us_awb_dur_NO_0884 886
DEF_STATIC_CONST_VAL_FLOAT(val_0536,-0.047187);
#define CTNODE_cmu_us_awb_dur_NO_0873 887
DEF_STATIC_CONST_VAL_FLOAT(val_0537,0.990277);
#define CTNODE_cmu_us_awb_dur_NO_0888 890
DEF_STATIC_CONST_VAL_FLOAT(val_0538,-0.277596);
#define CTNODE_cmu_us_awb_dur_NO_0890 892
DEF_STATIC_CONST_VAL_FLOAT(val_0539,0.325431);
#define CTNODE_cmu_us_awb_dur_NO_0893 895
DEF_STATIC_CONST_VAL_FLOAT(val_0540,-0.309056);
#define CTNODE_cmu_us_awb_dur_NO_0896 898
DEF_STATIC_CONST_VAL_FLOAT(val_0541,-0.076358);
#define CTNODE_cmu_us_awb_dur_NO_0895 899
DEF_STATIC_CONST_VAL_FLOAT(val_0542,0.120001);
#define CTNODE_cmu_us_awb_dur_NO_0892 900
DEF_STATIC_CONST_VAL_FLOAT(val_0543,0.288309);
#define CTNODE_cmu_us_awb_dur_NO_0887 901
DEF_STATIC_CONST_VAL_FLOAT(val_0544,-0.392778);
#define CTNODE_cmu_us_awb_dur_NO_0902 904
DEF_STATIC_CONST_VAL_FLOAT(val_0545,-0.416264);
#define CTNODE_cmu_us_awb_dur_NO_0901 905
DEF_STATIC_CONST_VAL_FLOAT(val_0546,-0.427890);
#define CTNODE_cmu_us_awb_dur_NO_0906 908
DEF_STATIC_CONST_VAL_FLOAT(val_0547,-0.289601);
#define CTNODE_cmu_us_awb_dur_NO_0908 910
DEF_STATIC_CONST_VAL_FLOAT(val_0548,-0.098360);
#define CTNODE_cmu_us_awb_dur_NO_0910 912
DEF_STATIC_CONST_VAL_FLOAT(val_0549,0.035177);
#define CTNODE_cmu_us_awb_dur_NO_0905 913
DEF_STATIC_CONST_VAL_STRING(val_0550,"p");
DEF_STATIC_CONST_VAL_FLOAT(val_0551,0.005267);
#define CTNODE_cmu_us_awb_dur_NO_0914 916
DEF_STATIC_CONST_VAL_FLOAT(val_0552,-0.295573);
#define CTNODE_cmu_us_awb_dur_NO_0917 919
DEF_STATIC_CONST_VAL_FLOAT(val_0553,-0.024186);
#define CTNODE_cmu_us_awb_dur_NO_0916 920
DEF_STATIC_CONST_VAL_FLOAT(val_0554,10.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0555,-0.322751);
#define CTNODE_cmu_us_awb_dur_NO_0920 922
DEF_STATIC_CONST_VAL_FLOAT(val_0556,-0.462189);
#define CTNODE_cmu_us_awb_dur_NO_0913 923
DEF_STATIC_CONST_VAL_FLOAT(val_0557,-0.369678);
#define CTNODE_cmu_us_awb_dur_NO_0923 925
DEF_STATIC_CONST_VAL_FLOAT(val_0558,-0.062432);
#define CTNODE_cmu_us_awb_dur_NO_0927 929
DEF_STATIC_CONST_VAL_FLOAT(val_0559,0.444467);
#define CTNODE_cmu_us_awb_dur_NO_0929 931
DEF_STATIC_CONST_VAL_FLOAT(val_0560,0.064548);
#define CTNODE_cmu_us_awb_dur_NO_0926 932
DEF_STATIC_CONST_VAL_FLOAT(val_0561,-0.369644);
#define CTNODE_cmu_us_awb_dur_NO_0934 936
DEF_STATIC_CONST_VAL_FLOAT(val_0562,-0.069755);
#define CTNODE_cmu_us_awb_dur_NO_0936 938
DEF_STATIC_CONST_VAL_FLOAT(val_0563,-0.215339);
#define CTNODE_cmu_us_awb_dur_NO_0933 939
DEF_STATIC_CONST_VAL_FLOAT(val_0564,0.080270);
#define CTNODE_cmu_us_awb_dur_NO_0941 943
DEF_STATIC_CONST_VAL_FLOAT(val_0565,-0.136994);
#define CTNODE_cmu_us_awb_dur_NO_0940 944
DEF_STATIC_CONST_VAL_FLOAT(val_0566,-0.094771);
#define CTNODE_cmu_us_awb_dur_NO_0944 946
DEF_STATIC_CONST_VAL_FLOAT(val_0567,-0.155682);
#define CTNODE_cmu_us_awb_dur_NO_0946 948
DEF_STATIC_CONST_VAL_FLOAT(val_0568,-0.308692);
#define CTNODE_cmu_us_awb_dur_NO_0939 949
DEF_STATIC_CONST_VAL_FLOAT(val_0569,-0.149594);
#define CTNODE_cmu_us_awb_dur_NO_0949 951
DEF_STATIC_CONST_VAL_FLOAT(val_0570,0.170557);
#define CTNODE_cmu_us_awb_dur_NO_0951 953
DEF_STATIC_CONST_VAL_FLOAT(val_0571,-0.067938);
#define CTNODE_cmu_us_awb_dur_NO_0932 954
DEF_STATIC_CONST_VAL_FLOAT(val_0572,-0.325206);
#define CTNODE_cmu_us_awb_dur_NO_0954 956
DEF_STATIC_CONST_VAL_FLOAT(val_0573,0.280322);
#define CTNODE_cmu_us_awb_dur_NO_0958 960
DEF_STATIC_CONST_VAL_FLOAT(val_0574,0.290643);
#define CTNODE_cmu_us_awb_dur_NO_0961 963
DEF_STATIC_CONST_VAL_FLOAT(val_0575,-0.048317);
#define CTNODE_cmu_us_awb_dur_NO_0963 965
DEF_STATIC_CONST_VAL_FLOAT(val_0576,-0.178466);
#define CTNODE_cmu_us_awb_dur_NO_0960 966
DEF_STATIC_CONST_VAL_FLOAT(val_0577,-0.512734);
#define CTNODE_cmu_us_awb_dur_NO_0966 968
DEF_STATIC_CONST_VAL_FLOAT(val_0578,0.082138);
#define CTNODE_cmu_us_awb_dur_NO_0968 970
DEF_STATIC_CONST_VAL_FLOAT(val_0579,-0.369882);
#define CTNODE_cmu_us_awb_dur_NO_0970 972
DEF_STATIC_CONST_VAL_FLOAT(val_0580,-0.169848);
#define CTNODE_cmu_us_awb_dur_NO_0957 973
DEF_STATIC_CONST_VAL_STRING(val_0581,"ae_6");
DEF_STATIC_CONST_VAL_FLOAT(val_0582,0.077930);
#define CTNODE_cmu_us_awb_dur_NO_0974 976
DEF_STATIC_CONST_VAL_FLOAT(val_0583,-0.240365);
#define CTNODE_cmu_us_awb_dur_NO_0976 978
DEF_STATIC_CONST_VAL_FLOAT(val_0584,-0.061165);
#define CTNODE_cmu_us_awb_dur_NO_0973 979
DEF_STATIC_CONST_VAL_FLOAT(val_0585,-0.145416);
#define CTNODE_cmu_us_awb_dur_NO_0979 981
DEF_STATIC_CONST_VAL_FLOAT(val_0586,0.473039);
#define CTNODE_cmu_us_awb_dur_NO_0981 983
DEF_STATIC_CONST_VAL_FLOAT(val_0587,0.537597);
#define CTNODE_cmu_us_awb_dur_NO_0984 986
DEF_STATIC_CONST_VAL_FLOAT(val_0588,0.215622);
#define CTNODE_cmu_us_awb_dur_NO_0983 987
DEF_STATIC_CONST_VAL_FLOAT(val_0589,-0.009238);
#define CTNODE_cmu_us_awb_dur_NO_0956 988
DEF_STATIC_CONST_VAL_FLOAT(val_0590,-0.247286);
#define CTNODE_cmu_us_awb_dur_NO_0925 989
DEF_STATIC_CONST_VAL_FLOAT(val_0591,7.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0592,-0.056060);
#define CTNODE_cmu_us_awb_dur_NO_0989 991
DEF_STATIC_CONST_VAL_FLOAT(val_0593,0.550575);
#define CTNODE_cmu_us_awb_dur_NO_0991 993
DEF_STATIC_CONST_VAL_FLOAT(val_0594,0.184782);
#define CTNODE_cmu_us_awb_dur_NO_0834 994
DEF_STATIC_CONST_VAL_FLOAT(val_0595,-0.575611);
#define CTNODE_cmu_us_awb_dur_NO_0994 996
DEF_STATIC_CONST_VAL_FLOAT(val_0596,9.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0597,-0.407996);
#define CTNODE_cmu_us_awb_dur_NO_0999 1001
DEF_STATIC_CONST_VAL_FLOAT(val_0598,-0.550304);
#define CTNODE_cmu_us_awb_dur_NO_0998 1002
DEF_STATIC_CONST_VAL_FLOAT(val_0599,-0.003468);
#define CTNODE_cmu_us_awb_dur_NO_1002 1004
DEF_STATIC_CONST_VAL_FLOAT(val_0600,-0.530767);
#define CTNODE_cmu_us_awb_dur_NO_1004 1006
DEF_STATIC_CONST_VAL_FLOAT(val_0601,-0.239390);
#define CTNODE_cmu_us_awb_dur_NO_1006 1008
DEF_STATIC_CONST_VAL_FLOAT(val_0602,-0.424566);
#define CTNODE_cmu_us_awb_dur_NO_0997 1009
DEF_STATIC_CONST_VAL_FLOAT(val_0603,0.110533);
#define CTNODE_cmu_us_awb_dur_NO_1009 1011
DEF_STATIC_CONST_VAL_FLOAT(val_0604,-0.375932);
#define CTNODE_cmu_us_awb_dur_NO_0996 1012
DEF_STATIC_CONST_VAL_FLOAT(val_0605,-0.605665);
#define CTNODE_cmu_us_awb_dur_NO_1012 1014
DEF_STATIC_CONST_VAL_FLOAT(val_0606,12.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0607,-0.174525);
#define CTNODE_cmu_us_awb_dur_NO_1018 1020
DEF_STATIC_CONST_VAL_FLOAT(val_0608,-0.446492);
#define CTNODE_cmu_us_awb_dur_NO_1017 1021
DEF_STATIC_CONST_VAL_FLOAT(val_0609,-0.038281);
#define CTNODE_cmu_us_awb_dur_NO_1016 1022
DEF_STATIC_CONST_VAL_FLOAT(val_0610,0.109300);
#define CTNODE_cmu_us_awb_dur_NO_1015 1023
DEF_STATIC_CONST_VAL_FLOAT(val_0611,-0.524543);
#define CTNODE_cmu_us_awb_dur_NO_1023 1025
DEF_STATIC_CONST_VAL_FLOAT(val_0612,-0.239461);
#define CTNODE_cmu_us_awb_dur_NO_1026 1028
DEF_STATIC_CONST_VAL_FLOAT(val_0613,-0.341155);
#define CTNODE_cmu_us_awb_dur_NO_1028 1030
DEF_STATIC_CONST_VAL_FLOAT(val_0614,-0.482479);
#define CTNODE_cmu_us_awb_dur_NO_1025 1031
DEF_STATIC_CONST_VAL_FLOAT(val_0615,-0.158664);
#define CTNODE_cmu_us_awb_dur_NO_1032 1034
DEF_STATIC_CONST_VAL_FLOAT(val_0616,0.168682);
#define CTNODE_cmu_us_awb_dur_NO_1031 1035
DEF_STATIC_CONST_VAL_FLOAT(val_0617,-0.439374);
#define CTNODE_cmu_us_awb_dur_NO_1035 1037
DEF_STATIC_CONST_VAL_FLOAT(val_0618,4.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_0619,-0.084829);
#define CTNODE_cmu_us_awb_dur_NO_1037 1039
DEF_STATIC_CONST_VAL_FLOAT(val_0620,-0.312747);
#define CTNODE_cmu_us_awb_dur_NO_1039 1041
DEF_STATIC_CONST_VAL_FLOAT(val_0621,-0.193683);
#define CTNODE_cmu_us_awb_dur_NO_1014 1042
DEF_STATIC_CONST_VAL_FLOAT(val_0622,-0.400117);
#define CTNODE_cmu_us_awb_dur_NO_1046 1048
DEF_STATIC_CONST_VAL_FLOAT(val_0623,-0.065442);
#define CTNODE_cmu_us_awb_dur_NO_1048 1050
DEF_STATIC_CONST_VAL_FLOAT(val_0624,-0.322935);
#define CTNODE_cmu_us_awb_dur_NO_1051 1053
DEF_STATIC_CONST_VAL_FLOAT(val_0625,-0.053537);
#define CTNODE_cmu_us_awb_dur_NO_1053 1055
DEF_STATIC_CONST_VAL_FLOAT(val_0626,-0.219244);
#define CTNODE_cmu_us_awb_dur_NO_1050 1056
DEF_STATIC_CONST_VAL_FLOAT(val_0627,-0.383972);
#define CTNODE_cmu_us_awb_dur_NO_1045 1057
DEF_STATIC_CONST_VAL_FLOAT(val_0628,4.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0629,3.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_0630,-0.078765);
#define CTNODE_cmu_us_awb_dur_NO_1058 1060
DEF_STATIC_CONST_VAL_FLOAT(val_0631,0.254367);
#define CTNODE_cmu_us_awb_dur_NO_1057 1061
DEF_STATIC_CONST_VAL_FLOAT(val_0632,-0.235108);
#define CTNODE_cmu_us_awb_dur_NO_1044 1062
DEF_STATIC_CONST_VAL_FLOAT(val_0633,0.112674);
#define CTNODE_cmu_us_awb_dur_NO_1062 1064
DEF_STATIC_CONST_VAL_FLOAT(val_0634,-0.135600);
#define CTNODE_cmu_us_awb_dur_NO_1043 1065
DEF_STATIC_CONST_VAL_FLOAT(val_0635,0.148552);
#define CTNODE_cmu_us_awb_dur_NO_1042 1066
DEF_STATIC_CONST_VAL_STRING(val_0636,"n_116");
DEF_STATIC_CONST_VAL_FLOAT(val_0637,-0.333628);
#define CTNODE_cmu_us_awb_dur_NO_1068 1070
DEF_STATIC_CONST_VAL_FLOAT(val_0638,-0.107893);
#define CTNODE_cmu_us_awb_dur_NO_1071 1073
DEF_STATIC_CONST_VAL_FLOAT(val_0639,-0.279472);
#define CTNODE_cmu_us_awb_dur_NO_1070 1074
DEF_STATIC_CONST_VAL_FLOAT(val_0640,-0.418674);
#define CTNODE_cmu_us_awb_dur_NO_1075 1077
DEF_STATIC_CONST_VAL_FLOAT(val_0641,0.014758);
#define CTNODE_cmu_us_awb_dur_NO_1074 1078
DEF_STATIC_CONST_VAL_FLOAT(val_0642,-0.152086);
#define CTNODE_cmu_us_awb_dur_NO_1078 1080
DEF_STATIC_CONST_VAL_FLOAT(val_0643,-0.171600);
#define CTNODE_cmu_us_awb_dur_NO_1080 1082
DEF_STATIC_CONST_VAL_FLOAT(val_0644,-0.114165);
#define CTNODE_cmu_us_awb_dur_NO_1082 1084
DEF_STATIC_CONST_VAL_FLOAT(val_0645,0.029845);
#define CTNODE_cmu_us_awb_dur_NO_1084 1086
DEF_STATIC_CONST_VAL_FLOAT(val_0646,0.670336);
#define CTNODE_cmu_us_awb_dur_NO_1086 1088
DEF_STATIC_CONST_VAL_FLOAT(val_0647,0.417802);
#define CTNODE_cmu_us_awb_dur_NO_1088 1090
DEF_STATIC_CONST_VAL_FLOAT(val_0648,0.004174);
#define CTNODE_cmu_us_awb_dur_NO_1090 1092
DEF_STATIC_CONST_VAL_FLOAT(val_0649,0.054510);
#define CTNODE_cmu_us_awb_dur_NO_1092 1094
DEF_STATIC_CONST_VAL_FLOAT(val_0650,0.259036);
#define CTNODE_cmu_us_awb_dur_NO_1094 1096
DEF_STATIC_CONST_VAL_FLOAT(val_0651,0.464957);
#define CTNODE_cmu_us_awb_dur_NO_1067 1097
DEF_STATIC_CONST_VAL_FLOAT(val_0652,0.438398);
#define CTNODE_cmu_us_awb_dur_NO_1066 1098
DEF_STATIC_CONST_VAL_STRING(val_0653,"dh");
DEF_STATIC_CONST_VAL_FLOAT(val_0654,-0.459696);
#define CTNODE_cmu_us_awb_dur_NO_1098 1100
DEF_STATIC_CONST_VAL_FLOAT(val_0655,-0.012831);
#define CTNODE_cmu_us_awb_dur_NO_1100 1102
DEF_STATIC_CONST_VAL_FLOAT(val_0656,-0.327551);
#define CTNODE_cmu_us_awb_dur_NO_0613 1103
DEF_STATIC_CONST_VAL_FLOAT(val_0657,-0.105515);
#define CTNODE_cmu_us_awb_dur_NO_1104 1106
DEF_STATIC_CONST_VAL_FLOAT(val_0658,-0.820360);
#define CTNODE_cmu_us_awb_dur_NO_1107 1109
DEF_STATIC_CONST_VAL_FLOAT(val_0659,-0.555920);
#define CTNODE_cmu_us_awb_dur_NO_1106 1110
DEF_STATIC_CONST_VAL_FLOAT(val_0660,-0.972613);
#define CTNODE_cmu_us_awb_dur_NO_1103 1111
DEF_STATIC_CONST_VAL_STRING(val_0661,"ae_7");
DEF_STATIC_CONST_VAL_FLOAT(val_0662,0.938417);
#define CTNODE_cmu_us_awb_dur_NO_1112 1114
DEF_STATIC_CONST_VAL_STRING(val_0663,"ih_87");
DEF_STATIC_CONST_VAL_FLOAT(val_0664,0.095840);
#define CTNODE_cmu_us_awb_dur_NO_1116 1118
DEF_STATIC_CONST_VAL_FLOAT(val_0665,0.572791);
#define CTNODE_cmu_us_awb_dur_NO_1115 1119
DEF_STATIC_CONST_VAL_FLOAT(val_0666,1.047110);
#define CTNODE_cmu_us_awb_dur_NO_1114 1120
DEF_STATIC_CONST_VAL_STRING(val_0667,"aa_2");
DEF_STATIC_CONST_VAL_FLOAT(val_0668,0.763890);
#define CTNODE_cmu_us_awb_dur_NO_1121 1123
DEF_STATIC_CONST_VAL_FLOAT(val_0669,0.506670);
#define CTNODE_cmu_us_awb_dur_NO_1120 1124
DEF_STATIC_CONST_VAL_FLOAT(val_0670,1.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0671,-0.209741);
#define CTNODE_cmu_us_awb_dur_NO_1125 1127
DEF_STATIC_CONST_VAL_FLOAT(val_0672,-0.555603);
#define CTNODE_cmu_us_awb_dur_NO_1124 1128
DEF_STATIC_CONST_VAL_STRING(val_0673,"ah_12");
DEF_STATIC_CONST_VAL_FLOAT(val_0674,0.573320);
#define CTNODE_cmu_us_awb_dur_NO_1128 1130
DEF_STATIC_CONST_VAL_FLOAT(val_0675,0.677024);
#define CTNODE_cmu_us_awb_dur_NO_1131 1133
DEF_STATIC_CONST_VAL_FLOAT(val_0676,0.214409);
#define CTNODE_cmu_us_awb_dur_NO_1130 1134
DEF_STATIC_CONST_VAL_FLOAT(val_0677,0.596348);
#define CTNODE_cmu_us_awb_dur_NO_1134 1136
DEF_STATIC_CONST_VAL_FLOAT(val_0678,0.465560);
#define CTNODE_cmu_us_awb_dur_NO_1136 1138
DEF_STATIC_CONST_VAL_FLOAT(val_0679,-0.590899);
#define CTNODE_cmu_us_awb_dur_NO_1140 1142
DEF_STATIC_CONST_VAL_FLOAT(val_0680,-0.132831);
#define CTNODE_cmu_us_awb_dur_NO_1139 1143
DEF_STATIC_CONST_VAL_STRING(val_0681,"k_103");
DEF_STATIC_CONST_VAL_FLOAT(val_0682,-0.406112);
#define CTNODE_cmu_us_awb_dur_NO_1143 1145
DEF_STATIC_CONST_VAL_STRING(val_0683,"ae");
DEF_STATIC_CONST_VAL_FLOAT(val_0684,-0.438849);
#define CTNODE_cmu_us_awb_dur_NO_1145 1147
DEF_STATIC_CONST_VAL_FLOAT(val_0685,-0.193690);
#define CTNODE_cmu_us_awb_dur_NO_1148 1150
DEF_STATIC_CONST_VAL_FLOAT(val_0686,0.385748);
#define CTNODE_cmu_us_awb_dur_NO_1150 1152
DEF_STATIC_CONST_VAL_FLOAT(val_0687,0.277065);
#define CTNODE_cmu_us_awb_dur_NO_1153 1155
DEF_STATIC_CONST_VAL_FLOAT(val_0688,0.159618);
#define CTNODE_cmu_us_awb_dur_NO_1156 1158
DEF_STATIC_CONST_VAL_FLOAT(val_0689,3.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0690,-0.072863);
#define CTNODE_cmu_us_awb_dur_NO_1159 1161
DEF_STATIC_CONST_VAL_FLOAT(val_0691,-0.342634);
#define CTNODE_cmu_us_awb_dur_NO_1158 1162
DEF_STATIC_CONST_VAL_FLOAT(val_0692,0.038458);
#define CTNODE_cmu_us_awb_dur_NO_1155 1163
DEF_STATIC_CONST_VAL_FLOAT(val_0693,0.291005);
#define CTNODE_cmu_us_awb_dur_NO_1152 1164
DEF_STATIC_CONST_VAL_FLOAT(val_0694,-0.212340);
#define CTNODE_cmu_us_awb_dur_NO_1147 1165
DEF_STATIC_CONST_VAL_FLOAT(val_0695,-0.469707);
#define CTNODE_cmu_us_awb_dur_NO_1165 1167
DEF_STATIC_CONST_VAL_FLOAT(val_0696,-0.389794);
#define CTNODE_cmu_us_awb_dur_NO_1167 1169
DEF_STATIC_CONST_VAL_FLOAT(val_0697,-0.268264);
#define CTNODE_cmu_us_awb_dur_NO_1170 1172
DEF_STATIC_CONST_VAL_FLOAT(val_0698,0.457929);
#define CTNODE_cmu_us_awb_dur_NO_1172 1174
DEF_STATIC_CONST_VAL_FLOAT(val_0699,0.089649);
#define CTNODE_cmu_us_awb_dur_NO_1169 1175
DEF_STATIC_CONST_VAL_FLOAT(val_0700,5.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0701,0.191344);
#define CTNODE_cmu_us_awb_dur_NO_1176 1178
DEF_STATIC_CONST_VAL_FLOAT(val_0702,-0.190526);
#define CTNODE_cmu_us_awb_dur_NO_1178 1180
DEF_STATIC_CONST_VAL_FLOAT(val_0703,0.032626);
#define CTNODE_cmu_us_awb_dur_NO_1175 1181
DEF_STATIC_CONST_VAL_FLOAT(val_0704,-0.299595);
#define CTNODE_cmu_us_awb_dur_NO_1183 1185
DEF_STATIC_CONST_VAL_FLOAT(val_0705,-0.110495);
#define CTNODE_cmu_us_awb_dur_NO_1182 1186
DEF_STATIC_CONST_VAL_FLOAT(val_0706,-0.608068);
#define CTNODE_cmu_us_awb_dur_NO_1181 1187
DEF_STATIC_CONST_VAL_FLOAT(val_0707,-0.010987);
#define CTNODE_cmu_us_awb_dur_NO_1138 1188
DEF_STATIC_CONST_VAL_FLOAT(val_0708,0.232336);
#define CTNODE_cmu_us_awb_dur_NO_1190 1192
DEF_STATIC_CONST_VAL_FLOAT(val_0709,-0.143803);
#define CTNODE_cmu_us_awb_dur_NO_1189 1193
DEF_STATIC_CONST_VAL_FLOAT(val_0710,-0.143391);
#define CTNODE_cmu_us_awb_dur_NO_1195 1197
DEF_STATIC_CONST_VAL_FLOAT(val_0711,-0.361848);
#define CTNODE_cmu_us_awb_dur_NO_1194 1198
DEF_STATIC_CONST_VAL_FLOAT(val_0712,-0.417281);
#define CTNODE_cmu_us_awb_dur_NO_1193 1199
DEF_STATIC_CONST_VAL_FLOAT(val_0713,-0.133205);
#define CTNODE_cmu_us_awb_dur_NO_1188 1200
DEF_STATIC_CONST_VAL_FLOAT(val_0714,-0.178052);
#define CTNODE_cmu_us_awb_dur_NO_1201 1203
DEF_STATIC_CONST_VAL_FLOAT(val_0715,-0.473690);
#define CTNODE_cmu_us_awb_dur_NO_1200 1204
DEF_STATIC_CONST_VAL_STRING(val_0716,"iy_92");
DEF_STATIC_CONST_VAL_FLOAT(val_0717,0.589647);
#define CTNODE_cmu_us_awb_dur_NO_1204 1206
DEF_STATIC_CONST_VAL_STRING(val_0718,"k_101");
DEF_STATIC_CONST_VAL_FLOAT(val_0719,-0.251501);
#define CTNODE_cmu_us_awb_dur_NO_1207 1209
DEF_STATIC_CONST_VAL_FLOAT(val_0720,-0.214435);
#define CTNODE_cmu_us_awb_dur_NO_1210 1212
DEF_STATIC_CONST_VAL_FLOAT(val_0721,8.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0722,-0.087685);
#define CTNODE_cmu_us_awb_dur_NO_1212 1214
DEF_STATIC_CONST_VAL_FLOAT(val_0723,0.154151);
#define CTNODE_cmu_us_awb_dur_NO_1209 1215
DEF_STATIC_CONST_VAL_FLOAT(val_0724,-0.035577);
#define CTNODE_cmu_us_awb_dur_NO_1215 1217
DEF_STATIC_CONST_VAL_FLOAT(val_0725,0.825393);
#define CTNODE_cmu_us_awb_dur_NO_1217 1219
DEF_STATIC_CONST_VAL_FLOAT(val_0726,-0.072950);
#define CTNODE_cmu_us_awb_dur_NO_1219 1221
DEF_STATIC_CONST_VAL_FLOAT(val_0727,0.620376);
#define CTNODE_cmu_us_awb_dur_NO_1221 1223
DEF_STATIC_CONST_VAL_FLOAT(val_0728,0.630119);
#define CTNODE_cmu_us_awb_dur_NO_1224 1226
DEF_STATIC_CONST_VAL_FLOAT(val_0729,0.267233);
#define CTNODE_cmu_us_awb_dur_NO_1223 1227
DEF_STATIC_CONST_VAL_FLOAT(val_0730,-0.013176);
#define CTNODE_cmu_us_awb_dur_NO_1227 1229
DEF_STATIC_CONST_VAL_FLOAT(val_0731,0.139751);
#define CTNODE_cmu_us_awb_dur_NO_1229 1231
DEF_STATIC_CONST_VAL_FLOAT(val_0732,0.419445);
#define CTNODE_cmu_us_awb_dur_NO_1206 1232
DEF_STATIC_CONST_VAL_STRING(val_0733,"ey_67");
DEF_STATIC_CONST_VAL_FLOAT(val_0734,0.525391);
#define CTNODE_cmu_us_awb_dur_NO_1232 1234
DEF_STATIC_CONST_VAL_FLOAT(val_0735,0.337459);
#define CTNODE_cmu_us_awb_dur_NO_1236 1238
DEF_STATIC_CONST_VAL_FLOAT(val_0736,-0.131189);
#define CTNODE_cmu_us_awb_dur_NO_1235 1239
DEF_STATIC_CONST_VAL_FLOAT(val_0737,0.756040);
#define CTNODE_cmu_us_awb_dur_NO_1239 1241
DEF_STATIC_CONST_VAL_FLOAT(val_0738,0.295834);
#define CTNODE_cmu_us_awb_dur_NO_1234 1242
DEF_STATIC_CONST_VAL_STRING(val_0739,"m_112");
DEF_STATIC_CONST_VAL_FLOAT(val_0740,-0.248375);
#define CTNODE_cmu_us_awb_dur_NO_1243 1245
DEF_STATIC_CONST_VAL_FLOAT(val_0741,0.797594);
#define CTNODE_cmu_us_awb_dur_NO_1242 1246
DEF_STATIC_CONST_VAL_FLOAT(val_0742,0.473731);
#define CTNODE_cmu_us_awb_dur_NO_1247 1249
DEF_STATIC_CONST_VAL_FLOAT(val_0743,-0.185979);
#define CTNODE_cmu_us_awb_dur_NO_1249 1251
DEF_STATIC_CONST_VAL_FLOAT(val_0744,0.291296);
#define CTNODE_cmu_us_awb_dur_NO_1251 1253
DEF_STATIC_CONST_VAL_FLOAT(val_0745,0.182130);
#define CTNODE_cmu_us_awb_dur_NO_1253 1255
DEF_STATIC_CONST_VAL_FLOAT(val_0746,-0.219120);
#define CTNODE_cmu_us_awb_dur_NO_1246 1256
DEF_STATIC_CONST_VAL_FLOAT(val_0747,0.121563);
#define CTNODE_cmu_us_awb_dur_NO_1257 1259
DEF_STATIC_CONST_VAL_FLOAT(val_0748,-0.546629);
#define CTNODE_cmu_us_awb_dur_NO_1260 1262
DEF_STATIC_CONST_VAL_FLOAT(val_0749,-0.538437);
#define CTNODE_cmu_us_awb_dur_NO_1263 1265
DEF_STATIC_CONST_VAL_FLOAT(val_0750,-0.184674);
#define CTNODE_cmu_us_awb_dur_NO_1262 1266
DEF_STATIC_CONST_VAL_FLOAT(val_0751,-0.096534);
#define CTNODE_cmu_us_awb_dur_NO_1259 1267
DEF_STATIC_CONST_VAL_FLOAT(val_0752,0.168531);
#define CTNODE_cmu_us_awb_dur_NO_1267 1269
DEF_STATIC_CONST_VAL_FLOAT(val_0753,-0.273062);
#define CTNODE_cmu_us_awb_dur_NO_1256 1270
DEF_STATIC_CONST_VAL_STRING(val_0754,"ey");
DEF_STATIC_CONST_VAL_FLOAT(val_0755,-0.485224);
#define CTNODE_cmu_us_awb_dur_NO_1270 1272
DEF_STATIC_CONST_VAL_FLOAT(val_0756,0.525737);
#define CTNODE_cmu_us_awb_dur_NO_1272 1274
DEF_STATIC_CONST_VAL_FLOAT(val_0757,-0.497676);
#define CTNODE_cmu_us_awb_dur_NO_1275 1277
DEF_STATIC_CONST_VAL_FLOAT(val_0758,2.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0759,0.251961);
#define CTNODE_cmu_us_awb_dur_NO_1277 1279
DEF_STATIC_CONST_VAL_FLOAT(val_0760,-0.316349);
#define CTNODE_cmu_us_awb_dur_NO_1279 1281
DEF_STATIC_CONST_VAL_FLOAT(val_0761,0.357846);
#define CTNODE_cmu_us_awb_dur_NO_1282 1284
DEF_STATIC_CONST_VAL_FLOAT(val_0762,-0.239015);
#define CTNODE_cmu_us_awb_dur_NO_1284 1286
DEF_STATIC_CONST_VAL_FLOAT(val_0763,-0.104960);
#define CTNODE_cmu_us_awb_dur_NO_1281 1287
DEF_STATIC_CONST_VAL_FLOAT(val_0764,-0.018261);
#define CTNODE_cmu_us_awb_dur_NO_1287 1289
DEF_STATIC_CONST_VAL_FLOAT(val_0765,-0.101039);
#define CTNODE_cmu_us_awb_dur_NO_1289 1291
DEF_STATIC_CONST_VAL_FLOAT(val_0766,-0.507620);
#define CTNODE_cmu_us_awb_dur_NO_1291 1293
DEF_STATIC_CONST_VAL_FLOAT(val_0767,-0.166414);
#define CTNODE_cmu_us_awb_dur_NO_1274 1294
DEF_STATIC_CONST_VAL_FLOAT(val_0768,0.373451);
#define CTNODE_cmu_us_awb_dur_NO_1294 1296
DEF_STATIC_CONST_VAL_FLOAT(val_0769,-0.253111);
#define CTNODE_cmu_us_awb_dur_NO_1296 1298
DEF_STATIC_CONST_VAL_FLOAT(val_0770,3.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_0771,6.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0772,-0.271760);
#define CTNODE_cmu_us_awb_dur_NO_1301 1303
DEF_STATIC_CONST_VAL_FLOAT(val_0773,0.076007);
#define CTNODE_cmu_us_awb_dur_NO_1300 1304
DEF_STATIC_CONST_VAL_FLOAT(val_0774,0.355411);
#define CTNODE_cmu_us_awb_dur_NO_1299 1305
DEF_STATIC_CONST_VAL_FLOAT(val_0775,-0.317591);
#define CTNODE_cmu_us_awb_dur_NO_1298 1306
DEF_STATIC_CONST_VAL_FLOAT(val_0776,0.505412);
#define CTNODE_cmu_us_awb_dur_NO_1306 1308
DEF_STATIC_CONST_VAL_FLOAT(val_0777,7.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0778,0.192644);
#define CTNODE_cmu_us_awb_dur_NO_1310 1312
DEF_STATIC_CONST_VAL_FLOAT(val_0779,0.483517);
#define CTNODE_cmu_us_awb_dur_NO_1309 1313
DEF_STATIC_CONST_VAL_FLOAT(val_0780,0.331697);
#define CTNODE_cmu_us_awb_dur_NO_1313 1315
DEF_STATIC_CONST_VAL_FLOAT(val_0781,0.063580);
#define CTNODE_cmu_us_awb_dur_NO_1315 1317
DEF_STATIC_CONST_VAL_FLOAT(val_0782,-0.218962);
#define CTNODE_cmu_us_awb_dur_NO_1308 1318
DEF_STATIC_CONST_VAL_FLOAT(val_0783,-0.276846);
#define CTNODE_cmu_us_awb_dur_NO_1111 1319
DEF_STATIC_CONST_VAL_STRING(val_0784,"z_199");
DEF_STATIC_CONST_VAL_FLOAT(val_0785,0.364139);
#define CTNODE_cmu_us_awb_dur_NO_1321 1323
DEF_STATIC_CONST_VAL_FLOAT(val_0786,0.029800);
#define CTNODE_cmu_us_awb_dur_NO_1320 1324
DEF_STATIC_CONST_VAL_FLOAT(val_0787,0.640666);
#define CTNODE_cmu_us_awb_dur_NO_1319 1325
DEF_STATIC_CONST_VAL_FLOAT(val_0788,-0.333591);
#define CTNODE_cmu_us_awb_dur_NO_1327 1329
DEF_STATIC_CONST_VAL_FLOAT(val_0789,2.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_0790,10.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_0791,0.411047);
#define CTNODE_cmu_us_awb_dur_NO_1331 1333
DEF_STATIC_CONST_VAL_FLOAT(val_0792,0.169834);
#define CTNODE_cmu_us_awb_dur_NO_1330 1334
DEF_STATIC_CONST_VAL_FLOAT(val_0793,0.495980);
#define CTNODE_cmu_us_awb_dur_NO_1334 1336
DEF_STATIC_CONST_VAL_FLOAT(val_0794,0.752474);
#define CTNODE_cmu_us_awb_dur_NO_1329 1337
DEF_STATIC_CONST_VAL_FLOAT(val_0795,0.189476);
#define CTNODE_cmu_us_awb_dur_NO_1338 1340
DEF_STATIC_CONST_VAL_FLOAT(val_0796,0.480768);
#define CTNODE_cmu_us_awb_dur_NO_1337 1341
DEF_STATIC_CONST_VAL_FLOAT(val_0797,-0.043870);
#define CTNODE_cmu_us_awb_dur_NO_1326 1342
DEF_STATIC_CONST_VAL_FLOAT(val_0798,0.564685);
#define CTNODE_cmu_us_awb_dur_NO_1342 1344
DEF_STATIC_CONST_VAL_FLOAT(val_0799,0.426104);
#define CTNODE_cmu_us_awb_dur_NO_1345 1347
DEF_STATIC_CONST_VAL_FLOAT(val_0800,0.130231);
#define CTNODE_cmu_us_awb_dur_NO_1344 1348
DEF_STATIC_CONST_VAL_FLOAT(val_0801,-0.275637);
#define CTNODE_cmu_us_awb_dur_NO_1349 1351
DEF_STATIC_CONST_VAL_FLOAT(val_0802,-0.555786);
#define CTNODE_cmu_us_awb_dur_NO_1348 1352
DEF_STATIC_CONST_VAL_FLOAT(val_0803,-0.210707);
#define CTNODE_cmu_us_awb_dur_NO_1353 1355
DEF_STATIC_CONST_VAL_FLOAT(val_0804,-0.455035);
#define CTNODE_cmu_us_awb_dur_NO_1352 1356
DEF_STATIC_CONST_VAL_FLOAT(val_0805,-0.147073);
#define CTNODE_cmu_us_awb_dur_NO_1357 1359
DEF_STATIC_CONST_VAL_FLOAT(val_0806,-0.434890);
#define CTNODE_cmu_us_awb_dur_NO_1356 1360
DEF_STATIC_CONST_VAL_FLOAT(val_0807,0.358418);
#define CTNODE_cmu_us_awb_dur_NO_1360 1362
DEF_STATIC_CONST_VAL_FLOAT(val_0808,0.100775);
#define CTNODE_cmu_us_awb_dur_NO_1363 1365
DEF_STATIC_CONST_VAL_FLOAT(val_0809,-0.100768);
#define CTNODE_cmu_us_awb_dur_NO_1362 1366
DEF_STATIC_CONST_VAL_FLOAT(val_0810,-0.205583);
#define CTNODE_cmu_us_awb_dur_NO_1325 1367
DEF_STATIC_CONST_VAL_FLOAT(val_0811,0.836875);
#define CTNODE_cmu_us_awb_dur_NO_1368 1370
DEF_STATIC_CONST_VAL_FLOAT(val_0812,-0.773665);
#define CTNODE_cmu_us_awb_dur_NO_1371 1373
DEF_STATIC_CONST_VAL_FLOAT(val_0813,-0.360602);
#define CTNODE_cmu_us_awb_dur_NO_1370 1374
DEF_STATIC_CONST_VAL_FLOAT(val_0814,-0.885483);
#define CTNODE_cmu_us_awb_dur_NO_1374 1376
DEF_STATIC_CONST_VAL_FLOAT(val_0815,-0.756258);
#define CTNODE_cmu_us_awb_dur_NO_1367 1377
DEF_STATIC_CONST_VAL_FLOAT(val_0816,0.664005);
#define CTNODE_cmu_us_awb_dur_NO_1377 1379
DEF_STATIC_CONST_VAL_STRING(val_0817,"v_184");
DEF_STATIC_CONST_VAL_FLOAT(val_0818,0.701875);
#define CTNODE_cmu_us_awb_dur_NO_1380 1382
DEF_STATIC_CONST_VAL_FLOAT(val_0819,-0.297297);
#define CTNODE_cmu_us_awb_dur_NO_1382 1384
DEF_STATIC_CONST_VAL_FLOAT(val_0820,-0.079379);
#define CTNODE_cmu_us_awb_dur_NO_1384 1386
DEF_STATIC_CONST_VAL_FLOAT(val_0821,0.647653);
#define CTNODE_cmu_us_awb_dur_NO_1379 1387
DEF_STATIC_CONST_VAL_FLOAT(val_0822,0.556934);
#define CTNODE_cmu_us_awb_dur_NO_1389 1391
DEF_STATIC_CONST_VAL_FLOAT(val_0823,0.398308);
#define CTNODE_cmu_us_awb_dur_NO_1391 1393
DEF_STATIC_CONST_VAL_FLOAT(val_0824,5.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0825,-0.053500);
#define CTNODE_cmu_us_awb_dur_NO_1393 1395
DEF_STATIC_CONST_VAL_FLOAT(val_0826,-0.202690);
#define CTNODE_cmu_us_awb_dur_NO_1388 1396
DEF_STATIC_CONST_VAL_FLOAT(val_0827,0.184202);
#define CTNODE_cmu_us_awb_dur_NO_1399 1401
DEF_STATIC_CONST_VAL_FLOAT(val_0828,-0.117910);
#define CTNODE_cmu_us_awb_dur_NO_1398 1402
DEF_STATIC_CONST_VAL_FLOAT(val_0829,0.401427);
#define CTNODE_cmu_us_awb_dur_NO_1397 1403
DEF_STATIC_CONST_VAL_FLOAT(val_0830,-0.186478);
#define CTNODE_cmu_us_awb_dur_NO_1396 1404
DEF_STATIC_CONST_VAL_FLOAT(val_0831,-0.490375);
#define CTNODE_cmu_us_awb_dur_NO_1387 1405
DEF_STATIC_CONST_VAL_STRING(val_0832,"d_47");
DEF_STATIC_CONST_VAL_FLOAT(val_0833,0.380774);
#define CTNODE_cmu_us_awb_dur_NO_1405 1407
DEF_STATIC_CONST_VAL_STRING(val_0834,"aux");
DEF_STATIC_CONST_VAL_FLOAT(val_0835,-0.250740);
#define CTNODE_cmu_us_awb_dur_NO_1410 1412
DEF_STATIC_CONST_VAL_FLOAT(val_0836,-0.034559);
#define CTNODE_cmu_us_awb_dur_NO_1409 1413
DEF_STATIC_CONST_VAL_FLOAT(val_0837,-0.175880);
#define CTNODE_cmu_us_awb_dur_NO_1413 1415
DEF_STATIC_CONST_VAL_FLOAT(val_0838,-0.306135);
#define CTNODE_cmu_us_awb_dur_NO_1415 1417
DEF_STATIC_CONST_VAL_FLOAT(val_0839,-0.448027);
#define CTNODE_cmu_us_awb_dur_NO_1417 1419
DEF_STATIC_CONST_VAL_FLOAT(val_0840,-0.515337);
#define CTNODE_cmu_us_awb_dur_NO_1419 1421
DEF_STATIC_CONST_VAL_FLOAT(val_0841,-0.674550);
#define CTNODE_cmu_us_awb_dur_NO_1408 1422
DEF_STATIC_CONST_VAL_FLOAT(val_0842,0.174573);
#define CTNODE_cmu_us_awb_dur_NO_1422 1424
DEF_STATIC_CONST_VAL_FLOAT(val_0843,-0.342591);
#define CTNODE_cmu_us_awb_dur_NO_1426 1428
DEF_STATIC_CONST_VAL_FLOAT(val_0844,-0.550231);
#define CTNODE_cmu_us_awb_dur_NO_1425 1429
DEF_STATIC_CONST_VAL_FLOAT(val_0845,-0.320395);
#define CTNODE_cmu_us_awb_dur_NO_1429 1431
DEF_STATIC_CONST_VAL_FLOAT(val_0846,-0.009645);
#define CTNODE_cmu_us_awb_dur_NO_1424 1432
DEF_STATIC_CONST_VAL_FLOAT(val_0847,0.114556);
#define CTNODE_cmu_us_awb_dur_NO_1432 1434
DEF_STATIC_CONST_VAL_FLOAT(val_0848,-0.050554);
#define CTNODE_cmu_us_awb_dur_NO_1434 1436
DEF_STATIC_CONST_VAL_FLOAT(val_0849,-0.347950);
#define CTNODE_cmu_us_awb_dur_NO_1407 1437
DEF_STATIC_CONST_VAL_STRING(val_0850,"b_36");
DEF_STATIC_CONST_VAL_FLOAT(val_0851,-0.640983);
#define CTNODE_cmu_us_awb_dur_NO_1437 1439
DEF_STATIC_CONST_VAL_FLOAT(val_0852,-0.038712);
#define CTNODE_cmu_us_awb_dur_NO_1440 1442
DEF_STATIC_CONST_VAL_FLOAT(val_0853,-0.595453);
#define CTNODE_cmu_us_awb_dur_NO_1439 1443
DEF_STATIC_CONST_VAL_STRING(val_0854,"hh_82");
DEF_STATIC_CONST_VAL_FLOAT(val_0855,-0.473472);
#define CTNODE_cmu_us_awb_dur_NO_1443 1445
DEF_STATIC_CONST_VAL_FLOAT(val_0856,-0.344013);
#define CTNODE_cmu_us_awb_dur_NO_1447 1449
DEF_STATIC_CONST_VAL_FLOAT(val_0857,1.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0858,0.687050);
#define CTNODE_cmu_us_awb_dur_NO_1450 1452
DEF_STATIC_CONST_VAL_FLOAT(val_0859,-0.310997);
#define CTNODE_cmu_us_awb_dur_NO_1449 1453
DEF_STATIC_CONST_VAL_FLOAT(val_0860,0.215589);
#define CTNODE_cmu_us_awb_dur_NO_1453 1455
DEF_STATIC_CONST_VAL_FLOAT(val_0861,-0.381176);
#define CTNODE_cmu_us_awb_dur_NO_1446 1456
DEF_STATIC_CONST_VAL_FLOAT(val_0862,-0.282679);
#define CTNODE_cmu_us_awb_dur_NO_1456 1458
DEF_STATIC_CONST_VAL_STRING(val_0863,"ah_11");
DEF_STATIC_CONST_VAL_FLOAT(val_0864,-0.629169);
#define CTNODE_cmu_us_awb_dur_NO_1458 1460
DEF_STATIC_CONST_VAL_FLOAT(val_0865,-0.463476);
#define CTNODE_cmu_us_awb_dur_NO_1445 1461
DEF_STATIC_CONST_VAL_FLOAT(val_0866,-0.383983);
#define CTNODE_cmu_us_awb_dur_NO_1461 1463
DEF_STATIC_CONST_VAL_STRING(val_0867,"aw");
DEF_STATIC_CONST_VAL_FLOAT(val_0868,0.399484);
#define CTNODE_cmu_us_awb_dur_NO_1463 1465
DEF_STATIC_CONST_VAL_FLOAT(val_0869,5.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_0870,-0.221779);
#define CTNODE_cmu_us_awb_dur_NO_1468 1470
DEF_STATIC_CONST_VAL_FLOAT(val_0871,0.203548);
#define CTNODE_cmu_us_awb_dur_NO_1470 1472
DEF_STATIC_CONST_VAL_FLOAT(val_0872,-0.155123);
#define CTNODE_cmu_us_awb_dur_NO_1467 1473
DEF_STATIC_CONST_VAL_FLOAT(val_0873,-0.388200);
#define CTNODE_cmu_us_awb_dur_NO_1473 1475
DEF_STATIC_CONST_VAL_FLOAT(val_0874,0.029208);
#define CTNODE_cmu_us_awb_dur_NO_1475 1477
DEF_STATIC_CONST_VAL_FLOAT(val_0875,-0.219907);
#define CTNODE_cmu_us_awb_dur_NO_1477 1479
DEF_STATIC_CONST_VAL_FLOAT(val_0876,-0.402351);
#define CTNODE_cmu_us_awb_dur_NO_1466 1480
DEF_STATIC_CONST_VAL_FLOAT(val_0877,0.628064);
#define CTNODE_cmu_us_awb_dur_NO_1481 1483
DEF_STATIC_CONST_VAL_FLOAT(val_0878,-0.167994);
#define CTNODE_cmu_us_awb_dur_NO_1480 1484
DEF_STATIC_CONST_VAL_FLOAT(val_0879,0.558506);
#define CTNODE_cmu_us_awb_dur_NO_1486 1488
DEF_STATIC_CONST_VAL_FLOAT(val_0880,-0.004342);
#define CTNODE_cmu_us_awb_dur_NO_1489 1491
DEF_STATIC_CONST_VAL_FLOAT(val_0881,-0.454549);
#define CTNODE_cmu_us_awb_dur_NO_1488 1492
DEF_STATIC_CONST_VAL_FLOAT(val_0882,-0.298468);
#define CTNODE_cmu_us_awb_dur_NO_1492 1494
DEF_STATIC_CONST_VAL_FLOAT(val_0883,0.123094);
#define CTNODE_cmu_us_awb_dur_NO_1495 1497
DEF_STATIC_CONST_VAL_FLOAT(val_0884,0.598470);
#define CTNODE_cmu_us_awb_dur_NO_1494 1498
DEF_STATIC_CONST_VAL_FLOAT(val_0885,-0.217731);
#define CTNODE_cmu_us_awb_dur_NO_1498 1500
DEF_STATIC_CONST_VAL_FLOAT(val_0886,-0.330475);
#define CTNODE_cmu_us_awb_dur_NO_1502 1504
DEF_STATIC_CONST_VAL_FLOAT(val_0887,-0.035881);
#define CTNODE_cmu_us_awb_dur_NO_1501 1505
DEF_STATIC_CONST_VAL_FLOAT(val_0888,0.196760);
#define CTNODE_cmu_us_awb_dur_NO_1500 1506
DEF_STATIC_CONST_VAL_FLOAT(val_0889,0.074407);
#define CTNODE_cmu_us_awb_dur_NO_1506 1508
DEF_STATIC_CONST_VAL_FLOAT(val_0890,0.573513);
#define CTNODE_cmu_us_awb_dur_NO_1485 1509
DEF_STATIC_CONST_VAL_STRING(val_0891,"v_185");
DEF_STATIC_CONST_VAL_FLOAT(val_0892,-0.428680);
#define CTNODE_cmu_us_awb_dur_NO_1509 1511
DEF_STATIC_CONST_VAL_FLOAT(val_0893,0.318659);
#define CTNODE_cmu_us_awb_dur_NO_1511 1513
DEF_STATIC_CONST_VAL_FLOAT(val_0894,-0.066399);
#define CTNODE_cmu_us_awb_dur_NO_1514 1516
DEF_STATIC_CONST_VAL_FLOAT(val_0895,0.275605);
#define CTNODE_cmu_us_awb_dur_NO_1513 1517
DEF_STATIC_CONST_VAL_FLOAT(val_0896,0.214528);
#define CTNODE_cmu_us_awb_dur_NO_1518 1520
DEF_STATIC_CONST_VAL_FLOAT(val_0897,-0.393380);
#define CTNODE_cmu_us_awb_dur_NO_1523 1525
DEF_STATIC_CONST_VAL_FLOAT(val_0898,0.048450);
#define CTNODE_cmu_us_awb_dur_NO_1522 1526
DEF_STATIC_CONST_VAL_FLOAT(val_0899,0.432272);
#define CTNODE_cmu_us_awb_dur_NO_1526 1528
DEF_STATIC_CONST_VAL_FLOAT(val_0900,0.021577);
#define CTNODE_cmu_us_awb_dur_NO_1521 1529
DEF_STATIC_CONST_VAL_FLOAT(val_0901,-0.355736);
#define CTNODE_cmu_us_awb_dur_NO_1529 1531
DEF_STATIC_CONST_VAL_FLOAT(val_0902,-0.204952);
#define CTNODE_cmu_us_awb_dur_NO_1520 1532
DEF_STATIC_CONST_VAL_FLOAT(val_0903,-0.161338);
#define CTNODE_cmu_us_awb_dur_NO_1532 1534
DEF_STATIC_CONST_VAL_FLOAT(val_0904,-0.457355);
#define CTNODE_cmu_us_awb_dur_NO_1517 1535
DEF_STATIC_CONST_VAL_FLOAT(val_0905,-0.512523);
#define CTNODE_cmu_us_awb_dur_NO_1536 1538
DEF_STATIC_CONST_VAL_FLOAT(val_0906,-0.343118);
#define CTNODE_cmu_us_awb_dur_NO_1535 1539
DEF_STATIC_CONST_VAL_FLOAT(val_0907,-0.039232);
#define CTNODE_cmu_us_awb_dur_NO_1484 1540
DEF_STATIC_CONST_VAL_FLOAT(val_0908,0.056021);
#define CTNODE_cmu_us_awb_dur_NO_1541 1543
DEF_STATIC_CONST_VAL_FLOAT(val_0909,0.609448);
#define CTNODE_cmu_us_awb_dur_NO_1540 1544
DEF_STATIC_CONST_VAL_FLOAT(val_0910,0.201836);
#define CTNODE_cmu_us_awb_dur_NO_1544 1546
DEF_STATIC_CONST_VAL_FLOAT(val_0911,-0.138232);
#define CTNODE_cmu_us_awb_dur_NO_1465 1547
DEF_STATIC_CONST_VAL_FLOAT(val_0912,-0.350628);
#define CTNODE_cmu_us_awb_dur_NO_1548 1550
DEF_STATIC_CONST_VAL_FLOAT(val_0913,-0.498264);
#define CTNODE_cmu_us_awb_dur_NO_1547 1551
DEF_STATIC_CONST_VAL_FLOAT(val_0914,9.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_0915,0.111746);
#define CTNODE_cmu_us_awb_dur_NO_1552 1554
DEF_STATIC_CONST_VAL_FLOAT(val_0916,0.188975);
#define CTNODE_cmu_us_awb_dur_NO_1556 1558
DEF_STATIC_CONST_VAL_FLOAT(val_0917,-0.192880);
#define CTNODE_cmu_us_awb_dur_NO_1555 1559
DEF_STATIC_CONST_VAL_FLOAT(val_0918,-0.478171);
#define CTNODE_cmu_us_awb_dur_NO_1560 1562
DEF_STATIC_CONST_VAL_FLOAT(val_0919,-0.203890);
#define CTNODE_cmu_us_awb_dur_NO_1559 1563
DEF_STATIC_CONST_VAL_FLOAT(val_0920,-0.012126);
#define CTNODE_cmu_us_awb_dur_NO_1554 1564
DEF_STATIC_CONST_VAL_FLOAT(val_0921,-0.442633);
#define CTNODE_cmu_us_awb_dur_NO_1551 1565
DEF_STATIC_CONST_VAL_FLOAT(val_0922,0.216049);
#define CTNODE_cmu_us_awb_dur_NO_0606 1566
DEF_STATIC_CONST_VAL_FLOAT(val_0923,-0.060194);
#define CTNODE_cmu_us_awb_dur_NO_1568 1570
DEF_STATIC_CONST_VAL_FLOAT(val_0924,0.524782);
#define CTNODE_cmu_us_awb_dur_NO_1567 1571
DEF_STATIC_CONST_VAL_STRING(val_0925,"l_106");
DEF_STATIC_CONST_VAL_FLOAT(val_0926,0.497497);
#define CTNODE_cmu_us_awb_dur_NO_1571 1573
DEF_STATIC_CONST_VAL_FLOAT(val_0927,-0.560052);
#define CTNODE_cmu_us_awb_dur_NO_1573 1575
DEF_STATIC_CONST_VAL_FLOAT(val_0928,-0.189696);
#define CTNODE_cmu_us_awb_dur_NO_1577 1579
DEF_STATIC_CONST_VAL_FLOAT(val_0929,-0.698917);
#define CTNODE_cmu_us_awb_dur_NO_1576 1580
DEF_STATIC_CONST_VAL_FLOAT(val_0930,0.176804);
#define CTNODE_cmu_us_awb_dur_NO_1581 1583
DEF_STATIC_CONST_VAL_FLOAT(val_0931,5.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0932,-0.413012);
#define CTNODE_cmu_us_awb_dur_NO_1585 1587
DEF_STATIC_CONST_VAL_FLOAT(val_0933,-0.083633);
#define CTNODE_cmu_us_awb_dur_NO_1584 1588
DEF_STATIC_CONST_VAL_FLOAT(val_0934,-0.595976);
#define CTNODE_cmu_us_awb_dur_NO_1588 1590
DEF_STATIC_CONST_VAL_FLOAT(val_0935,-0.466676);
#define CTNODE_cmu_us_awb_dur_NO_1583 1591
DEF_STATIC_CONST_VAL_FLOAT(val_0936,0.249208);
#define CTNODE_cmu_us_awb_dur_NO_1592 1594
DEF_STATIC_CONST_VAL_FLOAT(val_0937,4.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_0938,-0.354194);
#define CTNODE_cmu_us_awb_dur_NO_1594 1596
DEF_STATIC_CONST_VAL_FLOAT(val_0939,0.057533);
#define CTNODE_cmu_us_awb_dur_NO_1591 1597
DEF_STATIC_CONST_VAL_FLOAT(val_0940,-0.450788);
#define CTNODE_cmu_us_awb_dur_NO_1580 1598
DEF_STATIC_CONST_VAL_FLOAT(val_0941,0.023030);
#define CTNODE_cmu_us_awb_dur_NO_1601 1603
DEF_STATIC_CONST_VAL_FLOAT(val_0942,-0.419862);
#define CTNODE_cmu_us_awb_dur_NO_1603 1605
DEF_STATIC_CONST_VAL_FLOAT(val_0943,-0.289544);
#define CTNODE_cmu_us_awb_dur_NO_1600 1606
DEF_STATIC_CONST_VAL_FLOAT(val_0944,0.457644);
#define CTNODE_cmu_us_awb_dur_NO_1607 1609
DEF_STATIC_CONST_VAL_FLOAT(val_0945,-0.014127);
#define CTNODE_cmu_us_awb_dur_NO_1606 1610
DEF_STATIC_CONST_VAL_FLOAT(val_0946,0.261960);
#define CTNODE_cmu_us_awb_dur_NO_1610 1612
DEF_STATIC_CONST_VAL_FLOAT(val_0947,0.198854);
#define CTNODE_cmu_us_awb_dur_NO_1612 1614
DEF_STATIC_CONST_VAL_FLOAT(val_0948,-0.327179);
#define CTNODE_cmu_us_awb_dur_NO_1616 1618
DEF_STATIC_CONST_VAL_FLOAT(val_0949,0.177659);
#define CTNODE_cmu_us_awb_dur_NO_1615 1619
DEF_STATIC_CONST_VAL_FLOAT(val_0950,0.038586);
#define CTNODE_cmu_us_awb_dur_NO_1620 1622
DEF_STATIC_CONST_VAL_FLOAT(val_0951,-0.412516);
#define CTNODE_cmu_us_awb_dur_NO_1619 1623
DEF_STATIC_CONST_VAL_FLOAT(val_0952,-0.474117);
#define CTNODE_cmu_us_awb_dur_NO_1614 1624
DEF_STATIC_CONST_VAL_FLOAT(val_0953,0.190879);
#define CTNODE_cmu_us_awb_dur_NO_1624 1626
DEF_STATIC_CONST_VAL_FLOAT(val_0954,-0.090767);
#define CTNODE_cmu_us_awb_dur_NO_1599 1627
DEF_STATIC_CONST_VAL_FLOAT(val_0955,-0.449681);
#define CTNODE_cmu_us_awb_dur_NO_1628 1630
DEF_STATIC_CONST_VAL_FLOAT(val_0956,-0.006216);
#define CTNODE_cmu_us_awb_dur_NO_1627 1631
DEF_STATIC_CONST_VAL_FLOAT(val_0957,-0.541809);
#define CTNODE_cmu_us_awb_dur_NO_1598 1632
DEF_STATIC_CONST_VAL_FLOAT(val_0958,0.029044);
#define CTNODE_cmu_us_awb_dur_NO_1632 1634
DEF_STATIC_CONST_VAL_FLOAT(val_0959,0.168883);
#define CTNODE_cmu_us_awb_dur_NO_1634 1636
DEF_STATIC_CONST_VAL_FLOAT(val_0960,0.406329);
#define CTNODE_cmu_us_awb_dur_NO_1575 1637
DEF_STATIC_CONST_VAL_FLOAT(val_0961,0.662608);
#define CTNODE_cmu_us_awb_dur_NO_1638 1640
DEF_STATIC_CONST_VAL_STRING(val_0962,"eh_56");
DEF_STATIC_CONST_VAL_FLOAT(val_0963,-0.292533);
#define CTNODE_cmu_us_awb_dur_NO_1640 1642
DEF_STATIC_CONST_VAL_FLOAT(val_0964,0.031630);
#define CTNODE_cmu_us_awb_dur_NO_1644 1646
DEF_STATIC_CONST_VAL_FLOAT(val_0965,0.236194);
#define CTNODE_cmu_us_awb_dur_NO_1643 1647
DEF_STATIC_CONST_VAL_FLOAT(val_0966,0.423166);
#define CTNODE_cmu_us_awb_dur_NO_1642 1648
DEF_STATIC_CONST_VAL_FLOAT(val_0967,-0.281535);
#define CTNODE_cmu_us_awb_dur_NO_1648 1650
DEF_STATIC_CONST_VAL_FLOAT(val_0968,0.302942);
#define CTNODE_cmu_us_awb_dur_NO_1650 1652
DEF_STATIC_CONST_VAL_FLOAT(val_0969,0.007285);
#define CTNODE_cmu_us_awb_dur_NO_1652 1654
DEF_STATIC_CONST_VAL_FLOAT(val_0970,-0.214445);
#define CTNODE_cmu_us_awb_dur_NO_1637 1655
DEF_STATIC_CONST_VAL_FLOAT(val_0971,-0.358086);
#define CTNODE_cmu_us_awb_dur_NO_1566 1656
DEF_STATIC_CONST_VAL_FLOAT(val_0972,-0.503854);
#define CTNODE_cmu_us_awb_dur_NO_1657 1659
DEF_STATIC_CONST_VAL_FLOAT(val_0973,0.147190);
#define CTNODE_cmu_us_awb_dur_NO_1659 1661
DEF_STATIC_CONST_VAL_FLOAT(val_0974,0.141390);
#define CTNODE_cmu_us_awb_dur_NO_1661 1663
DEF_STATIC_CONST_VAL_FLOAT(val_0975,0.137271);
#define CTNODE_cmu_us_awb_dur_NO_1664 1666
DEF_STATIC_CONST_VAL_FLOAT(val_0976,-0.225877);
#define CTNODE_cmu_us_awb_dur_NO_1663 1667
DEF_STATIC_CONST_VAL_FLOAT(val_0977,-0.188320);
#define CTNODE_cmu_us_awb_dur_NO_1667 1669
DEF_STATIC_CONST_VAL_FLOAT(val_0978,-0.604578);
#define CTNODE_cmu_us_awb_dur_NO_1669 1671
DEF_STATIC_CONST_VAL_FLOAT(val_0979,-0.366549);
#define CTNODE_cmu_us_awb_dur_NO_1656 1672
DEF_STATIC_CONST_VAL_STRING(val_0980,"d_46");
DEF_STATIC_CONST_VAL_FLOAT(val_0981,-0.432382);
#define CTNODE_cmu_us_awb_dur_NO_1674 1676
DEF_STATIC_CONST_VAL_FLOAT(val_0982,-0.071683);
#define CTNODE_cmu_us_awb_dur_NO_1673 1677
DEF_STATIC_CONST_VAL_FLOAT(val_0983,-0.535482);
#define CTNODE_cmu_us_awb_dur_NO_1678 1680
DEF_STATIC_CONST_VAL_FLOAT(val_0984,-0.740824);
#define CTNODE_cmu_us_awb_dur_NO_1677 1681
DEF_STATIC_CONST_VAL_FLOAT(val_0985,-0.629669);
#define CTNODE_cmu_us_awb_dur_NO_1681 1683
DEF_STATIC_CONST_VAL_FLOAT(val_0986,-0.224417);
#define CTNODE_cmu_us_awb_dur_NO_1683 1685
DEF_STATIC_CONST_VAL_FLOAT(val_0987,11.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_0988,-0.501161);
#define CTNODE_cmu_us_awb_dur_NO_1686 1688
DEF_STATIC_CONST_VAL_FLOAT(val_0989,-0.280692);
#define CTNODE_cmu_us_awb_dur_NO_1685 1689
DEF_STATIC_CONST_VAL_FLOAT(val_0990,-0.647559);
#define CTNODE_cmu_us_awb_dur_NO_1672 1690
DEF_STATIC_CONST_VAL_FLOAT(val_0991,-0.029257);
#define CTNODE_cmu_us_awb_dur_NO_1691 1693
DEF_STATIC_CONST_VAL_FLOAT(val_0992,-0.128525);
#define CTNODE_cmu_us_awb_dur_NO_1690 1694
DEF_STATIC_CONST_VAL_FLOAT(val_0993,-0.362849);
#define CTNODE_cmu_us_awb_dur_NO_0585 1695
DEF_STATIC_CONST_VAL_STRING(val_0994,"iy_91");
DEF_STATIC_CONST_VAL_FLOAT(val_0995,0.984615);
#define CTNODE_cmu_us_awb_dur_NO_1696 1698
DEF_STATIC_CONST_VAL_FLOAT(val_0996,0.383611);
#define CTNODE_cmu_us_awb_dur_NO_1695 1699
DEF_STATIC_CONST_VAL_FLOAT(val_0997,-0.597883);
#define CTNODE_cmu_us_awb_dur_NO_1701 1703
DEF_STATIC_CONST_VAL_FLOAT(val_0998,-0.131481);
#define CTNODE_cmu_us_awb_dur_NO_1704 1706
DEF_STATIC_CONST_VAL_FLOAT(val_0999,-0.423894);
#define CTNODE_cmu_us_awb_dur_NO_1707 1709
DEF_STATIC_CONST_VAL_FLOAT(val_1000,-0.102606);
#define CTNODE_cmu_us_awb_dur_NO_1706 1710
DEF_STATIC_CONST_VAL_FLOAT(val_1001,-0.547675);
#define CTNODE_cmu_us_awb_dur_NO_1703 1711
DEF_STATIC_CONST_VAL_FLOAT(val_1002,-0.216206);
#define CTNODE_cmu_us_awb_dur_NO_1713 1715
DEF_STATIC_CONST_VAL_FLOAT(val_1003,0.121938);
#define CTNODE_cmu_us_awb_dur_NO_1712 1716
DEF_STATIC_CONST_VAL_FLOAT(val_1004,-0.238115);
#define CTNODE_cmu_us_awb_dur_NO_1716 1718
DEF_STATIC_CONST_VAL_FLOAT(val_1005,-0.493692);
#define CTNODE_cmu_us_awb_dur_NO_1711 1719
DEF_STATIC_CONST_VAL_FLOAT(val_1006,0.020879);
#define CTNODE_cmu_us_awb_dur_NO_1719 1721
DEF_STATIC_CONST_VAL_FLOAT(val_1007,0.324373);
#define CTNODE_cmu_us_awb_dur_NO_1700 1722
DEF_STATIC_CONST_VAL_FLOAT(val_1008,0.149898);
#define CTNODE_cmu_us_awb_dur_NO_1724 1726
DEF_STATIC_CONST_VAL_FLOAT(val_1009,-0.414787);
#define CTNODE_cmu_us_awb_dur_NO_1723 1727
DEF_STATIC_CONST_VAL_FLOAT(val_1010,-0.471008);
#define CTNODE_cmu_us_awb_dur_NO_1722 1728
DEF_STATIC_CONST_VAL_FLOAT(val_1011,-0.654908);
#define CTNODE_cmu_us_awb_dur_NO_1730 1732
DEF_STATIC_CONST_VAL_FLOAT(val_1012,-0.454534);
#define CTNODE_cmu_us_awb_dur_NO_1729 1733
DEF_STATIC_CONST_VAL_FLOAT(val_1013,-0.761597);
#define CTNODE_cmu_us_awb_dur_NO_1728 1734
DEF_STATIC_CONST_VAL_STRING(val_1014,"iy");
DEF_STATIC_CONST_VAL_FLOAT(val_1015,-0.651036);
#define CTNODE_cmu_us_awb_dur_NO_1734 1736
DEF_STATIC_CONST_VAL_FLOAT(val_1016,-0.617916);
#define CTNODE_cmu_us_awb_dur_NO_1737 1739
DEF_STATIC_CONST_VAL_FLOAT(val_1017,-0.438112);
#define CTNODE_cmu_us_awb_dur_NO_1740 1742
DEF_STATIC_CONST_VAL_FLOAT(val_1018,-0.601566);
#define CTNODE_cmu_us_awb_dur_NO_1739 1743
DEF_STATIC_CONST_VAL_FLOAT(val_1019,-0.176179);
#define CTNODE_cmu_us_awb_dur_NO_1743 1745
DEF_STATIC_CONST_VAL_FLOAT(val_1020,-0.571804);
#define CTNODE_cmu_us_awb_dur_NO_1746 1748
DEF_STATIC_CONST_VAL_FLOAT(val_1021,-0.465946);
#define CTNODE_cmu_us_awb_dur_NO_1745 1749
DEF_STATIC_CONST_VAL_FLOAT(val_1022,-0.433804);
#define CTNODE_cmu_us_awb_dur_NO_1749 1751
DEF_STATIC_CONST_VAL_FLOAT(val_1023,-0.252672);
#define CTNODE_cmu_us_awb_dur_NO_1736 1752
DEF_STATIC_CONST_VAL_FLOAT(val_1024,-0.145259);
#define CTNODE_cmu_us_awb_dur_NO_1699 1753
DEF_STATIC_CONST_VAL_FLOAT(val_1025,0.041877);
#define CTNODE_cmu_us_awb_dur_NO_1755 1757
DEF_STATIC_CONST_VAL_FLOAT(val_1026,-0.138278);
#define CTNODE_cmu_us_awb_dur_NO_1757 1759
DEF_STATIC_CONST_VAL_FLOAT(val_1027,-0.633105);
#define CTNODE_cmu_us_awb_dur_NO_1759 1761
DEF_STATIC_CONST_VAL_FLOAT(val_1028,-0.292593);
#define CTNODE_cmu_us_awb_dur_NO_1754 1762
DEF_STATIC_CONST_VAL_FLOAT(val_1029,-0.464013);
#define CTNODE_cmu_us_awb_dur_NO_1764 1766
DEF_STATIC_CONST_VAL_FLOAT(val_1030,-0.281291);
#define CTNODE_cmu_us_awb_dur_NO_1763 1767
DEF_STATIC_CONST_VAL_FLOAT(val_1031,-0.049078);
#define CTNODE_cmu_us_awb_dur_NO_1767 1769
DEF_STATIC_CONST_VAL_FLOAT(val_1032,0.191207);
#define CTNODE_cmu_us_awb_dur_NO_1762 1770
DEF_STATIC_CONST_VAL_FLOAT(val_1033,0.840828);
#define CTNODE_cmu_us_awb_dur_NO_1770 1772
DEF_STATIC_CONST_VAL_FLOAT(val_1034,-0.195045);
#define CTNODE_cmu_us_awb_dur_NO_1772 1774
DEF_STATIC_CONST_VAL_STRING(val_1035,"w_191");
DEF_STATIC_CONST_VAL_FLOAT(val_1036,-0.150045);
#define CTNODE_cmu_us_awb_dur_NO_1774 1776
DEF_STATIC_CONST_VAL_FLOAT(val_1037,0.719660);
#define CTNODE_cmu_us_awb_dur_NO_1776 1778
DEF_STATIC_CONST_VAL_FLOAT(val_1038,0.810772);
#define CTNODE_cmu_us_awb_dur_NO_1780 1782
DEF_STATIC_CONST_VAL_FLOAT(val_1039,1.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_1040,0.445341);
#define CTNODE_cmu_us_awb_dur_NO_1782 1784
DEF_STATIC_CONST_VAL_FLOAT(val_1041,0.158942);
#define CTNODE_cmu_us_awb_dur_NO_1779 1785
DEF_STATIC_CONST_VAL_FLOAT(val_1042,0.613224);
#define CTNODE_cmu_us_awb_dur_NO_1785 1787
DEF_STATIC_CONST_VAL_FLOAT(val_1043,0.167743);
#define CTNODE_cmu_us_awb_dur_NO_1790 1792
DEF_STATIC_CONST_VAL_FLOAT(val_1044,-0.122171);
#define CTNODE_cmu_us_awb_dur_NO_1789 1793
DEF_STATIC_CONST_VAL_FLOAT(val_1045,0.314298);
#define CTNODE_cmu_us_awb_dur_NO_1788 1794
DEF_STATIC_CONST_VAL_FLOAT(val_1046,-0.152369);
#define CTNODE_cmu_us_awb_dur_NO_1787 1795
DEF_STATIC_CONST_VAL_FLOAT(val_1047,0.322401);
#define CTNODE_cmu_us_awb_dur_NO_1778 1796
DEF_STATIC_CONST_VAL_FLOAT(val_1048,-0.140811);
#define CTNODE_cmu_us_awb_dur_NO_1753 1797
DEF_STATIC_CONST_VAL_STRING(val_1049,"dh_52");
DEF_STATIC_CONST_VAL_FLOAT(val_1050,0.721858);
#define CTNODE_cmu_us_awb_dur_NO_1797 1799
DEF_STATIC_CONST_VAL_FLOAT(val_1051,0.110196);
#define CTNODE_cmu_us_awb_dur_NO_1802 1804
DEF_STATIC_CONST_VAL_FLOAT(val_1052,0.372678);
#define CTNODE_cmu_us_awb_dur_NO_1801 1805
DEF_STATIC_CONST_VAL_FLOAT(val_1053,0.697920);
#define CTNODE_cmu_us_awb_dur_NO_1800 1806
DEF_STATIC_CONST_VAL_FLOAT(val_1054,-0.381394);
#define CTNODE_cmu_us_awb_dur_NO_1806 1808
DEF_STATIC_CONST_VAL_FLOAT(val_1055,0.215513);
#define CTNODE_cmu_us_awb_dur_NO_1808 1810
DEF_STATIC_CONST_VAL_FLOAT(val_1056,-0.126506);
#define CTNODE_cmu_us_awb_dur_NO_1799 1811
DEF_STATIC_CONST_VAL_STRING(val_1057,"r_148");
DEF_STATIC_CONST_VAL_FLOAT(val_1058,-0.115810);
#define CTNODE_cmu_us_awb_dur_NO_1813 1815
DEF_STATIC_CONST_VAL_FLOAT(val_1059,0.605541);
#define CTNODE_cmu_us_awb_dur_NO_1812 1816
DEF_STATIC_CONST_VAL_STRING(val_1060,"n_117");
DEF_STATIC_CONST_VAL_FLOAT(val_1061,0.359741);
#define CTNODE_cmu_us_awb_dur_NO_1816 1818
DEF_STATIC_CONST_VAL_STRING(val_1062,"l_108");
DEF_STATIC_CONST_VAL_FLOAT(val_1063,-0.464871);
#define CTNODE_cmu_us_awb_dur_NO_1820 1822
DEF_STATIC_CONST_VAL_FLOAT(val_1064,-0.284718);
#define CTNODE_cmu_us_awb_dur_NO_1819 1823
DEF_STATIC_CONST_VAL_STRING(val_1065,"y");
DEF_STATIC_CONST_VAL_FLOAT(val_1066,0.230713);
#define CTNODE_cmu_us_awb_dur_NO_1826 1828
DEF_STATIC_CONST_VAL_FLOAT(val_1067,-0.110975);
#define CTNODE_cmu_us_awb_dur_NO_1825 1829
DEF_STATIC_CONST_VAL_FLOAT(val_1068,0.083029);
#define CTNODE_cmu_us_awb_dur_NO_1829 1831
DEF_STATIC_CONST_VAL_FLOAT(val_1069,0.010423);
#define CTNODE_cmu_us_awb_dur_NO_1831 1833
DEF_STATIC_CONST_VAL_FLOAT(val_1070,-0.468831);
#define CTNODE_cmu_us_awb_dur_NO_1834 1836
DEF_STATIC_CONST_VAL_FLOAT(val_1071,-0.339642);
#define CTNODE_cmu_us_awb_dur_NO_1833 1837
DEF_STATIC_CONST_VAL_FLOAT(val_1072,-0.003529);
#define CTNODE_cmu_us_awb_dur_NO_1837 1839
DEF_STATIC_CONST_VAL_FLOAT(val_1073,-0.334331);
#define CTNODE_cmu_us_awb_dur_NO_1824 1840
DEF_STATIC_CONST_VAL_FLOAT(val_1074,-0.370235);
#define CTNODE_cmu_us_awb_dur_NO_1823 1841
DEF_STATIC_CONST_VAL_FLOAT(val_1075,-0.146708);
#define CTNODE_cmu_us_awb_dur_NO_1842 1844
DEF_STATIC_CONST_VAL_FLOAT(val_1076,-0.349455);
#define CTNODE_cmu_us_awb_dur_NO_1841 1845
DEF_STATIC_CONST_VAL_FLOAT(val_1077,-0.130700);
#define CTNODE_cmu_us_awb_dur_NO_1845 1847
DEF_STATIC_CONST_VAL_FLOAT(val_1078,0.011210);
#define CTNODE_cmu_us_awb_dur_NO_1848 1850
DEF_STATIC_CONST_VAL_FLOAT(val_1079,0.408272);
#define CTNODE_cmu_us_awb_dur_NO_1851 1853
DEF_STATIC_CONST_VAL_FLOAT(val_1080,0.124358);
#define CTNODE_cmu_us_awb_dur_NO_1850 1854
DEF_STATIC_CONST_VAL_FLOAT(val_1081,0.723523);
#define CTNODE_cmu_us_awb_dur_NO_1847 1855
DEF_STATIC_CONST_VAL_FLOAT(val_1082,0.263315);
#define CTNODE_cmu_us_awb_dur_NO_1855 1857
DEF_STATIC_CONST_VAL_FLOAT(val_1083,0.066028);
#define CTNODE_cmu_us_awb_dur_NO_1857 1859
DEF_STATIC_CONST_VAL_FLOAT(val_1084,-0.174578);
#define CTNODE_cmu_us_awb_dur_NO_1818 1860
DEF_STATIC_CONST_VAL_FLOAT(val_1085,0.311848);
#define CTNODE_cmu_us_awb_dur_NO_1861 1863
DEF_STATIC_CONST_VAL_FLOAT(val_1086,0.017181);
#define CTNODE_cmu_us_awb_dur_NO_1865 1867
DEF_STATIC_CONST_VAL_FLOAT(val_1087,0.289908);
#define CTNODE_cmu_us_awb_dur_NO_1864 1868
DEF_STATIC_CONST_VAL_FLOAT(val_1088,-0.245517);
#define CTNODE_cmu_us_awb_dur_NO_1868 1870
DEF_STATIC_CONST_VAL_FLOAT(val_1089,0.007975);
#define CTNODE_cmu_us_awb_dur_NO_1863 1871
DEF_STATIC_CONST_VAL_FLOAT(val_1090,-0.143721);
#define CTNODE_cmu_us_awb_dur_NO_1872 1874
DEF_STATIC_CONST_VAL_FLOAT(val_1091,0.239336);
#define CTNODE_cmu_us_awb_dur_NO_1874 1876
DEF_STATIC_CONST_VAL_FLOAT(val_1092,-0.025378);
#define CTNODE_cmu_us_awb_dur_NO_1871 1877
DEF_STATIC_CONST_VAL_FLOAT(val_1093,0.128841);
#define CTNODE_cmu_us_awb_dur_NO_1877 1879
DEF_STATIC_CONST_VAL_FLOAT(val_1094,0.064477);
#define CTNODE_cmu_us_awb_dur_NO_1879 1881
DEF_STATIC_CONST_VAL_FLOAT(val_1095,-0.670331);
#define CTNODE_cmu_us_awb_dur_NO_1882 1884
DEF_STATIC_CONST_VAL_FLOAT(val_1096,-0.574265);
#define CTNODE_cmu_us_awb_dur_NO_1884 1886
DEF_STATIC_CONST_VAL_FLOAT(val_1097,-0.169775);
#define CTNODE_cmu_us_awb_dur_NO_1886 1888
DEF_STATIC_CONST_VAL_FLOAT(val_1098,-0.408302);
#define CTNODE_cmu_us_awb_dur_NO_1881 1889
DEF_STATIC_CONST_VAL_FLOAT(val_1099,-0.565134);
#define CTNODE_cmu_us_awb_dur_NO_1890 1892
DEF_STATIC_CONST_VAL_FLOAT(val_1100,-0.237127);
#define CTNODE_cmu_us_awb_dur_NO_1889 1893
DEF_STATIC_CONST_VAL_FLOAT(val_1101,-0.207418);
#define CTNODE_cmu_us_awb_dur_NO_1894 1896
DEF_STATIC_CONST_VAL_FLOAT(val_1102,-0.423151);
#define CTNODE_cmu_us_awb_dur_NO_1893 1897
DEF_STATIC_CONST_VAL_FLOAT(val_1103,-0.296422);
#define CTNODE_cmu_us_awb_dur_NO_1897 1899
DEF_STATIC_CONST_VAL_FLOAT(val_1104,-0.253944);
#define CTNODE_cmu_us_awb_dur_NO_1899 1901
DEF_STATIC_CONST_VAL_FLOAT(val_1105,-0.068910);
#define CTNODE_cmu_us_awb_dur_NO_1902 1904
DEF_STATIC_CONST_VAL_FLOAT(val_1106,0.135024);
#define CTNODE_cmu_us_awb_dur_NO_1901 1905
DEF_STATIC_CONST_VAL_FLOAT(val_1107,-0.183449);
#define CTNODE_cmu_us_awb_dur_NO_1860 1906
DEF_STATIC_CONST_VAL_FLOAT(val_1108,-0.288670);
#define CTNODE_cmu_us_awb_dur_NO_1907 1909
DEF_STATIC_CONST_VAL_FLOAT(val_1109,-0.639632);
#define CTNODE_cmu_us_awb_dur_NO_1909 1911
DEF_STATIC_CONST_VAL_FLOAT(val_1110,-0.359206);
#define CTNODE_cmu_us_awb_dur_NO_1911 1913
DEF_STATIC_CONST_VAL_FLOAT(val_1111,-0.538122);
#define CTNODE_cmu_us_awb_dur_NO_1906 1914
DEF_STATIC_CONST_VAL_FLOAT(val_1112,-0.158244);
#define CTNODE_cmu_us_awb_dur_NO_1811 1915
DEF_STATIC_CONST_VAL_FLOAT(val_1113,-0.787074);
#define CTNODE_cmu_us_awb_dur_NO_1916 1918
DEF_STATIC_CONST_VAL_FLOAT(val_1114,-0.795706);
#define CTNODE_cmu_us_awb_dur_NO_1919 1921
DEF_STATIC_CONST_VAL_FLOAT(val_1115,-0.645573);
#define CTNODE_cmu_us_awb_dur_NO_1918 1922
DEF_STATIC_CONST_VAL_FLOAT(val_1116,-0.398775);
#define CTNODE_cmu_us_awb_dur_NO_1923 1925
DEF_STATIC_CONST_VAL_FLOAT(val_1117,-0.213755);
#define CTNODE_cmu_us_awb_dur_NO_1922 1926
DEF_STATIC_CONST_VAL_FLOAT(val_1118,-0.378240);
#define CTNODE_cmu_us_awb_dur_NO_1926 1928
DEF_STATIC_CONST_VAL_FLOAT(val_1119,-0.678592);
#define CTNODE_cmu_us_awb_dur_NO_1928 1930
DEF_STATIC_CONST_VAL_FLOAT(val_1120,-0.642220);
#define CTNODE_cmu_us_awb_dur_NO_1930 1932
DEF_STATIC_CONST_VAL_FLOAT(val_1121,-0.399122);
#define CTNODE_cmu_us_awb_dur_NO_1932 1934
DEF_STATIC_CONST_VAL_FLOAT(val_1122,-0.488039);
#define CTNODE_cmu_us_awb_dur_NO_1934 1936
DEF_STATIC_CONST_VAL_FLOAT(val_1123,-0.620952);
#define CTNODE_cmu_us_awb_dur_NO_1915 1937
DEF_STATIC_CONST_VAL_FLOAT(val_1124,0.215983);
#define CTNODE_cmu_us_awb_dur_NO_1937 1939
DEF_STATIC_CONST_VAL_FLOAT(val_1125,0.124606);
#define CTNODE_cmu_us_awb_dur_NO_1940 1942
DEF_STATIC_CONST_VAL_FLOAT(val_1126,-0.022920);
#define CTNODE_cmu_us_awb_dur_NO_1939 1943
DEF_STATIC_CONST_VAL_STRING(val_1127,"md");
DEF_STATIC_CONST_VAL_FLOAT(val_1128,-0.453920);
#define CTNODE_cmu_us_awb_dur_NO_1943 1945
DEF_STATIC_CONST_VAL_FLOAT(val_1129,-0.409189);
#define CTNODE_cmu_us_awb_dur_NO_1945 1947
DEF_STATIC_CONST_VAL_FLOAT(val_1130,0.076974);
#define CTNODE_cmu_us_awb_dur_NO_1948 1950
DEF_STATIC_CONST_VAL_FLOAT(val_1131,-0.227154);
#define CTNODE_cmu_us_awb_dur_NO_1951 1953
DEF_STATIC_CONST_VAL_FLOAT(val_1132,-0.475994);
#define CTNODE_cmu_us_awb_dur_NO_1950 1954
DEF_STATIC_CONST_VAL_FLOAT(val_1133,0.051996);
#define CTNODE_cmu_us_awb_dur_NO_1954 1956
DEF_STATIC_CONST_VAL_FLOAT(val_1134,-0.213785);
#define CTNODE_cmu_us_awb_dur_NO_1947 1957
DEF_STATIC_CONST_VAL_FLOAT(val_1135,-0.363894);
#define CTNODE_cmu_us_awb_dur_NO_0190 1958
DEF_STATIC_CONST_VAL_FLOAT(val_1136,-0.735599);
#define CTNODE_cmu_us_awb_dur_NO_1961 1963
DEF_STATIC_CONST_VAL_FLOAT(val_1137,-0.615834);
#define CTNODE_cmu_us_awb_dur_NO_1963 1965
DEF_STATIC_CONST_VAL_FLOAT(val_1138,-0.709890);
#define CTNODE_cmu_us_awb_dur_NO_1960 1966
DEF_STATIC_CONST_VAL_FLOAT(val_1139,-0.897691);
#define CTNODE_cmu_us_awb_dur_NO_1959 1967
DEF_STATIC_CONST_VAL_FLOAT(val_1140,0.027422);
#define CTNODE_cmu_us_awb_dur_NO_1958 1968
DEF_STATIC_CONST_VAL_FLOAT(val_1141,-0.237274);
#define CTNODE_cmu_us_awb_dur_NO_1970 1972
DEF_STATIC_CONST_VAL_FLOAT(val_1142,-0.669614);
#define CTNODE_cmu_us_awb_dur_NO_1973 1975
DEF_STATIC_CONST_VAL_FLOAT(val_1143,-0.419953);
#define CTNODE_cmu_us_awb_dur_NO_1975 1977
DEF_STATIC_CONST_VAL_FLOAT(val_1144,-0.178216);
#define CTNODE_cmu_us_awb_dur_NO_1972 1978
DEF_STATIC_CONST_VAL_FLOAT(val_1145,-0.581892);
#define CTNODE_cmu_us_awb_dur_NO_1978 1980
DEF_STATIC_CONST_VAL_FLOAT(val_1146,-0.662018);
#define CTNODE_cmu_us_awb_dur_NO_1980 1982
DEF_STATIC_CONST_VAL_FLOAT(val_1147,-0.816395);
#define CTNODE_cmu_us_awb_dur_NO_1969 1983
DEF_STATIC_CONST_VAL_FLOAT(val_1148,0.146430);
#define CTNODE_cmu_us_awb_dur_NO_1968 1984
DEF_STATIC_CONST_VAL_FLOAT(val_1149,-0.265330);
#define CTNODE_cmu_us_awb_dur_NO_1987 1989
DEF_STATIC_CONST_VAL_FLOAT(val_1150,1.192300);
#define CTNODE_cmu_us_awb_dur_NO_1989 1991
DEF_STATIC_CONST_VAL_FLOAT(val_1151,0.576674);
#define CTNODE_cmu_us_awb_dur_NO_1991 1993
DEF_STATIC_CONST_VAL_FLOAT(val_1152,0.239695);
#define CTNODE_cmu_us_awb_dur_NO_1994 1996
DEF_STATIC_CONST_VAL_FLOAT(val_1153,0.604456);
#define CTNODE_cmu_us_awb_dur_NO_1993 1997
DEF_STATIC_CONST_VAL_FLOAT(val_1154,-0.130113);
#define CTNODE_cmu_us_awb_dur_NO_1986 1998
DEF_STATIC_CONST_VAL_FLOAT(val_1155,0.140127);
#define CTNODE_cmu_us_awb_dur_NO_2002 2004
DEF_STATIC_CONST_VAL_FLOAT(val_1156,0.568531);
#define CTNODE_cmu_us_awb_dur_NO_2004 2006
DEF_STATIC_CONST_VAL_FLOAT(val_1157,0.193122);
#define CTNODE_cmu_us_awb_dur_NO_2001 2007
DEF_STATIC_CONST_VAL_FLOAT(val_1158,-0.054826);
#define CTNODE_cmu_us_awb_dur_NO_2000 2008
DEF_STATIC_CONST_VAL_FLOAT(val_1159,0.256084);
#define CTNODE_cmu_us_awb_dur_NO_2009 2011
DEF_STATIC_CONST_VAL_FLOAT(val_1160,-0.085212);
#define CTNODE_cmu_us_awb_dur_NO_2008 2012
DEF_STATIC_CONST_VAL_FLOAT(val_1161,4.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_1162,-0.212223);
#define CTNODE_cmu_us_awb_dur_NO_2012 2014
DEF_STATIC_CONST_VAL_FLOAT(val_1163,-0.127792);
#define CTNODE_cmu_us_awb_dur_NO_1999 2015
DEF_STATIC_CONST_VAL_FLOAT(val_1164,0.425355);
#define CTNODE_cmu_us_awb_dur_NO_2016 2018
DEF_STATIC_CONST_VAL_FLOAT(val_1165,0.984237);
#define CTNODE_cmu_us_awb_dur_NO_2015 2019
DEF_STATIC_CONST_VAL_FLOAT(val_1166,0.049086);
#define CTNODE_cmu_us_awb_dur_NO_1998 2020
DEF_STATIC_CONST_VAL_FLOAT(val_1167,-0.630601);
#define CTNODE_cmu_us_awb_dur_NO_2021 2023
DEF_STATIC_CONST_VAL_FLOAT(val_1168,-0.351232);
#define CTNODE_cmu_us_awb_dur_NO_2023 2025
DEF_STATIC_CONST_VAL_FLOAT(val_1169,-0.532131);
#define CTNODE_cmu_us_awb_dur_NO_2020 2026
DEF_STATIC_CONST_VAL_FLOAT(val_1170,-0.692266);
#define CTNODE_cmu_us_awb_dur_NO_2026 2028
DEF_STATIC_CONST_VAL_FLOAT(val_1171,-0.455406);
#define CTNODE_cmu_us_awb_dur_NO_2029 2031
DEF_STATIC_CONST_VAL_FLOAT(val_1172,-0.145812);
#define CTNODE_cmu_us_awb_dur_NO_2033 2035
DEF_STATIC_CONST_VAL_FLOAT(val_1173,0.497937);
#define CTNODE_cmu_us_awb_dur_NO_2032 2036
DEF_STATIC_CONST_VAL_FLOAT(val_1174,1.264890);
#define CTNODE_cmu_us_awb_dur_NO_2036 2038
DEF_STATIC_CONST_VAL_FLOAT(val_1175,0.777615);
#define CTNODE_cmu_us_awb_dur_NO_2031 2039
DEF_STATIC_CONST_VAL_FLOAT(val_1176,-0.242093);
#define CTNODE_cmu_us_awb_dur_NO_2041 2043
DEF_STATIC_CONST_VAL_FLOAT(val_1177,-0.058674);
#define CTNODE_cmu_us_awb_dur_NO_2043 2045
DEF_STATIC_CONST_VAL_FLOAT(val_1178,0.243466);
#define CTNODE_cmu_us_awb_dur_NO_2040 2046
DEF_STATIC_CONST_VAL_FLOAT(val_1179,0.044019);
#define CTNODE_cmu_us_awb_dur_NO_2046 2048
DEF_STATIC_CONST_VAL_FLOAT(val_1180,0.710008);
#define CTNODE_cmu_us_awb_dur_NO_2039 2049
DEF_STATIC_CONST_VAL_FLOAT(val_1181,-0.444423);
#define CTNODE_cmu_us_awb_dur_NO_2049 2051
DEF_STATIC_CONST_VAL_FLOAT(val_1182,-0.318843);
#define CTNODE_cmu_us_awb_dur_NO_2051 2053
DEF_STATIC_CONST_VAL_FLOAT(val_1183,-0.030115);
#define CTNODE_cmu_us_awb_dur_NO_2028 2054
DEF_STATIC_CONST_VAL_STRING(val_1184,"r_147");
DEF_STATIC_CONST_VAL_FLOAT(val_1185,0.454643);
#define CTNODE_cmu_us_awb_dur_NO_2054 2056
DEF_STATIC_CONST_VAL_FLOAT(val_1186,-0.619320);
#define CTNODE_cmu_us_awb_dur_NO_2057 2059
DEF_STATIC_CONST_VAL_FLOAT(val_1187,-0.303671);
#define CTNODE_cmu_us_awb_dur_NO_2056 2060
DEF_STATIC_CONST_VAL_FLOAT(val_1188,-0.612370);
#define CTNODE_cmu_us_awb_dur_NO_2061 2063
DEF_STATIC_CONST_VAL_FLOAT(val_1189,-0.181769);
#define CTNODE_cmu_us_awb_dur_NO_2063 2065
DEF_STATIC_CONST_VAL_FLOAT(val_1190,-0.438272);
#define CTNODE_cmu_us_awb_dur_NO_2060 2066
DEF_STATIC_CONST_VAL_FLOAT(val_1191,-0.237861);
#define CTNODE_cmu_us_awb_dur_NO_2067 2069
DEF_STATIC_CONST_VAL_FLOAT(val_1192,-0.665828);
#define CTNODE_cmu_us_awb_dur_NO_2066 2070
DEF_STATIC_CONST_VAL_STRING(val_1193,"ih_86");
DEF_STATIC_CONST_VAL_FLOAT(val_1194,0.866193);
#define CTNODE_cmu_us_awb_dur_NO_2071 2073
DEF_STATIC_CONST_VAL_FLOAT(val_1195,-0.190475);
#define CTNODE_cmu_us_awb_dur_NO_2070 2074
DEF_STATIC_CONST_VAL_FLOAT(val_1196,0.046594);
#define CTNODE_cmu_us_awb_dur_NO_2075 2077
DEF_STATIC_CONST_VAL_FLOAT(val_1197,-0.171185);
#define CTNODE_cmu_us_awb_dur_NO_2077 2079
DEF_STATIC_CONST_VAL_FLOAT(val_1198,-0.574396);
#define CTNODE_cmu_us_awb_dur_NO_2079 2081
DEF_STATIC_CONST_VAL_FLOAT(val_1199,-0.425788);
#define CTNODE_cmu_us_awb_dur_NO_2074 2082
DEF_STATIC_CONST_VAL_FLOAT(val_1200,-0.527571);
#define CTNODE_cmu_us_awb_dur_NO_2082 2084
DEF_STATIC_CONST_VAL_FLOAT(val_1201,0.398220);
#define CTNODE_cmu_us_awb_dur_NO_2084 2086
DEF_STATIC_CONST_VAL_STRING(val_1202,"ae_8");
DEF_STATIC_CONST_VAL_FLOAT(val_1203,-0.174211);
#define CTNODE_cmu_us_awb_dur_NO_2087 2089
DEF_STATIC_CONST_VAL_FLOAT(val_1204,0.581994);
#define CTNODE_cmu_us_awb_dur_NO_2089 2091
DEF_STATIC_CONST_VAL_FLOAT(val_1205,0.227845);
#define CTNODE_cmu_us_awb_dur_NO_2086 2092
DEF_STATIC_CONST_VAL_STRING(val_1206,"v_186");
DEF_STATIC_CONST_VAL_FLOAT(val_1207,0.482280);
#define CTNODE_cmu_us_awb_dur_NO_2092 2094
DEF_STATIC_CONST_VAL_FLOAT(val_1208,0.520715);
#define CTNODE_cmu_us_awb_dur_NO_2096 2098
DEF_STATIC_CONST_VAL_FLOAT(val_1209,0.127742);
#define CTNODE_cmu_us_awb_dur_NO_2098 2100
DEF_STATIC_CONST_VAL_FLOAT(val_1210,-0.112452);
#define CTNODE_cmu_us_awb_dur_NO_2095 2101
DEF_STATIC_CONST_VAL_FLOAT(val_1211,0.316219);
#define CTNODE_cmu_us_awb_dur_NO_2101 2103
DEF_STATIC_CONST_VAL_FLOAT(val_1212,-0.307252);
#define CTNODE_cmu_us_awb_dur_NO_2103 2105
DEF_STATIC_CONST_VAL_FLOAT(val_1213,0.407948);
#define CTNODE_cmu_us_awb_dur_NO_2106 2108
DEF_STATIC_CONST_VAL_FLOAT(val_1214,-0.416488);
#define CTNODE_cmu_us_awb_dur_NO_2108 2110
DEF_STATIC_CONST_VAL_FLOAT(val_1215,-0.329961);
#define CTNODE_cmu_us_awb_dur_NO_2111 2113
DEF_STATIC_CONST_VAL_FLOAT(val_1216,0.217768);
#define CTNODE_cmu_us_awb_dur_NO_2113 2115
DEF_STATIC_CONST_VAL_FLOAT(val_1217,-0.142331);
#define CTNODE_cmu_us_awb_dur_NO_2110 2116
DEF_STATIC_CONST_VAL_FLOAT(val_1218,-0.062216);
#define CTNODE_cmu_us_awb_dur_NO_2118 2120
DEF_STATIC_CONST_VAL_FLOAT(val_1219,-0.267730);
#define CTNODE_cmu_us_awb_dur_NO_2117 2121
DEF_STATIC_CONST_VAL_FLOAT(val_1220,0.173681);
#define CTNODE_cmu_us_awb_dur_NO_2116 2122
DEF_STATIC_CONST_VAL_FLOAT(val_1221,0.502030);
#define CTNODE_cmu_us_awb_dur_NO_2122 2124
DEF_STATIC_CONST_VAL_FLOAT(val_1222,0.164339);
#define CTNODE_cmu_us_awb_dur_NO_2105 2125
DEF_STATIC_CONST_VAL_FLOAT(val_1223,-0.379745);
#define CTNODE_cmu_us_awb_dur_NO_2125 2127
DEF_STATIC_CONST_VAL_FLOAT(val_1224,0.083634);
#define CTNODE_cmu_us_awb_dur_NO_2127 2129
DEF_STATIC_CONST_VAL_FLOAT(val_1225,-0.180656);
#define CTNODE_cmu_us_awb_dur_NO_2094 2130
DEF_STATIC_CONST_VAL_FLOAT(val_1226,-0.471828);
#define CTNODE_cmu_us_awb_dur_NO_2131 2133
DEF_STATIC_CONST_VAL_FLOAT(val_1227,0.320237);
#define CTNODE_cmu_us_awb_dur_NO_2133 2135
DEF_STATIC_CONST_VAL_FLOAT(val_1228,-0.482466);
#define CTNODE_cmu_us_awb_dur_NO_2136 2138
DEF_STATIC_CONST_VAL_FLOAT(val_1229,-0.334725);
#define CTNODE_cmu_us_awb_dur_NO_2135 2139
DEF_STATIC_CONST_VAL_FLOAT(val_1230,-0.261437);
#define CTNODE_cmu_us_awb_dur_NO_2141 2143
DEF_STATIC_CONST_VAL_FLOAT(val_1231,0.193903);
#define CTNODE_cmu_us_awb_dur_NO_2140 2144
DEF_STATIC_CONST_VAL_FLOAT(val_1232,0.372166);
#define CTNODE_cmu_us_awb_dur_NO_2139 2145
DEF_STATIC_CONST_VAL_FLOAT(val_1233,6.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1234,0.102859);
#define CTNODE_cmu_us_awb_dur_NO_2147 2149
DEF_STATIC_CONST_VAL_FLOAT(val_1235,-0.130603);
#define CTNODE_cmu_us_awb_dur_NO_2146 2150
DEF_STATIC_CONST_VAL_FLOAT(val_1236,-0.427813);
#define CTNODE_cmu_us_awb_dur_NO_2151 2153
DEF_STATIC_CONST_VAL_FLOAT(val_1237,-0.381895);
#define CTNODE_cmu_us_awb_dur_NO_2153 2155
DEF_STATIC_CONST_VAL_FLOAT(val_1238,-0.135722);
#define CTNODE_cmu_us_awb_dur_NO_2156 2158
DEF_STATIC_CONST_VAL_FLOAT(val_1239,-0.320457);
#define CTNODE_cmu_us_awb_dur_NO_2155 2159
DEF_STATIC_CONST_VAL_FLOAT(val_1240,0.023443);
#define CTNODE_cmu_us_awb_dur_NO_2150 2160
DEF_STATIC_CONST_VAL_FLOAT(val_1241,-0.496143);
#define CTNODE_cmu_us_awb_dur_NO_2145 2161
DEF_STATIC_CONST_VAL_FLOAT(val_1242,0.014665);
#define CTNODE_cmu_us_awb_dur_NO_2163 2165
DEF_STATIC_CONST_VAL_FLOAT(val_1243,0.177732);
#define CTNODE_cmu_us_awb_dur_NO_2162 2166
DEF_STATIC_CONST_VAL_FLOAT(val_1244,-0.095703);
#define CTNODE_cmu_us_awb_dur_NO_2161 2167
DEF_STATIC_CONST_VAL_FLOAT(val_1245,-0.357583);
#define CTNODE_cmu_us_awb_dur_NO_2167 2169
DEF_STATIC_CONST_VAL_FLOAT(val_1246,-0.139975);
#define CTNODE_cmu_us_awb_dur_NO_2130 2170
DEF_STATIC_CONST_VAL_FLOAT(val_1247,-0.380013);
#define CTNODE_cmu_us_awb_dur_NO_2170 2172
DEF_STATIC_CONST_VAL_FLOAT(val_1248,-0.409986);
#define CTNODE_cmu_us_awb_dur_NO_2172 2174
DEF_STATIC_CONST_VAL_FLOAT(val_1249,-0.133429);
#define CTNODE_cmu_us_awb_dur_NO_2175 2177
DEF_STATIC_CONST_VAL_FLOAT(val_1250,-0.502362);
#define CTNODE_cmu_us_awb_dur_NO_2174 2178
DEF_STATIC_CONST_VAL_FLOAT(val_1251,-0.399135);
#define CTNODE_cmu_us_awb_dur_NO_2180 2182
DEF_STATIC_CONST_VAL_FLOAT(val_1252,-0.039910);
#define CTNODE_cmu_us_awb_dur_NO_2182 2184
DEF_STATIC_CONST_VAL_FLOAT(val_1253,-0.300744);
#define CTNODE_cmu_us_awb_dur_NO_2179 2185
DEF_STATIC_CONST_VAL_FLOAT(val_1254,0.079946);
#define CTNODE_cmu_us_awb_dur_NO_2178 2186
DEF_STATIC_CONST_VAL_FLOAT(val_1255,-0.369203);
#define CTNODE_cmu_us_awb_dur_NO_2187 2189
DEF_STATIC_CONST_VAL_FLOAT(val_1256,-0.067762);
#define CTNODE_cmu_us_awb_dur_NO_2186 2190
DEF_STATIC_CONST_VAL_FLOAT(val_1257,1.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1258,-0.265027);
#define CTNODE_cmu_us_awb_dur_NO_2190 2192
DEF_STATIC_CONST_VAL_FLOAT(val_1259,9.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1260,0.691997);
#define CTNODE_cmu_us_awb_dur_NO_2193 2195
DEF_STATIC_CONST_VAL_FLOAT(val_1261,0.200178);
#define CTNODE_cmu_us_awb_dur_NO_2192 2196
DEF_STATIC_CONST_VAL_FLOAT(val_1262,-0.211479);
#define CTNODE_cmu_us_awb_dur_NO_2196 2198
DEF_STATIC_CONST_VAL_FLOAT(val_1263,11.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1264,0.693171);
#define CTNODE_cmu_us_awb_dur_NO_2199 2201
DEF_STATIC_CONST_VAL_FLOAT(val_1265,-0.254551);
#define CTNODE_cmu_us_awb_dur_NO_2203 2205
DEF_STATIC_CONST_VAL_FLOAT(val_1266,-0.127039);
#define CTNODE_cmu_us_awb_dur_NO_2205 2207
DEF_STATIC_CONST_VAL_FLOAT(val_1267,0.270011);
#define CTNODE_cmu_us_awb_dur_NO_2202 2208
DEF_STATIC_CONST_VAL_FLOAT(val_1268,-0.115215);
#define CTNODE_cmu_us_awb_dur_NO_2208 2210
DEF_STATIC_CONST_VAL_FLOAT(val_1269,0.406014);
#define CTNODE_cmu_us_awb_dur_NO_2211 2213
DEF_STATIC_CONST_VAL_FLOAT(val_1270,-0.200670);
#define CTNODE_cmu_us_awb_dur_NO_2213 2215
DEF_STATIC_CONST_VAL_FLOAT(val_1271,0.267567);
#define CTNODE_cmu_us_awb_dur_NO_2210 2216
DEF_STATIC_CONST_VAL_FLOAT(val_1272,0.454510);
#define CTNODE_cmu_us_awb_dur_NO_2201 2217
DEF_STATIC_CONST_VAL_FLOAT(val_1273,0.467666);
#define CTNODE_cmu_us_awb_dur_NO_2198 2218
DEF_STATIC_CONST_VAL_FLOAT(val_1274,-0.273880);
#define CTNODE_cmu_us_awb_dur_NO_2218 2220
DEF_STATIC_CONST_VAL_FLOAT(val_1275,0.118612);
#define CTNODE_cmu_us_awb_dur_NO_1985 2221
DEF_STATIC_CONST_VAL_FLOAT(val_1276,0.851060);
#define CTNODE_cmu_us_awb_dur_NO_2222 2224
DEF_STATIC_CONST_VAL_FLOAT(val_1277,-0.482210);
#define CTNODE_cmu_us_awb_dur_NO_2225 2227
DEF_STATIC_CONST_VAL_FLOAT(val_1278,0.279735);
#define CTNODE_cmu_us_awb_dur_NO_2227 2229
DEF_STATIC_CONST_VAL_FLOAT(val_1279,-0.350348);
#define CTNODE_cmu_us_awb_dur_NO_2224 2230
DEF_STATIC_CONST_VAL_FLOAT(val_1280,0.264854);
#define CTNODE_cmu_us_awb_dur_NO_2231 2233
DEF_STATIC_CONST_VAL_FLOAT(val_1281,-0.104650);
#define CTNODE_cmu_us_awb_dur_NO_2233 2235
DEF_STATIC_CONST_VAL_FLOAT(val_1282,-0.354182);
#define CTNODE_cmu_us_awb_dur_NO_2230 2236
DEF_STATIC_CONST_VAL_FLOAT(val_1283,0.079134);
#define CTNODE_cmu_us_awb_dur_NO_2236 2238
DEF_STATIC_CONST_VAL_FLOAT(val_1284,0.604950);
#define CTNODE_cmu_us_awb_dur_NO_2238 2240
DEF_STATIC_CONST_VAL_FLOAT(val_1285,0.247208);
#define CTNODE_cmu_us_awb_dur_NO_2221 2241
DEF_STATIC_CONST_VAL_FLOAT(val_1286,-0.275040);
#define CTNODE_cmu_us_awb_dur_NO_2242 2244
DEF_STATIC_CONST_VAL_FLOAT(val_1287,0.667554);
#define CTNODE_cmu_us_awb_dur_NO_2244 2246
DEF_STATIC_CONST_VAL_FLOAT(val_1288,-0.026622);
#define CTNODE_cmu_us_awb_dur_NO_2246 2248
DEF_STATIC_CONST_VAL_FLOAT(val_1289,0.143194);
#define CTNODE_cmu_us_awb_dur_NO_2248 2250
DEF_STATIC_CONST_VAL_FLOAT(val_1290,0.413543);
#define CTNODE_cmu_us_awb_dur_NO_2241 2251
DEF_STATIC_CONST_VAL_STRING(val_1291,"z_200");
DEF_STATIC_CONST_VAL_FLOAT(val_1292,0.686921);
#define CTNODE_cmu_us_awb_dur_NO_2252 2254
DEF_STATIC_CONST_VAL_FLOAT(val_1293,11.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1294,0.002992);
#define CTNODE_cmu_us_awb_dur_NO_2255 2257
DEF_STATIC_CONST_VAL_FLOAT(val_1295,0.396829);
#define CTNODE_cmu_us_awb_dur_NO_2254 2258
DEF_STATIC_CONST_VAL_FLOAT(val_1296,-0.266475);
#define CTNODE_cmu_us_awb_dur_NO_2251 2259
DEF_STATIC_CONST_VAL_FLOAT(val_1297,-0.345900);
#define CTNODE_cmu_us_awb_dur_NO_2261 2263
DEF_STATIC_CONST_VAL_FLOAT(val_1298,0.025509);
#define CTNODE_cmu_us_awb_dur_NO_2260 2264
DEF_STATIC_CONST_VAL_FLOAT(val_1299,-0.637495);
#define CTNODE_cmu_us_awb_dur_NO_2264 2266
DEF_STATIC_CONST_VAL_FLOAT(val_1300,-0.370778);
#define CTNODE_cmu_us_awb_dur_NO_2266 2268
DEF_STATIC_CONST_VAL_FLOAT(val_1301,-0.548247);
#define CTNODE_cmu_us_awb_dur_NO_2268 2270
DEF_STATIC_CONST_VAL_FLOAT(val_1302,-0.448282);
#define CTNODE_cmu_us_awb_dur_NO_2259 2271
DEF_STATIC_CONST_VAL_FLOAT(val_1303,0.562285);
#define CTNODE_cmu_us_awb_dur_NO_2271 2273
DEF_STATIC_CONST_VAL_FLOAT(val_1304,-0.395300);
#define CTNODE_cmu_us_awb_dur_NO_2274 2276
DEF_STATIC_CONST_VAL_FLOAT(val_1305,-0.791406);
#define CTNODE_cmu_us_awb_dur_NO_2273 2277
DEF_STATIC_CONST_VAL_FLOAT(val_1306,0.575854);
#define CTNODE_cmu_us_awb_dur_NO_2278 2280
DEF_STATIC_CONST_VAL_FLOAT(val_1307,-0.215276);
#define CTNODE_cmu_us_awb_dur_NO_2280 2282
DEF_STATIC_CONST_VAL_FLOAT(val_1308,0.159559);
#define CTNODE_cmu_us_awb_dur_NO_2277 2283
DEF_STATIC_CONST_VAL_STRING(val_1309,"aa_3");
DEF_STATIC_CONST_VAL_FLOAT(val_1310,-0.529761);
#define CTNODE_cmu_us_awb_dur_NO_2287 2289
DEF_STATIC_CONST_VAL_FLOAT(val_1311,-0.492205);
#define CTNODE_cmu_us_awb_dur_NO_2286 2290
DEF_STATIC_CONST_VAL_FLOAT(val_1312,0.024998);
#define CTNODE_cmu_us_awb_dur_NO_2290 2292
DEF_STATIC_CONST_VAL_FLOAT(val_1313,-0.000043);
#define CTNODE_cmu_us_awb_dur_NO_2285 2293
DEF_STATIC_CONST_VAL_FLOAT(val_1314,-0.624969);
#define CTNODE_cmu_us_awb_dur_NO_2294 2296
DEF_STATIC_CONST_VAL_FLOAT(val_1315,-0.368384);
#define CTNODE_cmu_us_awb_dur_NO_2296 2298
DEF_STATIC_CONST_VAL_FLOAT(val_1316,-0.634059);
#define CTNODE_cmu_us_awb_dur_NO_2298 2300
DEF_STATIC_CONST_VAL_FLOAT(val_1317,-0.466363);
#define CTNODE_cmu_us_awb_dur_NO_2293 2301
DEF_STATIC_CONST_VAL_FLOAT(val_1318,-0.417888);
#define CTNODE_cmu_us_awb_dur_NO_2301 2303
DEF_STATIC_CONST_VAL_FLOAT(val_1319,-0.257220);
#define CTNODE_cmu_us_awb_dur_NO_2284 2304
DEF_STATIC_CONST_VAL_FLOAT(val_1320,-0.380258);
#define CTNODE_cmu_us_awb_dur_NO_2304 2306
DEF_STATIC_CONST_VAL_STRING(val_1321,"ao");
DEF_STATIC_CONST_VAL_FLOAT(val_1322,-0.148317);
#define CTNODE_cmu_us_awb_dur_NO_2307 2309
DEF_STATIC_CONST_VAL_FLOAT(val_1323,-0.435562);
#define CTNODE_cmu_us_awb_dur_NO_2306 2310
DEF_STATIC_CONST_VAL_FLOAT(val_1324,-0.259940);
#define CTNODE_cmu_us_awb_dur_NO_2310 2312
DEF_STATIC_CONST_VAL_FLOAT(val_1325,0.382663);
#define CTNODE_cmu_us_awb_dur_NO_2312 2314
DEF_STATIC_CONST_VAL_FLOAT(val_1326,0.164988);
#define CTNODE_cmu_us_awb_dur_NO_2314 2316
DEF_STATIC_CONST_VAL_FLOAT(val_1327,-0.148352);
#define CTNODE_cmu_us_awb_dur_NO_2283 2317
DEF_STATIC_CONST_VAL_FLOAT(val_1328,0.388230);
#define CTNODE_cmu_us_awb_dur_NO_2317 2319
DEF_STATIC_CONST_VAL_STRING(val_1329,"t_165");
DEF_STATIC_CONST_VAL_FLOAT(val_1330,-0.418327);
#define CTNODE_cmu_us_awb_dur_NO_2321 2323
DEF_STATIC_CONST_VAL_FLOAT(val_1331,-0.764448);
#define CTNODE_cmu_us_awb_dur_NO_2320 2324
DEF_STATIC_CONST_VAL_FLOAT(val_1332,-0.234348);
#define CTNODE_cmu_us_awb_dur_NO_2319 2325
DEF_STATIC_CONST_VAL_FLOAT(val_1333,-0.929847);
#define CTNODE_cmu_us_awb_dur_NO_2326 2328
DEF_STATIC_CONST_VAL_FLOAT(val_1334,0.479851);
#define CTNODE_cmu_us_awb_dur_NO_2329 2331
DEF_STATIC_CONST_VAL_FLOAT(val_1335,-0.303997);
#define CTNODE_cmu_us_awb_dur_NO_2331 2333
DEF_STATIC_CONST_VAL_FLOAT(val_1336,0.115157);
#define CTNODE_cmu_us_awb_dur_NO_2328 2334
DEF_STATIC_CONST_VAL_FLOAT(val_1337,-0.468739);
#define CTNODE_cmu_us_awb_dur_NO_2337 2339
DEF_STATIC_CONST_VAL_FLOAT(val_1338,0.002609);
#define CTNODE_cmu_us_awb_dur_NO_2336 2340
DEF_STATIC_CONST_VAL_FLOAT(val_1339,-0.662521);
#define CTNODE_cmu_us_awb_dur_NO_2340 2342
DEF_STATIC_CONST_VAL_FLOAT(val_1340,-0.706347);
#define CTNODE_cmu_us_awb_dur_NO_2343 2345
DEF_STATIC_CONST_VAL_FLOAT(val_1341,-0.461660);
#define CTNODE_cmu_us_awb_dur_NO_2342 2346
DEF_STATIC_CONST_VAL_FLOAT(val_1342,-0.350925);
#define CTNODE_cmu_us_awb_dur_NO_2335 2347
DEF_STATIC_CONST_VAL_FLOAT(val_1343,0.241180);
#define CTNODE_cmu_us_awb_dur_NO_2348 2350
DEF_STATIC_CONST_VAL_FLOAT(val_1344,0.180866);
#define CTNODE_cmu_us_awb_dur_NO_2350 2352
DEF_STATIC_CONST_VAL_FLOAT(val_1345,-0.405052);
#define CTNODE_cmu_us_awb_dur_NO_2347 2353
DEF_STATIC_CONST_VAL_FLOAT(val_1346,-0.336309);
#define CTNODE_cmu_us_awb_dur_NO_2334 2354
DEF_STATIC_CONST_VAL_FLOAT(val_1347,0.472300);
#define CTNODE_cmu_us_awb_dur_NO_2354 2356
DEF_STATIC_CONST_VAL_STRING(val_1348,"aa_1");
DEF_STATIC_CONST_VAL_FLOAT(val_1349,0.407942);
#define CTNODE_cmu_us_awb_dur_NO_2357 2359
DEF_STATIC_CONST_VAL_FLOAT(val_1350,-0.205845);
#define CTNODE_cmu_us_awb_dur_NO_2356 2360
DEF_STATIC_CONST_VAL_FLOAT(val_1351,-0.258639);
#define CTNODE_cmu_us_awb_dur_NO_2363 2365
DEF_STATIC_CONST_VAL_FLOAT(val_1352,-0.419403);
#define CTNODE_cmu_us_awb_dur_NO_2362 2366
DEF_STATIC_CONST_VAL_FLOAT(val_1353,0.055186);
#define CTNODE_cmu_us_awb_dur_NO_2361 2367
DEF_STATIC_CONST_VAL_FLOAT(val_1354,-0.084390);
#define CTNODE_cmu_us_awb_dur_NO_2369 2371
DEF_STATIC_CONST_VAL_FLOAT(val_1355,-0.371776);
#define CTNODE_cmu_us_awb_dur_NO_2368 2372
DEF_STATIC_CONST_VAL_FLOAT(val_1356,-0.500712);
#define CTNODE_cmu_us_awb_dur_NO_2367 2373
DEF_STATIC_CONST_VAL_FLOAT(val_1357,-0.579032);
#define CTNODE_cmu_us_awb_dur_NO_2360 2374
DEF_STATIC_CONST_VAL_FLOAT(val_1358,-0.669657);
#define CTNODE_cmu_us_awb_dur_NO_2375 2377
DEF_STATIC_CONST_VAL_FLOAT(val_1359,-0.213293);
#define CTNODE_cmu_us_awb_dur_NO_2374 2378
DEF_STATIC_CONST_VAL_FLOAT(val_1360,-0.497107);
#define CTNODE_cmu_us_awb_dur_NO_2378 2380
DEF_STATIC_CONST_VAL_STRING(val_1361,"cc");
DEF_STATIC_CONST_VAL_FLOAT(val_1362,0.118520);
#define CTNODE_cmu_us_awb_dur_NO_2382 2384
DEF_STATIC_CONST_VAL_FLOAT(val_1363,-0.249949);
#define CTNODE_cmu_us_awb_dur_NO_2381 2385
DEF_STATIC_CONST_VAL_FLOAT(val_1364,-0.592497);
#define CTNODE_cmu_us_awb_dur_NO_2385 2387
DEF_STATIC_CONST_VAL_FLOAT(val_1365,-0.363553);
#define CTNODE_cmu_us_awb_dur_NO_2380 2388
DEF_STATIC_CONST_VAL_FLOAT(val_1366,-0.504327);
#define CTNODE_cmu_us_awb_dur_NO_2389 2391
DEF_STATIC_CONST_VAL_FLOAT(val_1367,-0.305183);
#define CTNODE_cmu_us_awb_dur_NO_2388 2392
DEF_STATIC_CONST_VAL_FLOAT(val_1368,0.663469);
#define CTNODE_cmu_us_awb_dur_NO_2396 2398
DEF_STATIC_CONST_VAL_FLOAT(val_1369,0.245323);
#define CTNODE_cmu_us_awb_dur_NO_2395 2399
DEF_STATIC_CONST_VAL_FLOAT(val_1370,-0.137024);
#define CTNODE_cmu_us_awb_dur_NO_2394 2400
DEF_STATIC_CONST_VAL_FLOAT(val_1371,-0.321100);
#define CTNODE_cmu_us_awb_dur_NO_2400 2402
DEF_STATIC_CONST_VAL_FLOAT(val_1372,0.637739);
#define CTNODE_cmu_us_awb_dur_NO_2405 2407
DEF_STATIC_CONST_VAL_FLOAT(val_1373,0.065129);
#define CTNODE_cmu_us_awb_dur_NO_2404 2408
DEF_STATIC_CONST_VAL_FLOAT(val_1374,-0.436846);
#define CTNODE_cmu_us_awb_dur_NO_2410 2412
DEF_STATIC_CONST_VAL_FLOAT(val_1375,-0.277600);
#define CTNODE_cmu_us_awb_dur_NO_2409 2413
DEF_STATIC_CONST_VAL_FLOAT(val_1376,-0.154419);
#define CTNODE_cmu_us_awb_dur_NO_2408 2414
DEF_STATIC_CONST_VAL_FLOAT(val_1377,4.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_1378,-0.165041);
#define CTNODE_cmu_us_awb_dur_NO_2416 2418
DEF_STATIC_CONST_VAL_FLOAT(val_1379,-0.457766);
#define CTNODE_cmu_us_awb_dur_NO_2415 2419
DEF_STATIC_CONST_VAL_FLOAT(val_1380,-0.195955);
#define CTNODE_cmu_us_awb_dur_NO_2419 2421
DEF_STATIC_CONST_VAL_FLOAT(val_1381,-0.038742);
#define CTNODE_cmu_us_awb_dur_NO_2421 2423
DEF_STATIC_CONST_VAL_FLOAT(val_1382,0.354976);
#define CTNODE_cmu_us_awb_dur_NO_2414 2424
DEF_STATIC_CONST_VAL_FLOAT(val_1383,0.460025);
#define CTNODE_cmu_us_awb_dur_NO_2424 2426
DEF_STATIC_CONST_VAL_FLOAT(val_1384,0.379939);
#define CTNODE_cmu_us_awb_dur_NO_2427 2429
DEF_STATIC_CONST_VAL_FLOAT(val_1385,0.071314);
#define CTNODE_cmu_us_awb_dur_NO_2426 2430
DEF_STATIC_CONST_VAL_FLOAT(val_1386,-0.397168);
#define CTNODE_cmu_us_awb_dur_NO_2430 2432
DEF_STATIC_CONST_VAL_FLOAT(val_1387,4.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_1388,7.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_1389,-0.052357);
#define CTNODE_cmu_us_awb_dur_NO_2433 2435
DEF_STATIC_CONST_VAL_FLOAT(val_1390,-0.331260);
#define CTNODE_cmu_us_awb_dur_NO_2432 2436
DEF_STATIC_CONST_VAL_FLOAT(val_1391,0.277176);
#define CTNODE_cmu_us_awb_dur_NO_2436 2438
DEF_STATIC_CONST_VAL_FLOAT(val_1392,-0.090017);
#define CTNODE_cmu_us_awb_dur_NO_2403 2439
DEF_STATIC_CONST_VAL_FLOAT(val_1393,0.217100);
#define CTNODE_cmu_us_awb_dur_NO_2440 2442
DEF_STATIC_CONST_VAL_FLOAT(val_1394,-0.032367);
#define CTNODE_cmu_us_awb_dur_NO_2439 2443
DEF_STATIC_CONST_VAL_FLOAT(val_1395,-0.479794);
#define CTNODE_cmu_us_awb_dur_NO_2443 2445
DEF_STATIC_CONST_VAL_FLOAT(val_1396,-0.055641);
#define CTNODE_cmu_us_awb_dur_NO_2445 2447
DEF_STATIC_CONST_VAL_FLOAT(val_1397,-0.385009);
#define CTNODE_cmu_us_awb_dur_NO_2447 2449
DEF_STATIC_CONST_VAL_FLOAT(val_1398,-0.155392);
#define CTNODE_cmu_us_awb_dur_NO_2402 2450
DEF_STATIC_CONST_VAL_FLOAT(val_1399,-0.136862);
#define CTNODE_cmu_us_awb_dur_NO_2450 2452
DEF_STATIC_CONST_VAL_FLOAT(val_1400,-0.461447);
#define CTNODE_cmu_us_awb_dur_NO_2393 2453
DEF_STATIC_CONST_VAL_FLOAT(val_1401,-0.495595);
#define CTNODE_cmu_us_awb_dur_NO_2454 2456
DEF_STATIC_CONST_VAL_FLOAT(val_1402,6.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_1403,-0.072778);
#define CTNODE_cmu_us_awb_dur_NO_2456 2458
DEF_STATIC_CONST_VAL_FLOAT(val_1404,-0.290027);
#define CTNODE_cmu_us_awb_dur_NO_2453 2459
DEF_STATIC_CONST_VAL_FLOAT(val_1405,0.239271);
#define CTNODE_cmu_us_awb_dur_NO_2460 2462
DEF_STATIC_CONST_VAL_FLOAT(val_1406,0.047530);
#define CTNODE_cmu_us_awb_dur_NO_2462 2464
DEF_STATIC_CONST_VAL_FLOAT(val_1407,-0.260553);
#define CTNODE_cmu_us_awb_dur_NO_2459 2465
DEF_STATIC_CONST_VAL_FLOAT(val_1408,-0.370898);
#define CTNODE_cmu_us_awb_dur_NO_2466 2468
DEF_STATIC_CONST_VAL_FLOAT(val_1409,-0.222024);
#define CTNODE_cmu_us_awb_dur_NO_2468 2470
DEF_STATIC_CONST_VAL_FLOAT(val_1410,0.049029);
#define CTNODE_cmu_us_awb_dur_NO_2471 2473
DEF_STATIC_CONST_VAL_FLOAT(val_1411,0.239765);
#define CTNODE_cmu_us_awb_dur_NO_2470 2474
DEF_STATIC_CONST_VAL_FLOAT(val_1412,-0.063201);
#define CTNODE_cmu_us_awb_dur_NO_2465 2475
DEF_STATIC_CONST_VAL_FLOAT(val_1413,-0.482353);
#define CTNODE_cmu_us_awb_dur_NO_2476 2478
DEF_STATIC_CONST_VAL_FLOAT(val_1414,-0.275901);
#define CTNODE_cmu_us_awb_dur_NO_2475 2479
DEF_STATIC_CONST_VAL_FLOAT(val_1415,-0.099408);
#define CTNODE_cmu_us_awb_dur_NO_2392 2480
DEF_STATIC_CONST_VAL_FLOAT(val_1416,0.053991);
#define CTNODE_cmu_us_awb_dur_NO_2480 2482
DEF_STATIC_CONST_VAL_FLOAT(val_1417,-0.395823);
#define CTNODE_cmu_us_awb_dur_NO_2482 2484
DEF_STATIC_CONST_VAL_FLOAT(val_1418,-0.529234);
#define CTNODE_cmu_us_awb_dur_NO_2484 2486
DEF_STATIC_CONST_VAL_FLOAT(val_1419,-0.340273);
#define CTNODE_cmu_us_awb_dur_NO_2486 2488
DEF_STATIC_CONST_VAL_FLOAT(val_1420,0.047516);
#define CTNODE_cmu_us_awb_dur_NO_2488 2490
DEF_STATIC_CONST_VAL_FLOAT(val_1421,-0.210330);
#define CTNODE_cmu_us_awb_dur_NO_2491 2493
#define CTNODE_cmu_us_awb_dur_NO_2490 2494
DEF_STATIC_CONST_VAL_FLOAT(val_1422,-0.420167);
#define CTNODE_cmu_us_awb_dur_NO_2495 2497
DEF_STATIC_CONST_VAL_FLOAT(val_1423,-0.038833);
#define CTNODE_cmu_us_awb_dur_NO_2494 2498
DEF_STATIC_CONST_VAL_FLOAT(val_1424,0.071779);
#define CTNODE_cmu_us_awb_dur_NO_2498 2500
DEF_STATIC_CONST_VAL_FLOAT(val_1425,-0.189736);
#define CTNODE_cmu_us_awb_dur_NO_2325 2501
DEF_STATIC_CONST_VAL_FLOAT(val_1426,-0.392717);
#define CTNODE_cmu_us_awb_dur_NO_2502 2504
DEF_STATIC_CONST_VAL_FLOAT(val_1427,0.067583);
#define CTNODE_cmu_us_awb_dur_NO_2504 2506
DEF_STATIC_CONST_VAL_FLOAT(val_1428,0.028576);
#define CTNODE_cmu_us_awb_dur_NO_2506 2508
DEF_STATIC_CONST_VAL_FLOAT(val_1429,-0.412938);
#define CTNODE_cmu_us_awb_dur_NO_2508 2510
DEF_STATIC_CONST_VAL_FLOAT(val_1430,-0.182355);
#define CTNODE_cmu_us_awb_dur_NO_2501 2511
DEF_STATIC_CONST_VAL_FLOAT(val_1431,-0.344011);
#define CTNODE_cmu_us_awb_dur_NO_2511 2513
DEF_STATIC_CONST_VAL_FLOAT(val_1432,-0.277092);
#define CTNODE_cmu_us_awb_dur_NO_2514 2516
DEF_STATIC_CONST_VAL_FLOAT(val_1433,0.335705);
#define CTNODE_cmu_us_awb_dur_NO_2516 2518
DEF_STATIC_CONST_VAL_FLOAT(val_1434,0.017175);
#define CTNODE_cmu_us_awb_dur_NO_2518 2520
DEF_STATIC_CONST_VAL_FLOAT(val_1435,-0.203492);
#define CTNODE_cmu_us_awb_dur_NO_2513 2521
DEF_STATIC_CONST_VAL_FLOAT(val_1436,-0.151735);
#define CTNODE_cmu_us_awb_dur_NO_2521 2523
DEF_STATIC_CONST_VAL_FLOAT(val_1437,0.337797);
#define CTNODE_cmu_us_awb_dur_NO_2524 2526
DEF_STATIC_CONST_VAL_FLOAT(val_1438,0.249791);
#define CTNODE_cmu_us_awb_dur_NO_2526 2528
DEF_STATIC_CONST_VAL_FLOAT(val_1439,-0.291188);
#define CTNODE_cmu_us_awb_dur_NO_2528 2530
DEF_STATIC_CONST_VAL_FLOAT(val_1440,0.069539);
#define CTNODE_cmu_us_awb_dur_NO_2523 2531
DEF_STATIC_CONST_VAL_FLOAT(val_1441,0.568114);
#define CTNODE_cmu_us_awb_dur_NO_1984 2532
DEF_STATIC_CONST_VAL_STRING(val_1442,"er_62");
DEF_STATIC_CONST_VAL_FLOAT(val_1443,-0.041775);
#define CTNODE_cmu_us_awb_dur_NO_2533 2535
DEF_STATIC_CONST_VAL_FLOAT(val_1444,-0.359319);
#define CTNODE_cmu_us_awb_dur_NO_2536 2538
DEF_STATIC_CONST_VAL_FLOAT(val_1445,-0.634958);
#define CTNODE_cmu_us_awb_dur_NO_2535 2539
DEF_STATIC_CONST_VAL_FLOAT(val_1446,-0.889834);
#define CTNODE_cmu_us_awb_dur_NO_2540 2542
DEF_STATIC_CONST_VAL_FLOAT(val_1447,-0.762539);
#define CTNODE_cmu_us_awb_dur_NO_2539 2543
DEF_STATIC_CONST_VAL_FLOAT(val_1448,-0.517382);
#define CTNODE_cmu_us_awb_dur_NO_2532 2544
DEF_STATIC_CONST_VAL_FLOAT(val_1449,0.680596);
#define CTNODE_cmu_us_awb_dur_NO_2546 2548
DEF_STATIC_CONST_VAL_FLOAT(val_1450,-0.316423);
#define CTNODE_cmu_us_awb_dur_NO_2548 2550
DEF_STATIC_CONST_VAL_FLOAT(val_1451,0.326698);
#define CTNODE_cmu_us_awb_dur_NO_2550 2552
DEF_STATIC_CONST_VAL_FLOAT(val_1452,-0.029660);
#define CTNODE_cmu_us_awb_dur_NO_2545 2553
DEF_STATIC_CONST_VAL_FLOAT(val_1453,0.738441);
#define CTNODE_cmu_us_awb_dur_NO_2555 2557
DEF_STATIC_CONST_VAL_STRING(val_1454,"mid");
DEF_STATIC_CONST_VAL_FLOAT(val_1455,-0.227562);
#define CTNODE_cmu_us_awb_dur_NO_2557 2559
DEF_STATIC_CONST_VAL_FLOAT(val_1456,0.072479);
#define CTNODE_cmu_us_awb_dur_NO_2559 2561
DEF_STATIC_CONST_VAL_FLOAT(val_1457,0.487920);
#define CTNODE_cmu_us_awb_dur_NO_2561 2563
DEF_STATIC_CONST_VAL_FLOAT(val_1458,0.202272);
#define CTNODE_cmu_us_awb_dur_NO_2554 2564
DEF_STATIC_CONST_VAL_FLOAT(val_1459,-0.439319);
#define CTNODE_cmu_us_awb_dur_NO_2553 2565
DEF_STATIC_CONST_VAL_STRING(val_1460,"s_152");
DEF_STATIC_CONST_VAL_FLOAT(val_1461,-0.661316);
#define CTNODE_cmu_us_awb_dur_NO_2566 2568
DEF_STATIC_CONST_VAL_FLOAT(val_1462,-0.638922);
#define CTNODE_cmu_us_awb_dur_NO_2568 2570
DEF_STATIC_CONST_VAL_FLOAT(val_1463,0.910560);
#define CTNODE_cmu_us_awb_dur_NO_2573 2575
DEF_STATIC_CONST_VAL_FLOAT(val_1464,0.110427);
#define CTNODE_cmu_us_awb_dur_NO_2575 2577
DEF_STATIC_CONST_VAL_FLOAT(val_1465,-0.439921);
#define CTNODE_cmu_us_awb_dur_NO_2572 2578
DEF_STATIC_CONST_VAL_FLOAT(val_1466,-0.393395);
#define CTNODE_cmu_us_awb_dur_NO_2579 2581
DEF_STATIC_CONST_VAL_FLOAT(val_1467,-0.512089);
#define CTNODE_cmu_us_awb_dur_NO_2578 2582
DEF_STATIC_CONST_VAL_FLOAT(val_1468,-0.032141);
#define CTNODE_cmu_us_awb_dur_NO_2583 2585
DEF_STATIC_CONST_VAL_FLOAT(val_1469,-0.436636);
#define CTNODE_cmu_us_awb_dur_NO_2586 2588
DEF_STATIC_CONST_VAL_FLOAT(val_1470,-0.082572);
#define CTNODE_cmu_us_awb_dur_NO_2585 2589
DEF_STATIC_CONST_VAL_FLOAT(val_1471,-0.335507);
#define CTNODE_cmu_us_awb_dur_NO_2589 2591
DEF_STATIC_CONST_VAL_FLOAT(val_1472,-0.521778);
#define CTNODE_cmu_us_awb_dur_NO_2582 2592
DEF_STATIC_CONST_VAL_FLOAT(val_1473,-0.064225);
#define CTNODE_cmu_us_awb_dur_NO_2594 2596
DEF_STATIC_CONST_VAL_FLOAT(val_1474,0.345713);
#define CTNODE_cmu_us_awb_dur_NO_2593 2597
DEF_STATIC_CONST_VAL_FLOAT(val_1475,-0.438470);
#define CTNODE_cmu_us_awb_dur_NO_2597 2599
DEF_STATIC_CONST_VAL_FLOAT(val_1476,0.109878);
#define CTNODE_cmu_us_awb_dur_NO_2592 2600
DEF_STATIC_CONST_VAL_FLOAT(val_1477,-0.009837);
#define CTNODE_cmu_us_awb_dur_NO_2601 2603
DEF_STATIC_CONST_VAL_FLOAT(val_1478,-0.361908);
#define CTNODE_cmu_us_awb_dur_NO_2600 2604
DEF_STATIC_CONST_VAL_FLOAT(val_1479,-0.362957);
#define CTNODE_cmu_us_awb_dur_NO_2571 2605
DEF_STATIC_CONST_VAL_FLOAT(val_1480,0.079126);
#define CTNODE_cmu_us_awb_dur_NO_2606 2608
DEF_STATIC_CONST_VAL_FLOAT(val_1481,0.900865);
#define CTNODE_cmu_us_awb_dur_NO_2605 2609
DEF_STATIC_CONST_VAL_FLOAT(val_1482,-0.387441);
#define CTNODE_cmu_us_awb_dur_NO_2609 2611
DEF_STATIC_CONST_VAL_FLOAT(val_1483,-0.302113);
#define CTNODE_cmu_us_awb_dur_NO_2613 2615
DEF_STATIC_CONST_VAL_FLOAT(val_1484,-0.140300);
#define CTNODE_cmu_us_awb_dur_NO_2615 2617
DEF_STATIC_CONST_VAL_FLOAT(val_1485,0.551402);
#define CTNODE_cmu_us_awb_dur_NO_2617 2619
DEF_STATIC_CONST_VAL_FLOAT(val_1486,0.010824);
#define CTNODE_cmu_us_awb_dur_NO_2619 2621
DEF_STATIC_CONST_VAL_FLOAT(val_1487,0.296249);
#define CTNODE_cmu_us_awb_dur_NO_2612 2622
DEF_STATIC_CONST_VAL_FLOAT(val_1488,0.753256);
#define CTNODE_cmu_us_awb_dur_NO_2611 2623
DEF_STATIC_CONST_VAL_FLOAT(val_1489,-0.036085);
#define CTNODE_cmu_us_awb_dur_NO_2625 2627
DEF_STATIC_CONST_VAL_FLOAT(val_1490,0.530890);
#define CTNODE_cmu_us_awb_dur_NO_2624 2628
DEF_STATIC_CONST_VAL_FLOAT(val_1491,-0.342392);
#define CTNODE_cmu_us_awb_dur_NO_2623 2629
DEF_STATIC_CONST_VAL_FLOAT(val_1492,-0.526656);
#define CTNODE_cmu_us_awb_dur_NO_2629 2631
DEF_STATIC_CONST_VAL_FLOAT(val_1493,-0.180355);
#define CTNODE_cmu_us_awb_dur_NO_2632 2634
DEF_STATIC_CONST_VAL_FLOAT(val_1494,0.105055);
#define CTNODE_cmu_us_awb_dur_NO_2631 2635
DEF_STATIC_CONST_VAL_FLOAT(val_1495,-0.312960);
#define CTNODE_cmu_us_awb_dur_NO_2570 2636
DEF_STATIC_CONST_VAL_FLOAT(val_1496,-0.250509);
#define CTNODE_cmu_us_awb_dur_NO_2637 2639
DEF_STATIC_CONST_VAL_FLOAT(val_1497,-0.495349);
#define CTNODE_cmu_us_awb_dur_NO_2640 2642
DEF_STATIC_CONST_VAL_FLOAT(val_1498,-0.585995);
#define CTNODE_cmu_us_awb_dur_NO_2639 2643
DEF_STATIC_CONST_VAL_FLOAT(val_1499,-0.300755);
#define CTNODE_cmu_us_awb_dur_NO_2636 2644
DEF_STATIC_CONST_VAL_FLOAT(val_1500,0.058275);
#define CTNODE_cmu_us_awb_dur_NO_2644 2646
DEF_STATIC_CONST_VAL_FLOAT(val_1501,-0.273569);
#define CTNODE_cmu_us_awb_dur_NO_2565 2647
DEF_STATIC_CONST_VAL_FLOAT(val_1502,0.112662);
#define CTNODE_cmu_us_awb_dur_NO_2648 2650
DEF_STATIC_CONST_VAL_FLOAT(val_1503,0.336415);
#define CTNODE_cmu_us_awb_dur_NO_2647 2651
DEF_STATIC_CONST_VAL_FLOAT(val_1504,0.324289);
#define CTNODE_cmu_us_awb_dur_NO_2651 2653
DEF_STATIC_CONST_VAL_FLOAT(val_1505,-0.351535);
#define CTNODE_cmu_us_awb_dur_NO_2654 2656
DEF_STATIC_CONST_VAL_FLOAT(val_1506,0.427218);
#define CTNODE_cmu_us_awb_dur_NO_2653 2657
DEF_STATIC_CONST_VAL_FLOAT(val_1507,0.251570);
#define CTNODE_cmu_us_awb_dur_NO_2658 2660
DEF_STATIC_CONST_VAL_FLOAT(val_1508,0.203224);
#define CTNODE_cmu_us_awb_dur_NO_2660 2662
DEF_STATIC_CONST_VAL_FLOAT(val_1509,0.108351);
#define CTNODE_cmu_us_awb_dur_NO_2662 2664
DEF_STATIC_CONST_VAL_FLOAT(val_1510,0.140142);
#define CTNODE_cmu_us_awb_dur_NO_2665 2667
DEF_STATIC_CONST_VAL_FLOAT(val_1511,-0.210522);
#define CTNODE_cmu_us_awb_dur_NO_2664 2668
DEF_STATIC_CONST_VAL_FLOAT(val_1512,0.000741);
#define CTNODE_cmu_us_awb_dur_NO_2668 2670
DEF_STATIC_CONST_VAL_FLOAT(val_1513,11.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_1514,-0.198493);
#define CTNODE_cmu_us_awb_dur_NO_2671 2673
DEF_STATIC_CONST_VAL_FLOAT(val_1515,-0.760063);
#define CTNODE_cmu_us_awb_dur_NO_2674 2676
DEF_STATIC_CONST_VAL_FLOAT(val_1516,-0.431286);
#define CTNODE_cmu_us_awb_dur_NO_2673 2677
DEF_STATIC_CONST_VAL_FLOAT(val_1517,-0.574292);
#define CTNODE_cmu_us_awb_dur_NO_2678 2680
DEF_STATIC_CONST_VAL_FLOAT(val_1518,-0.272260);
#define CTNODE_cmu_us_awb_dur_NO_2677 2681
DEF_STATIC_CONST_VAL_FLOAT(val_1519,-0.363991);
#define CTNODE_cmu_us_awb_dur_NO_2681 2683
DEF_STATIC_CONST_VAL_FLOAT(val_1520,-0.144468);
#define CTNODE_cmu_us_awb_dur_NO_2670 2684
DEF_STATIC_CONST_VAL_FLOAT(val_1521,0.026175);
#define CTNODE_cmu_us_awb_dur_NO_2684 2686
DEF_STATIC_CONST_VAL_FLOAT(val_1522,-0.280449);
#define CTNODE_cmu_us_awb_dur_NO_2657 2687
DEF_STATIC_CONST_VAL_FLOAT(val_1523,7.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_1524,-0.440111);
#define CTNODE_cmu_us_awb_dur_NO_2690 2692
DEF_STATIC_CONST_VAL_FLOAT(val_1525,-0.053533);
#define CTNODE_cmu_us_awb_dur_NO_2689 2693
DEF_STATIC_CONST_VAL_FLOAT(val_1526,0.054874);
#define CTNODE_cmu_us_awb_dur_NO_2688 2694
DEF_STATIC_CONST_VAL_FLOAT(val_1527,0.122143);
#define CTNODE_cmu_us_awb_dur_NO_2687 2695
DEF_STATIC_CONST_VAL_STRING(val_1528,"ng");
DEF_STATIC_CONST_VAL_FLOAT(val_1529,-0.681158);
#define CTNODE_cmu_us_awb_dur_NO_2696 2698
DEF_STATIC_CONST_VAL_FLOAT(val_1530,8.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_1531,-0.755138);
#define CTNODE_cmu_us_awb_dur_NO_2700 2702
DEF_STATIC_CONST_VAL_FLOAT(val_1532,-0.579792);
#define CTNODE_cmu_us_awb_dur_NO_2699 2703
DEF_STATIC_CONST_VAL_FLOAT(val_1533,-0.279728);
#define CTNODE_cmu_us_awb_dur_NO_2698 2704
DEF_STATIC_CONST_VAL_FLOAT(val_1534,-0.710014);
#define CTNODE_cmu_us_awb_dur_NO_2705 2707
DEF_STATIC_CONST_VAL_FLOAT(val_1535,-0.513418);
#define CTNODE_cmu_us_awb_dur_NO_2704 2708
DEF_STATIC_CONST_VAL_FLOAT(val_1536,0.181127);
#define CTNODE_cmu_us_awb_dur_NO_2709 2711
DEF_STATIC_CONST_VAL_FLOAT(val_1537,-0.606957);
#define CTNODE_cmu_us_awb_dur_NO_2711 2713
DEF_STATIC_CONST_VAL_FLOAT(val_1538,-0.652703);
#define CTNODE_cmu_us_awb_dur_NO_2713 2715
DEF_STATIC_CONST_VAL_FLOAT(val_1539,-0.620655);
#define CTNODE_cmu_us_awb_dur_NO_2718 2720
DEF_STATIC_CONST_VAL_FLOAT(val_1540,-0.411899);
#define CTNODE_cmu_us_awb_dur_NO_2717 2721
DEF_STATIC_CONST_VAL_FLOAT(val_1541,-0.178953);
#define CTNODE_cmu_us_awb_dur_NO_2716 2722
DEF_STATIC_CONST_VAL_FLOAT(val_1542,-0.052211);
#define CTNODE_cmu_us_awb_dur_NO_2723 2725
DEF_STATIC_CONST_VAL_FLOAT(val_1543,-0.416798);
#define CTNODE_cmu_us_awb_dur_NO_2726 2728
DEF_STATIC_CONST_VAL_FLOAT(val_1544,0.094080);
#define CTNODE_cmu_us_awb_dur_NO_2728 2730
DEF_STATIC_CONST_VAL_FLOAT(val_1545,-0.237316);
#define CTNODE_cmu_us_awb_dur_NO_2725 2731
DEF_STATIC_CONST_VAL_FLOAT(val_1546,10.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_1547,-0.227848);
#define CTNODE_cmu_us_awb_dur_NO_2732 2734
DEF_STATIC_CONST_VAL_FLOAT(val_1548,-0.463411);
#define CTNODE_cmu_us_awb_dur_NO_2734 2736
DEF_STATIC_CONST_VAL_FLOAT(val_1549,-0.326606);
#define CTNODE_cmu_us_awb_dur_NO_2731 2737
DEF_STATIC_CONST_VAL_FLOAT(val_1550,-0.519251);
#define CTNODE_cmu_us_awb_dur_NO_2722 2738
DEF_STATIC_CONST_VAL_FLOAT(val_1551,-0.226521);
#define CTNODE_cmu_us_awb_dur_NO_2739 2741
DEF_STATIC_CONST_VAL_FLOAT(val_1552,-0.414946);
#define CTNODE_cmu_us_awb_dur_NO_2738 2742
DEF_STATIC_CONST_VAL_FLOAT(val_1553,-0.178944);
#define CTNODE_cmu_us_awb_dur_NO_2743 2745
DEF_STATIC_CONST_VAL_FLOAT(val_1554,-0.072395);
#define CTNODE_cmu_us_awb_dur_NO_2745 2747
DEF_STATIC_CONST_VAL_FLOAT(val_1555,0.388436);
#define CTNODE_cmu_us_awb_dur_NO_2742 2748
DEF_STATIC_CONST_VAL_FLOAT(val_1556,-0.166935);
#define CTNODE_cmu_us_awb_dur_NO_2750 2752
DEF_STATIC_CONST_VAL_FLOAT(val_1557,0.339023);
#define CTNODE_cmu_us_awb_dur_NO_2749 2753
DEF_STATIC_CONST_VAL_FLOAT(val_1558,-0.357804);
#define CTNODE_cmu_us_awb_dur_NO_2753 2755
DEF_STATIC_CONST_VAL_FLOAT(val_1559,-0.254001);
#define CTNODE_cmu_us_awb_dur_NO_2756 2758
DEF_STATIC_CONST_VAL_FLOAT(val_1560,0.049838);
#define CTNODE_cmu_us_awb_dur_NO_2755 2759
DEF_STATIC_CONST_VAL_FLOAT(val_1561,-0.078113);
#define CTNODE_cmu_us_awb_dur_NO_2759 2761
DEF_STATIC_CONST_VAL_FLOAT(val_1562,-0.336559);
#define CTNODE_cmu_us_awb_dur_NO_2748 2762
DEF_STATIC_CONST_VAL_FLOAT(val_1563,-0.478817);
#define CTNODE_cmu_us_awb_dur_NO_2763 2765
DEF_STATIC_CONST_VAL_FLOAT(val_1564,-0.250535);
#define CTNODE_cmu_us_awb_dur_NO_2762 2766
DEF_STATIC_CONST_VAL_FLOAT(val_1565,-0.146259);
#define CTNODE_cmu_us_awb_dur_NO_2715 2767
DEF_STATIC_CONST_VAL_FLOAT(val_1566,-0.464937);
#define CTNODE_cmu_us_awb_dur_NO_2768 2770
DEF_STATIC_CONST_VAL_FLOAT(val_1567,-0.625655);
#define CTNODE_cmu_us_awb_dur_NO_2770 2772
DEF_STATIC_CONST_VAL_FLOAT(val_1568,-0.721788);
#define CTNODE_cmu_us_awb_dur_NO_2767 2773
DEF_STATIC_CONST_VAL_STRING(val_1569,"ng_121");
DEF_STATIC_CONST_VAL_FLOAT(val_1570,0.130530);
#define CTNODE_cmu_us_awb_dur_NO_2774 2776
DEF_STATIC_CONST_VAL_FLOAT(val_1571,-0.261581);
#define CTNODE_cmu_us_awb_dur_NO_2776 2778
DEF_STATIC_CONST_VAL_FLOAT(val_1572,-0.339654);
#define CTNODE_cmu_us_awb_dur_NO_2773 2779
DEF_STATIC_CONST_VAL_FLOAT(val_1573,-0.038177);
#define CTNODE_cmu_us_awb_dur_NO_2779 2781
DEF_STATIC_CONST_VAL_FLOAT(val_1574,-0.410213);
#define CTNODE_cmu_us_awb_dur_NO_2782 2784
DEF_STATIC_CONST_VAL_FLOAT(val_1575,-0.392529);
#define CTNODE_cmu_us_awb_dur_NO_2784 2786
DEF_STATIC_CONST_VAL_FLOAT(val_1576,-0.321301);
#define CTNODE_cmu_us_awb_dur_NO_2786 2788
DEF_STATIC_CONST_VAL_FLOAT(val_1577,-0.222451);
#define CTNODE_cmu_us_awb_dur_NO_2788 2790
DEF_STATIC_CONST_VAL_FLOAT(val_1578,-0.078090);
#define CTNODE_cmu_us_awb_dur_NO_2781 2791
DEF_STATIC_CONST_VAL_FLOAT(val_1579,-0.583944);
#define CTNODE_cmu_us_awb_dur_NO_2793 2795
DEF_STATIC_CONST_VAL_FLOAT(val_1580,-0.356786);
#define CTNODE_cmu_us_awb_dur_NO_2795 2797
DEF_STATIC_CONST_VAL_FLOAT(val_1581,-0.509236);
#define CTNODE_cmu_us_awb_dur_NO_2797 2799
DEF_STATIC_CONST_VAL_FLOAT(val_1582,-0.456552);
#define CTNODE_cmu_us_awb_dur_NO_2792 2800
DEF_STATIC_CONST_VAL_FLOAT(val_1583,-0.319021);
#define CTNODE_cmu_us_awb_dur_NO_2791 2801
DEF_STATIC_CONST_VAL_FLOAT(val_1584,-0.414154);
#define CTNODE_cmu_us_awb_dur_NO_2801 2803
DEF_STATIC_CONST_VAL_FLOAT(val_1585,-0.226708);
#define CTNODE_cmu_us_awb_dur_NO_2708 2804
DEF_STATIC_CONST_VAL_FLOAT(val_1586,-0.363704);
#define CTNODE_cmu_us_awb_dur_NO_2805 2807
DEF_STATIC_CONST_VAL_FLOAT(val_1587,0.178850);
#define CTNODE_cmu_us_awb_dur_NO_2804 2808
DEF_STATIC_CONST_VAL_FLOAT(val_1588,-0.682376);
#define CTNODE_cmu_us_awb_dur_NO_2809 2811
DEF_STATIC_CONST_VAL_FLOAT(val_1589,-0.598230);
#define CTNODE_cmu_us_awb_dur_NO_2812 2814
DEF_STATIC_CONST_VAL_FLOAT(val_1590,-0.486554);
#define CTNODE_cmu_us_awb_dur_NO_2811 2815
DEF_STATIC_CONST_VAL_FLOAT(val_1591,-0.626169);
#define CTNODE_cmu_us_awb_dur_NO_2816 2818
DEF_STATIC_CONST_VAL_FLOAT(val_1592,-0.444166);
#define CTNODE_cmu_us_awb_dur_NO_2815 2819
DEF_STATIC_CONST_VAL_FLOAT(val_1593,-0.031689);
#define CTNODE_cmu_us_awb_dur_NO_2820 2822
DEF_STATIC_CONST_VAL_FLOAT(val_1594,-0.485568);
#define CTNODE_cmu_us_awb_dur_NO_2822 2824
DEF_STATIC_CONST_VAL_FLOAT(val_1595,-0.167697);
#define CTNODE_cmu_us_awb_dur_NO_2824 2826
DEF_STATIC_CONST_VAL_FLOAT(val_1596,-0.370464);
#define CTNODE_cmu_us_awb_dur_NO_2819 2827
DEF_STATIC_CONST_VAL_FLOAT(val_1597,-0.202208);
#define CTNODE_cmu_us_awb_dur_NO_2827 2829
DEF_STATIC_CONST_VAL_FLOAT(val_1598,1.900000);
DEF_STATIC_CONST_VAL_FLOAT(val_1599,-0.534716);
#define CTNODE_cmu_us_awb_dur_NO_2829 2831
DEF_STATIC_CONST_VAL_FLOAT(val_1600,-0.627028);
#define CTNODE_cmu_us_awb_dur_NO_2833 2835
DEF_STATIC_CONST_VAL_FLOAT(val_1601,-0.434487);
#define CTNODE_cmu_us_awb_dur_NO_2832 2836
DEF_STATIC_CONST_VAL_FLOAT(val_1602,-0.462586);
#define CTNODE_cmu_us_awb_dur_NO_2836 2838
DEF_STATIC_CONST_VAL_FLOAT(val_1603,-0.194732);
#define CTNODE_cmu_us_awb_dur_NO_2831 2839
DEF_STATIC_CONST_VAL_FLOAT(val_1604,-0.225557);
#define CTNODE_cmu_us_awb_dur_NO_2808 2840
DEF_STATIC_CONST_VAL_FLOAT(val_1605,-0.665837);
#define CTNODE_cmu_us_awb_dur_NO_2840 2842
DEF_STATIC_CONST_VAL_FLOAT(val_1606,-0.425229);
#define CTNODE_cmu_us_awb_dur_NO_2842 2844
DEF_STATIC_CONST_VAL_FLOAT(val_1607,-0.636270);
#define CTNODE_cmu_us_awb_dur_NO_2695 2845
DEF_STATIC_CONST_VAL_FLOAT(val_1608,0.264072);
#define CTNODE_cmu_us_awb_dur_NO_2845 2847
DEF_STATIC_CONST_VAL_FLOAT(val_1609,-0.186072);
#define CTNODE_cmu_us_awb_dur_NO_2544 2848
DEF_STATIC_CONST_VAL_FLOAT(val_1610,-0.920197);
#define CTNODE_cmu_us_awb_dur_NO_2849 2851
DEF_STATIC_CONST_VAL_FLOAT(val_1611,0.864591);
#define CTNODE_cmu_us_awb_dur_NO_2852 2854
DEF_STATIC_CONST_VAL_FLOAT(val_1612,0.101718);
#define CTNODE_cmu_us_awb_dur_NO_2851 2855
DEF_STATIC_CONST_VAL_FLOAT(val_1613,-0.573978);
#define CTNODE_cmu_us_awb_dur_NO_2856 2858
DEF_STATIC_CONST_VAL_FLOAT(val_1614,0.619719);
#define CTNODE_cmu_us_awb_dur_NO_2858 2860
DEF_STATIC_CONST_VAL_FLOAT(val_1615,0.285505);
#define CTNODE_cmu_us_awb_dur_NO_2860 2862
DEF_STATIC_CONST_VAL_FLOAT(val_1616,-0.003411);
#define CTNODE_cmu_us_awb_dur_NO_2864 2866
DEF_STATIC_CONST_VAL_FLOAT(val_1617,-0.349935);
#define CTNODE_cmu_us_awb_dur_NO_2863 2867
DEF_STATIC_CONST_VAL_FLOAT(val_1618,-0.524710);
#define CTNODE_cmu_us_awb_dur_NO_2867 2869
DEF_STATIC_CONST_VAL_FLOAT(val_1619,-0.415279);
#define CTNODE_cmu_us_awb_dur_NO_2869 2871
DEF_STATIC_CONST_VAL_FLOAT(val_1620,-0.028247);
#define CTNODE_cmu_us_awb_dur_NO_2862 2872
DEF_STATIC_CONST_VAL_FLOAT(val_1621,-0.157025);
#define CTNODE_cmu_us_awb_dur_NO_2873 2875
DEF_STATIC_CONST_VAL_FLOAT(val_1622,-0.412199);
#define CTNODE_cmu_us_awb_dur_NO_2872 2876
DEF_STATIC_CONST_VAL_FLOAT(val_1623,0.247443);
#define CTNODE_cmu_us_awb_dur_NO_2876 2878
DEF_STATIC_CONST_VAL_FLOAT(val_1624,-0.363617);
#define CTNODE_cmu_us_awb_dur_NO_2878 2880
DEF_STATIC_CONST_VAL_FLOAT(val_1625,-0.318491);
#define CTNODE_cmu_us_awb_dur_NO_2880 2882
DEF_STATIC_CONST_VAL_FLOAT(val_1626,0.176018);
#define CTNODE_cmu_us_awb_dur_NO_2885 2887
DEF_STATIC_CONST_VAL_FLOAT(val_1627,-0.072247);
#define CTNODE_cmu_us_awb_dur_NO_2884 2888
DEF_STATIC_CONST_VAL_FLOAT(val_1628,-0.419418);
#define CTNODE_cmu_us_awb_dur_NO_2888 2890
DEF_STATIC_CONST_VAL_FLOAT(val_1629,-0.027742);
#define CTNODE_cmu_us_awb_dur_NO_2890 2892
DEF_STATIC_CONST_VAL_FLOAT(val_1630,-0.268066);
#define CTNODE_cmu_us_awb_dur_NO_2883 2893
DEF_STATIC_CONST_VAL_FLOAT(val_1631,0.240940);
#define CTNODE_cmu_us_awb_dur_NO_2882 2894
DEF_STATIC_CONST_VAL_FLOAT(val_1632,-0.061432);
#define CTNODE_cmu_us_awb_dur_NO_2894 2896
DEF_STATIC_CONST_VAL_FLOAT(val_1633,0.405986);
#define CTNODE_cmu_us_awb_dur_NO_2855 2897
DEF_STATIC_CONST_VAL_FLOAT(val_1634,0.617860);
#define CTNODE_cmu_us_awb_dur_NO_2897 2899
DEF_STATIC_CONST_VAL_FLOAT(val_1635,-0.504939);
#define CTNODE_cmu_us_awb_dur_NO_2900 2902
DEF_STATIC_CONST_VAL_FLOAT(val_1636,-0.043210);
#define CTNODE_cmu_us_awb_dur_NO_2899 2903
DEF_STATIC_CONST_VAL_FLOAT(val_1637,0.577763);
#define CTNODE_cmu_us_awb_dur_NO_2903 2905
DEF_STATIC_CONST_VAL_FLOAT(val_1638,-0.000301);
#define CTNODE_cmu_us_awb_dur_NO_2906 2908
DEF_STATIC_CONST_VAL_FLOAT(val_1639,0.471445);
#define CTNODE_cmu_us_awb_dur_NO_2905 2909
DEF_STATIC_CONST_VAL_FLOAT(val_1640,-0.210171);
#define CTNODE_cmu_us_awb_dur_NO_2911 2913
DEF_STATIC_CONST_VAL_FLOAT(val_1641,0.182181);
#define CTNODE_cmu_us_awb_dur_NO_2910 2914
DEF_STATIC_CONST_VAL_FLOAT(val_1642,0.035651);
#define CTNODE_cmu_us_awb_dur_NO_2914 2916
DEF_STATIC_CONST_VAL_FLOAT(val_1643,0.624118);
#define CTNODE_cmu_us_awb_dur_NO_2909 2917
DEF_STATIC_CONST_VAL_FLOAT(val_1644,0.547210);
#define CTNODE_cmu_us_awb_dur_NO_2920 2922
DEF_STATIC_CONST_VAL_FLOAT(val_1645,0.136909);
#define CTNODE_cmu_us_awb_dur_NO_2922 2924
DEF_STATIC_CONST_VAL_FLOAT(val_1646,0.093177);
#define CTNODE_cmu_us_awb_dur_NO_2919 2925
DEF_STATIC_CONST_VAL_FLOAT(val_1647,-0.038242);
#define CTNODE_cmu_us_awb_dur_NO_2918 2926
DEF_STATIC_CONST_VAL_FLOAT(val_1648,0.106920);
#define CTNODE_cmu_us_awb_dur_NO_2926 2928
DEF_STATIC_CONST_VAL_FLOAT(val_1649,-0.165770);
#define CTNODE_cmu_us_awb_dur_NO_2917 2929
DEF_STATIC_CONST_VAL_FLOAT(val_1650,0.155144);
#define CTNODE_cmu_us_awb_dur_NO_2929 2931
DEF_STATIC_CONST_VAL_FLOAT(val_1651,0.183208);
#define CTNODE_cmu_us_awb_dur_NO_2931 2933
DEF_STATIC_CONST_VAL_FLOAT(val_1652,-0.366109);
#define CTNODE_cmu_us_awb_dur_NO_2934 2936
DEF_STATIC_CONST_VAL_FLOAT(val_1653,-0.070149);
#define CTNODE_cmu_us_awb_dur_NO_2937 2939
DEF_STATIC_CONST_VAL_FLOAT(val_1654,0.067840);
#define CTNODE_cmu_us_awb_dur_NO_2936 2940
DEF_STATIC_CONST_VAL_STRING(val_1655,"ah");
DEF_STATIC_CONST_VAL_FLOAT(val_1656,-0.402649);
#define CTNODE_cmu_us_awb_dur_NO_2942 2944
DEF_STATIC_CONST_VAL_FLOAT(val_1657,-0.003882);
#define CTNODE_cmu_us_awb_dur_NO_2944 2946
DEF_STATIC_CONST_VAL_FLOAT(val_1658,-0.325075);
#define CTNODE_cmu_us_awb_dur_NO_2946 2948
DEF_STATIC_CONST_VAL_FLOAT(val_1659,-0.219554);
#define CTNODE_cmu_us_awb_dur_NO_2941 2949
DEF_STATIC_CONST_VAL_FLOAT(val_1660,0.088678);
#define CTNODE_cmu_us_awb_dur_NO_2940 2950
DEF_STATIC_CONST_VAL_FLOAT(val_1661,-0.394567);
#define CTNODE_cmu_us_awb_dur_NO_2933 2951
DEF_STATIC_CONST_VAL_FLOAT(val_1662,0.208337);
#define CTNODE_cmu_us_awb_dur_NO_2951 2953
DEF_STATIC_CONST_VAL_FLOAT(val_1663,-0.145432);
#define CTNODE_cmu_us_awb_dur_NO_2848 2954
DEF_STATIC_CONST_VAL_FLOAT(val_1664,-0.717144);
#define CTNODE_cmu_us_awb_dur_NO_2957 2959
DEF_STATIC_CONST_VAL_FLOAT(val_1665,-0.550273);
#define CTNODE_cmu_us_awb_dur_NO_2956 2960
DEF_STATIC_CONST_VAL_FLOAT(val_1666,-0.439856);
#define CTNODE_cmu_us_awb_dur_NO_2955 2961
DEF_STATIC_CONST_VAL_FLOAT(val_1667,-0.378101);
#define CTNODE_cmu_us_awb_dur_NO_2961 2963
DEF_STATIC_CONST_VAL_FLOAT(val_1668,0.149592);
#define CTNODE_cmu_us_awb_dur_NO_2964 2966
DEF_STATIC_CONST_VAL_FLOAT(val_1669,-0.324405);
#define CTNODE_cmu_us_awb_dur_NO_2966 2968
DEF_STATIC_CONST_VAL_FLOAT(val_1670,-0.215701);
#define CTNODE_cmu_us_awb_dur_NO_2968 2970
DEF_STATIC_CONST_VAL_FLOAT(val_1671,-0.062583);
#define CTNODE_cmu_us_awb_dur_NO_2963 2971
DEF_STATIC_CONST_VAL_FLOAT(val_1672,-0.371250);
#define CTNODE_cmu_us_awb_dur_NO_2954 2972
DEF_STATIC_CONST_VAL_FLOAT(val_1673,-0.657710);
#define CTNODE_cmu_us_awb_dur_NO_2973 2975
DEF_STATIC_CONST_VAL_FLOAT(val_1674,-0.181537);
#define CTNODE_cmu_us_awb_dur_NO_2972 2976
DEF_STATIC_CONST_VAL_FLOAT(val_1675,0.092770);
#define CTNODE_cmu_us_awb_dur_NO_2977 2979
DEF_STATIC_CONST_VAL_FLOAT(val_1676,-0.531887);
#define CTNODE_cmu_us_awb_dur_NO_2979 2981
DEF_STATIC_CONST_VAL_FLOAT(val_1677,-0.486340);
#define CTNODE_cmu_us_awb_dur_NO_2981 2983
DEF_STATIC_CONST_VAL_FLOAT(val_1678,-0.417737);
#define CTNODE_cmu_us_awb_dur_NO_2983 2985
DEF_STATIC_CONST_VAL_FLOAT(val_1679,-0.351661);
#define CTNODE_cmu_us_awb_dur_NO_2985 2987
DEF_STATIC_CONST_VAL_FLOAT(val_1680,-0.135774);
#define CTNODE_cmu_us_awb_dur_NO_2976 2988
DEF_STATIC_CONST_VAL_FLOAT(val_1681,0.619778);
#define CTNODE_cmu_us_awb_dur_NO_2989 2991
DEF_STATIC_CONST_VAL_FLOAT(val_1682,0.343754);
#define CTNODE_cmu_us_awb_dur_NO_2991 2993
DEF_STATIC_CONST_VAL_FLOAT(val_1683,-0.547088);
#define CTNODE_cmu_us_awb_dur_NO_2993 2995
DEF_STATIC_CONST_VAL_FLOAT(val_1684,-0.182890);
#define CTNODE_cmu_us_awb_dur_NO_2988 2996
DEF_STATIC_CONST_VAL_STRING(val_1685,"b_38");
DEF_STATIC_CONST_VAL_FLOAT(val_1686,0.293845);
#define CTNODE_cmu_us_awb_dur_NO_2996 2998
DEF_STATIC_CONST_VAL_FLOAT(val_1687,0.384874);
#define CTNODE_cmu_us_awb_dur_NO_2999 3001
DEF_STATIC_CONST_VAL_FLOAT(val_1688,-0.325862);
#define CTNODE_cmu_us_awb_dur_NO_3001 3003
DEF_STATIC_CONST_VAL_FLOAT(val_1689,0.275906);
#define CTNODE_cmu_us_awb_dur_NO_3003 3005
DEF_STATIC_CONST_VAL_FLOAT(val_1690,-0.277644);
#define CTNODE_cmu_us_awb_dur_NO_3005 3007
DEF_STATIC_CONST_VAL_FLOAT(val_1691,0.111427);
#define CTNODE_cmu_us_awb_dur_NO_2998 3008
DEF_STATIC_CONST_VAL_FLOAT(val_1692,-0.504063);
#define CTNODE_cmu_us_awb_dur_NO_3008 3010
DEF_STATIC_CONST_VAL_FLOAT(val_1693,8.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_1694,-0.052035);
#define CTNODE_cmu_us_awb_dur_NO_3014 3016
DEF_STATIC_CONST_VAL_FLOAT(val_1695,-0.225133);
#define CTNODE_cmu_us_awb_dur_NO_3013 3017
DEF_STATIC_CONST_VAL_FLOAT(val_1696,0.157649);
#define CTNODE_cmu_us_awb_dur_NO_3012 3018
DEF_STATIC_CONST_VAL_FLOAT(val_1697,-0.574024);
#define CTNODE_cmu_us_awb_dur_NO_3011 3019
DEF_STATIC_CONST_VAL_FLOAT(val_1698,-0.117947);
#define CTNODE_cmu_us_awb_dur_NO_3019 3021
DEF_STATIC_CONST_VAL_FLOAT(val_1699,0.324882);
#define CTNODE_cmu_us_awb_dur_NO_3010 3022
DEF_STATIC_CONST_VAL_FLOAT(val_1700,-0.358264);
#define CTNODE_cmu_us_awb_dur_NO_3023 3025
DEF_STATIC_CONST_VAL_FLOAT(val_1701,0.208904);
#define CTNODE_cmu_us_awb_dur_NO_3026 3028
DEF_STATIC_CONST_VAL_FLOAT(val_1702,-0.003267);
#define CTNODE_cmu_us_awb_dur_NO_3025 3029
DEF_STATIC_CONST_VAL_FLOAT(val_1703,0.070041);
#define CTNODE_cmu_us_awb_dur_NO_3029 3031
DEF_STATIC_CONST_VAL_FLOAT(val_1704,-0.384890);
#define CTNODE_cmu_us_awb_dur_NO_3031 3033
DEF_STATIC_CONST_VAL_FLOAT(val_1705,0.072986);
#define CTNODE_cmu_us_awb_dur_NO_3033 3035
DEF_STATIC_CONST_VAL_FLOAT(val_1706,-0.020590);
#define CTNODE_cmu_us_awb_dur_NO_3035 3037
DEF_STATIC_CONST_VAL_FLOAT(val_1707,-0.247011);
#define CTNODE_cmu_us_awb_dur_NO_3022 3038
DEF_STATIC_CONST_VAL_FLOAT(val_1708,-0.066495);
#define CTNODE_cmu_us_awb_dur_NO_3038 3040
DEF_STATIC_CONST_VAL_FLOAT(val_1709,-0.207669);
#define CTNODE_cmu_us_awb_dur_NO_3043 3045
DEF_STATIC_CONST_VAL_FLOAT(val_1710,-0.410762);
#define CTNODE_cmu_us_awb_dur_NO_3042 3046
DEF_STATIC_CONST_VAL_FLOAT(val_1711,-0.503596);
#define CTNODE_cmu_us_awb_dur_NO_3041 3047
DEF_STATIC_CONST_VAL_FLOAT(val_1712,-0.354446);
#define CTNODE_cmu_us_awb_dur_NO_3047 3049
DEF_STATIC_CONST_VAL_FLOAT(val_1713,-0.289781);
#define CTNODE_cmu_us_awb_dur_NO_3049 3051
DEF_STATIC_CONST_VAL_FLOAT(val_1714,-0.066556);
#define CTNODE_cmu_us_awb_dur_NO_3040 3052
DEF_STATIC_CONST_VAL_FLOAT(val_1715,-0.498487);
#define CTNODE_cmu_us_awb_dur_NO_0005 3053
DEF_STATIC_CONST_VAL_STRING(val_1716,"r_146");
DEF_STATIC_CONST_VAL_FLOAT(val_1717,2.109410);
#define CTNODE_cmu_us_awb_dur_NO_3055 3057
DEF_STATIC_CONST_VAL_FLOAT(val_1718,1.473930);
#define CTNODE_cmu_us_awb_dur_NO_3058 3060
DEF_STATIC_CONST_VAL_FLOAT(val_1719,0.956401);
#define CTNODE_cmu_us_awb_dur_NO_3057 3061
DEF_STATIC_CONST_VAL_FLOAT(val_1720,-0.160523);
#define CTNODE_cmu_us_awb_dur_NO_3061 3063
DEF_STATIC_CONST_VAL_FLOAT(val_1721,0.390714);
#define CTNODE_cmu_us_awb_dur_NO_3054 3064
DEF_STATIC_CONST_VAL_FLOAT(val_1722,-0.247236);
#define CTNODE_cmu_us_awb_dur_NO_3066 3068
DEF_STATIC_CONST_VAL_FLOAT(val_1723,0.425585);
#define CTNODE_cmu_us_awb_dur_NO_3065 3069
DEF_STATIC_CONST_VAL_FLOAT(val_1724,-0.272351);
#define CTNODE_cmu_us_awb_dur_NO_3069 3071
DEF_STATIC_CONST_VAL_FLOAT(val_1725,-0.307210);
#define CTNODE_cmu_us_awb_dur_NO_3071 3073
DEF_STATIC_CONST_VAL_STRING(val_1726,"hh_83");
DEF_STATIC_CONST_VAL_FLOAT(val_1727,-0.579778);
#define CTNODE_cmu_us_awb_dur_NO_3075 3077
DEF_STATIC_CONST_VAL_FLOAT(val_1728,-0.521303);
#define CTNODE_cmu_us_awb_dur_NO_3077 3079
DEF_STATIC_CONST_VAL_FLOAT(val_1729,-0.564348);
#define CTNODE_cmu_us_awb_dur_NO_3074 3080
DEF_STATIC_CONST_VAL_FLOAT(val_1730,-0.656450);
#define CTNODE_cmu_us_awb_dur_NO_3073 3081
DEF_STATIC_CONST_VAL_FLOAT(val_1731,-0.489862);
#define CTNODE_cmu_us_awb_dur_NO_3064 3082
DEF_STATIC_CONST_VAL_FLOAT(val_1732,0.437952);
#define CTNODE_cmu_us_awb_dur_NO_3083 3085
DEF_STATIC_CONST_VAL_FLOAT(val_1733,1.416530);
#define CTNODE_cmu_us_awb_dur_NO_3082 3086
DEF_STATIC_CONST_VAL_FLOAT(val_1734,1.575660);
#define CTNODE_cmu_us_awb_dur_NO_3089 3091
DEF_STATIC_CONST_VAL_FLOAT(val_1735,0.778129);
#define CTNODE_cmu_us_awb_dur_NO_3088 3092
DEF_STATIC_CONST_VAL_FLOAT(val_1736,0.308322);
#define CTNODE_cmu_us_awb_dur_NO_3087 3093
DEF_STATIC_CONST_VAL_FLOAT(val_1737,7.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_1738,1.080960);
#define CTNODE_cmu_us_awb_dur_NO_3094 3096
DEF_STATIC_CONST_VAL_FLOAT(val_1739,0.849623);
#define CTNODE_cmu_us_awb_dur_NO_3093 3097
DEF_STATIC_CONST_VAL_FLOAT(val_1740,0.933291);
#define CTNODE_cmu_us_awb_dur_NO_3097 3099
DEF_STATIC_CONST_VAL_FLOAT(val_1741,0.770006);
#define CTNODE_cmu_us_awb_dur_NO_3099 3101
DEF_STATIC_CONST_VAL_STRING(val_1742,"sh");
DEF_STATIC_CONST_VAL_FLOAT(val_1743,0.541283);
#define CTNODE_cmu_us_awb_dur_NO_3101 3103
DEF_STATIC_CONST_VAL_FLOAT(val_1744,0.483966);
#define CTNODE_cmu_us_awb_dur_NO_3103 3105
DEF_STATIC_CONST_VAL_FLOAT(val_1745,-0.644019);
#define CTNODE_cmu_us_awb_dur_NO_3106 3108
DEF_STATIC_CONST_VAL_FLOAT(val_1746,-0.749004);
#define CTNODE_cmu_us_awb_dur_NO_3108 3110
DEF_STATIC_CONST_VAL_FLOAT(val_1747,-0.619460);
#define CTNODE_cmu_us_awb_dur_NO_3111 3113
DEF_STATIC_CONST_VAL_FLOAT(val_1748,-0.320733);
#define CTNODE_cmu_us_awb_dur_NO_3113 3115
DEF_STATIC_CONST_VAL_FLOAT(val_1749,-0.462126);
#define CTNODE_cmu_us_awb_dur_NO_3110 3116
DEF_STATIC_CONST_VAL_FLOAT(val_1750,0.732835);
#define CTNODE_cmu_us_awb_dur_NO_3121 3123
DEF_STATIC_CONST_VAL_FLOAT(val_1751,0.029213);
#define CTNODE_cmu_us_awb_dur_NO_3120 3124
DEF_STATIC_CONST_VAL_FLOAT(val_1752,-0.208956);
#define CTNODE_cmu_us_awb_dur_NO_3126 3128
DEF_STATIC_CONST_VAL_FLOAT(val_1753,-0.106821);
#define CTNODE_cmu_us_awb_dur_NO_3128 3130
DEF_STATIC_CONST_VAL_FLOAT(val_1754,0.333001);
#define CTNODE_cmu_us_awb_dur_NO_3125 3131
DEF_STATIC_CONST_VAL_FLOAT(val_1755,-0.328596);
#define CTNODE_cmu_us_awb_dur_NO_3124 3132
DEF_STATIC_CONST_VAL_FLOAT(val_1756,0.358640);
#define CTNODE_cmu_us_awb_dur_NO_3119 3133
DEF_STATIC_CONST_VAL_FLOAT(val_1757,-0.559118);
#define CTNODE_cmu_us_awb_dur_NO_3134 3136
DEF_STATIC_CONST_VAL_FLOAT(val_1758,-0.136655);
#define CTNODE_cmu_us_awb_dur_NO_3133 3137
DEF_STATIC_CONST_VAL_FLOAT(val_1759,-0.277598);
#define CTNODE_cmu_us_awb_dur_NO_3138 3140
DEF_STATIC_CONST_VAL_FLOAT(val_1760,0.050212);
#define CTNODE_cmu_us_awb_dur_NO_3137 3141
DEF_STATIC_CONST_VAL_FLOAT(val_1761,0.255178);
#define CTNODE_cmu_us_awb_dur_NO_3118 3142
DEF_STATIC_CONST_VAL_FLOAT(val_1762,-0.408477);
#define CTNODE_cmu_us_awb_dur_NO_3143 3145
DEF_STATIC_CONST_VAL_FLOAT(val_1763,-0.620387);
#define CTNODE_cmu_us_awb_dur_NO_3142 3146
DEF_STATIC_CONST_VAL_FLOAT(val_1764,-0.015187);
#define CTNODE_cmu_us_awb_dur_NO_3147 3149
DEF_STATIC_CONST_VAL_FLOAT(val_1765,-0.418767);
#define CTNODE_cmu_us_awb_dur_NO_3146 3150
DEF_STATIC_CONST_VAL_FLOAT(val_1766,0.300633);
#define CTNODE_cmu_us_awb_dur_NO_3117 3151
DEF_STATIC_CONST_VAL_FLOAT(val_1767,1.166490);
#define CTNODE_cmu_us_awb_dur_NO_3151 3153
DEF_STATIC_CONST_VAL_FLOAT(val_1768,0.069015);
#define CTNODE_cmu_us_awb_dur_NO_3116 3154
DEF_STATIC_CONST_VAL_FLOAT(val_1769,-0.695906);
#define CTNODE_cmu_us_awb_dur_NO_3155 3157
DEF_STATIC_CONST_VAL_FLOAT(val_1770,-0.301439);
#define CTNODE_cmu_us_awb_dur_NO_3154 3158
DEF_STATIC_CONST_VAL_FLOAT(val_1771,-0.244431);
#define CTNODE_cmu_us_awb_dur_NO_3160 3162
DEF_STATIC_CONST_VAL_FLOAT(val_1772,0.033553);
#define CTNODE_cmu_us_awb_dur_NO_3163 3165
DEF_STATIC_CONST_VAL_FLOAT(val_1773,-0.102528);
#define CTNODE_cmu_us_awb_dur_NO_3162 3166
DEF_STATIC_CONST_VAL_FLOAT(val_1774,0.190618);
#define CTNODE_cmu_us_awb_dur_NO_3166 3168
DEF_STATIC_CONST_VAL_FLOAT(val_1775,0.578771);
#define CTNODE_cmu_us_awb_dur_NO_3159 3169
DEF_STATIC_CONST_VAL_FLOAT(val_1776,-0.497666);
#define CTNODE_cmu_us_awb_dur_NO_3169 3171
DEF_STATIC_CONST_VAL_FLOAT(val_1777,-0.025697);
#define CTNODE_cmu_us_awb_dur_NO_3171 3173
DEF_STATIC_CONST_VAL_FLOAT(val_1778,-0.256470);
#define CTNODE_cmu_us_awb_dur_NO_3158 3174
DEF_STATIC_CONST_VAL_FLOAT(val_1779,-0.608589);
#define CTNODE_cmu_us_awb_dur_NO_3176 3178
DEF_STATIC_CONST_VAL_FLOAT(val_1780,-0.448224);
#define CTNODE_cmu_us_awb_dur_NO_3178 3180
DEF_STATIC_CONST_VAL_FLOAT(val_1781,-0.299550);
#define CTNODE_cmu_us_awb_dur_NO_3175 3181
DEF_STATIC_CONST_VAL_FLOAT(val_1782,0.027505);
#define CTNODE_cmu_us_awb_dur_NO_3182 3184
DEF_STATIC_CONST_VAL_FLOAT(val_1783,-0.154625);
#define CTNODE_cmu_us_awb_dur_NO_3181 3185
DEF_STATIC_CONST_VAL_FLOAT(val_1784,-0.450614);
#define CTNODE_cmu_us_awb_dur_NO_3185 3187
DEF_STATIC_CONST_VAL_FLOAT(val_1785,-0.427491);
#define CTNODE_cmu_us_awb_dur_NO_3188 3190
DEF_STATIC_CONST_VAL_FLOAT(val_1786,-0.226993);
#define CTNODE_cmu_us_awb_dur_NO_3187 3191
DEF_STATIC_CONST_VAL_FLOAT(val_1787,-0.074205);
#define CTNODE_cmu_us_awb_dur_NO_3174 3192
DEF_STATIC_CONST_VAL_FLOAT(val_1788,0.293770);
#define CTNODE_cmu_us_awb_dur_NO_3193 3195
DEF_STATIC_CONST_VAL_FLOAT(val_1789,-0.454943);
#define CTNODE_cmu_us_awb_dur_NO_3195 3197
DEF_STATIC_CONST_VAL_FLOAT(val_1790,0.265801);
#define CTNODE_cmu_us_awb_dur_NO_3197 3199
DEF_STATIC_CONST_VAL_FLOAT(val_1791,-0.469346);
#define CTNODE_cmu_us_awb_dur_NO_3201 3203
DEF_STATIC_CONST_VAL_FLOAT(val_1792,-0.092464);
#define CTNODE_cmu_us_awb_dur_NO_3203 3205
DEF_STATIC_CONST_VAL_FLOAT(val_1793,-0.439102);
#define CTNODE_cmu_us_awb_dur_NO_3205 3207
DEF_STATIC_CONST_VAL_FLOAT(val_1794,-0.226167);
#define CTNODE_cmu_us_awb_dur_NO_3200 3208
DEF_STATIC_CONST_VAL_FLOAT(val_1795,0.145050);
#define CTNODE_cmu_us_awb_dur_NO_3199 3209
DEF_STATIC_CONST_VAL_FLOAT(val_1796,0.294759);
#define CTNODE_cmu_us_awb_dur_NO_3209 3211
DEF_STATIC_CONST_VAL_FLOAT(val_1797,-0.075111);
#define CTNODE_cmu_us_awb_dur_NO_3192 3212
DEF_STATIC_CONST_VAL_FLOAT(val_1798,-0.474366);
#define CTNODE_cmu_us_awb_dur_NO_3105 3213
DEF_STATIC_CONST_VAL_STRING(val_1799,"ay_31");
DEF_STATIC_CONST_VAL_FLOAT(val_1800,-0.077650);
#define CTNODE_cmu_us_awb_dur_NO_3214 3216
DEF_STATIC_CONST_VAL_FLOAT(val_1801,-0.578256);
#define CTNODE_cmu_us_awb_dur_NO_3213 3217
DEF_STATIC_CONST_VAL_FLOAT(val_1802,0.678566);
#define CTNODE_cmu_us_awb_dur_NO_3218 3220
DEF_STATIC_CONST_VAL_FLOAT(val_1803,0.103693);
#define CTNODE_cmu_us_awb_dur_NO_3220 3222
DEF_STATIC_CONST_VAL_FLOAT(val_1804,0.464975);
#define CTNODE_cmu_us_awb_dur_NO_3217 3223
DEF_STATIC_CONST_VAL_FLOAT(val_1805,-0.229255);
#define CTNODE_cmu_us_awb_dur_NO_3223 3225
DEF_STATIC_CONST_VAL_FLOAT(val_1806,0.222087);
#define CTNODE_cmu_us_awb_dur_NO_3225 3227
DEF_STATIC_CONST_VAL_FLOAT(val_1807,0.027752);
#define CTNODE_cmu_us_awb_dur_NO_3086 3228
DEF_STATIC_CONST_VAL_FLOAT(val_1808,-0.811455);
#define CTNODE_cmu_us_awb_dur_NO_3229 3231
DEF_STATIC_CONST_VAL_FLOAT(val_1809,-0.606047);
#define CTNODE_cmu_us_awb_dur_NO_3233 3235
DEF_STATIC_CONST_VAL_FLOAT(val_1810,-0.381219);
#define CTNODE_cmu_us_awb_dur_NO_3232 3236
DEF_STATIC_CONST_VAL_FLOAT(val_1811,-0.344194);
#define CTNODE_cmu_us_awb_dur_NO_3236 3238
DEF_STATIC_CONST_VAL_FLOAT(val_1812,0.313545);
#define CTNODE_cmu_us_awb_dur_NO_3231 3239
DEF_STATIC_CONST_VAL_FLOAT(val_1813,0.248507);
#define CTNODE_cmu_us_awb_dur_NO_3228 3240
DEF_STATIC_CONST_VAL_FLOAT(val_1814,0.850870);
#define CTNODE_cmu_us_awb_dur_NO_3241 3243
DEF_STATIC_CONST_VAL_STRING(val_1815,"g");
DEF_STATIC_CONST_VAL_FLOAT(val_1816,0.717460);
#define CTNODE_cmu_us_awb_dur_NO_3245 3247
DEF_STATIC_CONST_VAL_FLOAT(val_1817,0.377191);
#define CTNODE_cmu_us_awb_dur_NO_3244 3248
DEF_STATIC_CONST_VAL_FLOAT(val_1818,-0.243420);
#define CTNODE_cmu_us_awb_dur_NO_3248 3250
DEF_STATIC_CONST_VAL_FLOAT(val_1819,-0.016481);
#define CTNODE_cmu_us_awb_dur_NO_3252 3254
DEF_STATIC_CONST_VAL_FLOAT(val_1820,5.600000);
DEF_STATIC_CONST_VAL_FLOAT(val_1821,0.534009);
#define CTNODE_cmu_us_awb_dur_NO_3257 3259
DEF_STATIC_CONST_VAL_FLOAT(val_1822,0.267269);
#define CTNODE_cmu_us_awb_dur_NO_3256 3260
DEF_STATIC_CONST_VAL_FLOAT(val_1823,0.156126);
#define CTNODE_cmu_us_awb_dur_NO_3255 3261
DEF_STATIC_CONST_VAL_FLOAT(val_1824,0.751599);
#define CTNODE_cmu_us_awb_dur_NO_3254 3262
DEF_STATIC_CONST_VAL_FLOAT(val_1825,0.103598);
#define CTNODE_cmu_us_awb_dur_NO_3251 3263
DEF_STATIC_CONST_VAL_FLOAT(val_1826,-0.220513);
#define CTNODE_cmu_us_awb_dur_NO_3250 3264
DEF_STATIC_CONST_VAL_FLOAT(val_1827,0.055082);
#define CTNODE_cmu_us_awb_dur_NO_3266 3268
DEF_STATIC_CONST_VAL_FLOAT(val_1828,0.409965);
#define CTNODE_cmu_us_awb_dur_NO_3265 3269
DEF_STATIC_CONST_VAL_FLOAT(val_1829,-0.288431);
#define CTNODE_cmu_us_awb_dur_NO_3269 3271
DEF_STATIC_CONST_VAL_FLOAT(val_1830,0.294563);
#define CTNODE_cmu_us_awb_dur_NO_3272 3274
DEF_STATIC_CONST_VAL_FLOAT(val_1831,0.091633);
#define CTNODE_cmu_us_awb_dur_NO_3271 3275
DEF_STATIC_CONST_VAL_FLOAT(val_1832,-0.267032);
#define CTNODE_cmu_us_awb_dur_NO_3264 3276
DEF_STATIC_CONST_VAL_FLOAT(val_1833,-0.330951);
#define CTNODE_cmu_us_awb_dur_NO_3276 3278
DEF_STATIC_CONST_VAL_FLOAT(val_1834,-0.118755);
#define CTNODE_cmu_us_awb_dur_NO_3243 3279
DEF_STATIC_CONST_VAL_FLOAT(val_1835,-0.425310);
#define CTNODE_cmu_us_awb_dur_NO_3279 3281
DEF_STATIC_CONST_VAL_FLOAT(val_1836,-0.263658);
#define CTNODE_cmu_us_awb_dur_NO_3284 3286
DEF_STATIC_CONST_VAL_FLOAT(val_1837,-0.210072);
#define CTNODE_cmu_us_awb_dur_NO_3283 3287
DEF_STATIC_CONST_VAL_FLOAT(val_1838,-0.077865);
#define CTNODE_cmu_us_awb_dur_NO_3282 3288
DEF_STATIC_CONST_VAL_FLOAT(val_1839,-0.429194);
#define CTNODE_cmu_us_awb_dur_NO_3288 3290
DEF_STATIC_CONST_VAL_FLOAT(val_1840,-0.257458);
#define CTNODE_cmu_us_awb_dur_NO_3281 3291
DEF_STATIC_CONST_VAL_FLOAT(val_1841,-0.483980);
#define CTNODE_cmu_us_awb_dur_NO_3291 3293
DEF_STATIC_CONST_VAL_FLOAT(val_1842,-0.368969);
#define CTNODE_cmu_us_awb_dur_NO_3294 3296
DEF_STATIC_CONST_VAL_FLOAT(val_1843,-0.239539);
#define CTNODE_cmu_us_awb_dur_NO_3293 3297
DEF_STATIC_CONST_VAL_FLOAT(val_1844,-0.473695);
#define CTNODE_cmu_us_awb_dur_NO_3298 3300
DEF_STATIC_CONST_VAL_FLOAT(val_1845,0.053202);
#define CTNODE_cmu_us_awb_dur_NO_3297 3301
DEF_STATIC_CONST_VAL_FLOAT(val_1846,-0.127534);
#define CTNODE_cmu_us_awb_dur_NO_3303 3305
DEF_STATIC_CONST_VAL_FLOAT(val_1847,-0.238453);
#define CTNODE_cmu_us_awb_dur_NO_3308 3310
DEF_STATIC_CONST_VAL_FLOAT(val_1848,0.016176);
#define CTNODE_cmu_us_awb_dur_NO_3310 3312
DEF_STATIC_CONST_VAL_FLOAT(val_1849,-0.149237);
#define CTNODE_cmu_us_awb_dur_NO_3307 3313
DEF_STATIC_CONST_VAL_FLOAT(val_1850,0.206908);
#define CTNODE_cmu_us_awb_dur_NO_3306 3314
DEF_STATIC_CONST_VAL_FLOAT(val_1851,0.166749);
#define CTNODE_cmu_us_awb_dur_NO_3305 3315
DEF_STATIC_CONST_VAL_FLOAT(val_1852,0.360478);
#define CTNODE_cmu_us_awb_dur_NO_3302 3316
DEF_STATIC_CONST_VAL_FLOAT(val_1853,-0.226876);
#define CTNODE_cmu_us_awb_dur_NO_3301 3317
DEF_STATIC_CONST_VAL_FLOAT(val_1854,0.435479);
#define CTNODE_cmu_us_awb_dur_NO_3240 3318
DEF_STATIC_CONST_VAL_FLOAT(val_1855,-0.467766);
#define CTNODE_cmu_us_awb_dur_NO_3322 3324
DEF_STATIC_CONST_VAL_FLOAT(val_1856,-0.248097);
#define CTNODE_cmu_us_awb_dur_NO_3321 3325
DEF_STATIC_CONST_VAL_FLOAT(val_1857,0.261355);
#define CTNODE_cmu_us_awb_dur_NO_3325 3327
DEF_STATIC_CONST_VAL_FLOAT(val_1858,-0.138192);
#define CTNODE_cmu_us_awb_dur_NO_3320 3328
DEF_STATIC_CONST_VAL_FLOAT(val_1859,-0.355268);
#define CTNODE_cmu_us_awb_dur_NO_3328 3330
DEF_STATIC_CONST_VAL_FLOAT(val_1860,-0.658467);
#define CTNODE_cmu_us_awb_dur_NO_3319 3331
DEF_STATIC_CONST_VAL_STRING(val_1861,"m_111");
DEF_STATIC_CONST_VAL_FLOAT(val_1862,-0.456363);
#define CTNODE_cmu_us_awb_dur_NO_3331 3333
DEF_STATIC_CONST_VAL_FLOAT(val_1863,0.727976);
#define CTNODE_cmu_us_awb_dur_NO_3333 3335
DEF_STATIC_CONST_VAL_FLOAT(val_1864,0.464526);
#define CTNODE_cmu_us_awb_dur_NO_3335 3337
DEF_STATIC_CONST_VAL_FLOAT(val_1865,0.470983);
#define CTNODE_cmu_us_awb_dur_NO_3338 3340
DEF_STATIC_CONST_VAL_FLOAT(val_1866,0.048211);
#define CTNODE_cmu_us_awb_dur_NO_3337 3341
DEF_STATIC_CONST_VAL_FLOAT(val_1867,-0.293849);
#define CTNODE_cmu_us_awb_dur_NO_3341 3343
DEF_STATIC_CONST_VAL_FLOAT(val_1868,0.035595);
#define CTNODE_cmu_us_awb_dur_NO_3318 3344
DEF_STATIC_CONST_VAL_FLOAT(val_1869,1.283350);
#define CTNODE_cmu_us_awb_dur_NO_3345 3347
DEF_STATIC_CONST_VAL_FLOAT(val_1870,-0.232400);
#define CTNODE_cmu_us_awb_dur_NO_3347 3349
DEF_STATIC_CONST_VAL_FLOAT(val_1871,0.531879);
#define CTNODE_cmu_us_awb_dur_NO_3350 3352
DEF_STATIC_CONST_VAL_FLOAT(val_1872,-0.442824);
#define CTNODE_cmu_us_awb_dur_NO_3349 3353
DEF_STATIC_CONST_VAL_FLOAT(val_1873,0.390961);
#define CTNODE_cmu_us_awb_dur_NO_3354 3356
DEF_STATIC_CONST_VAL_FLOAT(val_1874,1.235810);
#define CTNODE_cmu_us_awb_dur_NO_3356 3358
DEF_STATIC_CONST_VAL_FLOAT(val_1875,0.741710);
#define CTNODE_cmu_us_awb_dur_NO_3353 3359
DEF_STATIC_CONST_VAL_FLOAT(val_1876,0.921233);
#define CTNODE_cmu_us_awb_dur_NO_3360 3362
DEF_STATIC_CONST_VAL_FLOAT(val_1877,0.927921);
#define CTNODE_cmu_us_awb_dur_NO_3363 3365
DEF_STATIC_CONST_VAL_FLOAT(val_1878,0.422220);
#define CTNODE_cmu_us_awb_dur_NO_3362 3366
DEF_STATIC_CONST_VAL_FLOAT(val_1879,-0.101473);
#define CTNODE_cmu_us_awb_dur_NO_3367 3369
DEF_STATIC_CONST_VAL_FLOAT(val_1880,-0.186232);
#define CTNODE_cmu_us_awb_dur_NO_3370 3372
DEF_STATIC_CONST_VAL_FLOAT(val_1881,0.072730);
#define CTNODE_cmu_us_awb_dur_NO_3372 3374
DEF_STATIC_CONST_VAL_FLOAT(val_1882,0.656380);
#define CTNODE_cmu_us_awb_dur_NO_3369 3375
DEF_STATIC_CONST_VAL_FLOAT(val_1883,0.256115);
#define CTNODE_cmu_us_awb_dur_NO_3378 3380
DEF_STATIC_CONST_VAL_FLOAT(val_1884,0.014231);
#define CTNODE_cmu_us_awb_dur_NO_3377 3381
DEF_STATIC_CONST_VAL_FLOAT(val_1885,0.476704);
#define CTNODE_cmu_us_awb_dur_NO_3376 3382
DEF_STATIC_CONST_VAL_FLOAT(val_1886,0.834410);
#define CTNODE_cmu_us_awb_dur_NO_3383 3385
DEF_STATIC_CONST_VAL_FLOAT(val_1887,0.083188);
#define CTNODE_cmu_us_awb_dur_NO_3385 3387
DEF_STATIC_CONST_VAL_FLOAT(val_1888,0.296310);
#define CTNODE_cmu_us_awb_dur_NO_3387 3389
DEF_STATIC_CONST_VAL_FLOAT(val_1889,0.755333);
#define CTNODE_cmu_us_awb_dur_NO_3389 3391
DEF_STATIC_CONST_VAL_FLOAT(val_1890,0.350419);
#define CTNODE_cmu_us_awb_dur_NO_3382 3392
DEF_STATIC_CONST_VAL_FLOAT(val_1891,1.189490);
#define CTNODE_cmu_us_awb_dur_NO_3375 3393
DEF_STATIC_CONST_VAL_FLOAT(val_1892,0.439258);
#define CTNODE_cmu_us_awb_dur_NO_3393 3395
DEF_STATIC_CONST_VAL_FLOAT(val_1893,0.267022);
#define CTNODE_cmu_us_awb_dur_NO_3395 3397
DEF_STATIC_CONST_VAL_FLOAT(val_1894,-0.053303);
#define CTNODE_cmu_us_awb_dur_NO_3366 3398
DEF_STATIC_CONST_VAL_FLOAT(val_1895,1.109910);
#define CTNODE_cmu_us_awb_dur_NO_3399 3401
DEF_STATIC_CONST_VAL_FLOAT(val_1896,0.731386);
#define CTNODE_cmu_us_awb_dur_NO_3401 3403
DEF_STATIC_CONST_VAL_FLOAT(val_1897,0.158275);
#define CTNODE_cmu_us_awb_dur_NO_3403 3405
DEF_STATIC_CONST_VAL_FLOAT(val_1898,0.558094);
#define CTNODE_cmu_us_awb_dur_NO_3398 3406
DEF_STATIC_CONST_VAL_FLOAT(val_1899,0.330042);
#define CTNODE_cmu_us_awb_dur_NO_3359 3407
DEF_STATIC_CONST_VAL_FLOAT(val_1900,0.340782);
#define CTNODE_cmu_us_awb_dur_NO_3408 3410
DEF_STATIC_CONST_VAL_FLOAT(val_1901,0.055150);
#define CTNODE_cmu_us_awb_dur_NO_3407 3411
DEF_STATIC_CONST_VAL_FLOAT(val_1902,-0.076854);
#define CTNODE_cmu_us_awb_dur_NO_3344 3412
DEF_STATIC_CONST_VAL_FLOAT(val_1903,1.244790);
#define CTNODE_cmu_us_awb_dur_NO_3413 3415
DEF_STATIC_CONST_VAL_FLOAT(val_1904,0.609439);
#define CTNODE_cmu_us_awb_dur_NO_3412 3416
DEF_STATIC_CONST_VAL_FLOAT(val_1905,-0.026974);
#define CTNODE_cmu_us_awb_dur_NO_3417 3419
DEF_STATIC_CONST_VAL_FLOAT(val_1906,-0.783229);
#define CTNODE_cmu_us_awb_dur_NO_3416 3420
DEF_STATIC_CONST_VAL_FLOAT(val_1907,-0.093872);
#define CTNODE_cmu_us_awb_dur_NO_3422 3424
DEF_STATIC_CONST_VAL_FLOAT(val_1908,0.264741);
#define CTNODE_cmu_us_awb_dur_NO_3421 3425
DEF_STATIC_CONST_VAL_FLOAT(val_1909,-0.040765);
#define CTNODE_cmu_us_awb_dur_NO_3425 3427
DEF_STATIC_CONST_VAL_FLOAT(val_1910,-0.337665);
#define CTNODE_cmu_us_awb_dur_NO_3427 3429
DEF_STATIC_CONST_VAL_FLOAT(val_1911,-0.543493);
#define CTNODE_cmu_us_awb_dur_NO_3420 3430
DEF_STATIC_CONST_VAL_FLOAT(val_1912,0.720893);
#define CTNODE_cmu_us_awb_dur_NO_3431 3433
DEF_STATIC_CONST_VAL_FLOAT(val_1913,1.804960);
#define CTNODE_cmu_us_awb_dur_NO_3430 3434
DEF_STATIC_CONST_VAL_FLOAT(val_1914,-0.552652);
#define CTNODE_cmu_us_awb_dur_NO_3435 3437
DEF_STATIC_CONST_VAL_FLOAT(val_1915,-0.187221);
#define CTNODE_cmu_us_awb_dur_NO_3434 3438
DEF_STATIC_CONST_VAL_FLOAT(val_1916,-0.285012);
#define CTNODE_cmu_us_awb_dur_NO_3439 3441
#define CTNODE_cmu_us_awb_dur_NO_3438 3442
DEF_STATIC_CONST_VAL_FLOAT(val_1917,-0.501992);
#define CTNODE_cmu_us_awb_dur_NO_3444 3446
DEF_STATIC_CONST_VAL_FLOAT(val_1918,-0.383500);
#define CTNODE_cmu_us_awb_dur_NO_3446 3448
DEF_STATIC_CONST_VAL_FLOAT(val_1919,-0.061439);
#define CTNODE_cmu_us_awb_dur_NO_3443 3449
DEF_STATIC_CONST_VAL_FLOAT(val_1920,0.163898);
#define CTNODE_cmu_us_awb_dur_NO_3442 3450
DEF_STATIC_CONST_VAL_FLOAT(val_1921,-0.658167);
#define CTNODE_cmu_us_awb_dur_NO_3451 3453
DEF_STATIC_CONST_VAL_FLOAT(val_1922,-0.025236);
#define CTNODE_cmu_us_awb_dur_NO_3450 3454
DEF_STATIC_CONST_VAL_FLOAT(val_1923,0.169523);
#define CTNODE_cmu_us_awb_dur_NO_3455 3457
DEF_STATIC_CONST_VAL_STRING(val_1924,"k_102");
DEF_STATIC_CONST_VAL_FLOAT(val_1925,0.252135);
#define CTNODE_cmu_us_awb_dur_NO_3458 3460
DEF_STATIC_CONST_VAL_FLOAT(val_1926,0.733537);
#define CTNODE_cmu_us_awb_dur_NO_3457 3461
DEF_STATIC_CONST_VAL_FLOAT(val_1927,0.975687);
#define CTNODE_cmu_us_awb_dur_NO_3454 3462
DEF_STATIC_CONST_VAL_FLOAT(val_1928,-0.567389);
#define CTNODE_cmu_us_awb_dur_NO_3463 3465
DEF_STATIC_CONST_VAL_FLOAT(val_1929,0.180566);
#define CTNODE_cmu_us_awb_dur_NO_3462 3466
DEF_STATIC_CONST_VAL_FLOAT(val_1930,-0.445504);
#define CTNODE_cmu_us_awb_dur_NO_3469 3471
DEF_STATIC_CONST_VAL_FLOAT(val_1931,-0.323706);
#define CTNODE_cmu_us_awb_dur_NO_3468 3472
DEF_STATIC_CONST_VAL_FLOAT(val_1932,-0.192478);
#define CTNODE_cmu_us_awb_dur_NO_3472 3474
DEF_STATIC_CONST_VAL_FLOAT(val_1933,-0.009507);
#define CTNODE_cmu_us_awb_dur_NO_3467 3475
DEF_STATIC_CONST_VAL_FLOAT(val_1934,-0.263604);
#define CTNODE_cmu_us_awb_dur_NO_3476 3478
DEF_STATIC_CONST_VAL_FLOAT(val_1935,0.282635);
#define CTNODE_cmu_us_awb_dur_NO_3478 3480
DEF_STATIC_CONST_VAL_FLOAT(val_1936,0.126616);
#define CTNODE_cmu_us_awb_dur_NO_3480 3482
DEF_STATIC_CONST_VAL_FLOAT(val_1937,-0.296150);
#define CTNODE_cmu_us_awb_dur_NO_3475 3483
DEF_STATIC_CONST_VAL_FLOAT(val_1938,-0.014858);
#define CTNODE_cmu_us_awb_dur_NO_3483 3485
DEF_STATIC_CONST_VAL_FLOAT(val_1939,0.365008);
#define CTNODE_cmu_us_awb_dur_NO_3486 3488
DEF_STATIC_CONST_VAL_FLOAT(val_1940,1.134940);
#define CTNODE_cmu_us_awb_dur_NO_3485 3489
DEF_STATIC_CONST_VAL_FLOAT(val_1941,-0.020889);
#define CTNODE_cmu_us_awb_dur_NO_3489 3491
DEF_STATIC_CONST_VAL_FLOAT(val_1942,0.151098);
#define CTNODE_cmu_us_awb_dur_NO_3491 3493
DEF_STATIC_CONST_VAL_FLOAT(val_1943,0.428984);
#define CTNODE_cmu_us_awb_dur_NO_3466 3494
DEF_STATIC_CONST_VAL_FLOAT(val_1944,3.300000);
DEF_STATIC_CONST_VAL_FLOAT(val_1945,1.131980);
#define CTNODE_cmu_us_awb_dur_NO_3495 3497
DEF_STATIC_CONST_VAL_FLOAT(val_1946,0.658991);
#define CTNODE_cmu_us_awb_dur_NO_3494 3498
DEF_STATIC_CONST_VAL_FLOAT(val_1947,0.998788);
#define CTNODE_cmu_us_awb_dur_NO_3498 3500
DEF_STATIC_CONST_VAL_FLOAT(val_1948,0.982361);
#define CTNODE_cmu_us_awb_dur_NO_3501 3503
DEF_STATIC_CONST_VAL_FLOAT(val_1949,0.565990);
#define CTNODE_cmu_us_awb_dur_NO_3505 3507
DEF_STATIC_CONST_VAL_FLOAT(val_1950,0.194288);
#define CTNODE_cmu_us_awb_dur_NO_3504 3508
DEF_STATIC_CONST_VAL_FLOAT(val_1951,0.013687);
#define CTNODE_cmu_us_awb_dur_NO_3503 3509
DEF_STATIC_CONST_VAL_FLOAT(val_1952,0.811295);
#define CTNODE_cmu_us_awb_dur_NO_3509 3511
DEF_STATIC_CONST_VAL_FLOAT(val_1953,0.263473);
#define CTNODE_cmu_us_awb_dur_NO_3500 3512
DEF_STATIC_CONST_VAL_FLOAT(val_1954,1.395140);
#define CTNODE_cmu_us_awb_dur_NO_3513 3515
DEF_STATIC_CONST_VAL_FLOAT(val_1955,0.310328);
#define CTNODE_cmu_us_awb_dur_NO_3512 3516
DEF_STATIC_CONST_VAL_STRING(val_1956,"sh_157");
DEF_STATIC_CONST_VAL_FLOAT(val_1957,0.752388);
#define CTNODE_cmu_us_awb_dur_NO_3516 3518
DEF_STATIC_CONST_VAL_FLOAT(val_1958,-0.392540);
#define CTNODE_cmu_us_awb_dur_NO_3519 3521
DEF_STATIC_CONST_VAL_FLOAT(val_1959,-0.228439);
#define CTNODE_cmu_us_awb_dur_NO_3522 3524
DEF_STATIC_CONST_VAL_FLOAT(val_1960,0.372047);
#define CTNODE_cmu_us_awb_dur_NO_3525 3527
DEF_STATIC_CONST_VAL_FLOAT(val_1961,-0.147953);
#define CTNODE_cmu_us_awb_dur_NO_3524 3528
DEF_STATIC_CONST_VAL_FLOAT(val_1962,0.214847);
#define CTNODE_cmu_us_awb_dur_NO_3529 3531
DEF_STATIC_CONST_VAL_FLOAT(val_1963,0.104608);
#define CTNODE_cmu_us_awb_dur_NO_3528 3532
DEF_STATIC_CONST_VAL_FLOAT(val_1964,0.265861);
#define CTNODE_cmu_us_awb_dur_NO_3532 3534
DEF_STATIC_CONST_VAL_FLOAT(val_1965,0.322261);
#define CTNODE_cmu_us_awb_dur_NO_3535 3537
DEF_STATIC_CONST_VAL_FLOAT(val_1966,1.152850);
#define CTNODE_cmu_us_awb_dur_NO_3537 3539
DEF_STATIC_CONST_VAL_FLOAT(val_1967,0.459796);
#define CTNODE_cmu_us_awb_dur_NO_3534 3540
DEF_STATIC_CONST_VAL_FLOAT(val_1968,0.344644);
#define CTNODE_cmu_us_awb_dur_NO_3521 3541
DEF_STATIC_CONST_VAL_FLOAT(val_1969,-0.110992);
#define CTNODE_cmu_us_awb_dur_NO_3542 3544
DEF_STATIC_CONST_VAL_FLOAT(val_1970,-0.396075);
#define CTNODE_cmu_us_awb_dur_NO_3544 3546
DEF_STATIC_CONST_VAL_FLOAT(val_1971,-0.574171);
#define CTNODE_cmu_us_awb_dur_NO_3541 3547
DEF_STATIC_CONST_VAL_FLOAT(val_1972,0.618054);
#define CTNODE_cmu_us_awb_dur_NO_3547 3549
DEF_STATIC_CONST_VAL_FLOAT(val_1973,0.730960);
#define CTNODE_cmu_us_awb_dur_NO_3550 3552
DEF_STATIC_CONST_VAL_FLOAT(val_1974,0.530013);
#define CTNODE_cmu_us_awb_dur_NO_3552 3554
DEF_STATIC_CONST_VAL_FLOAT(val_1975,0.274790);
#define CTNODE_cmu_us_awb_dur_NO_3554 3556
DEF_STATIC_CONST_VAL_FLOAT(val_1976,0.078618);
#define CTNODE_cmu_us_awb_dur_NO_3549 3557
DEF_STATIC_CONST_VAL_FLOAT(val_1977,-0.240314);
#define CTNODE_cmu_us_awb_dur_NO_3557 3559
DEF_STATIC_CONST_VAL_FLOAT(val_1978,-0.285054);
#define CTNODE_cmu_us_awb_dur_NO_3559 3561
DEF_STATIC_CONST_VAL_FLOAT(val_1979,-0.232541);
#define CTNODE_cmu_us_awb_dur_NO_3562 3564
DEF_STATIC_CONST_VAL_FLOAT(val_1980,0.221469);
#define CTNODE_cmu_us_awb_dur_NO_3561 3565
DEF_STATIC_CONST_VAL_STRING(val_1981,"uw");
DEF_STATIC_CONST_VAL_FLOAT(val_1982,0.633224);
#define CTNODE_cmu_us_awb_dur_NO_3566 3568
DEF_STATIC_CONST_VAL_FLOAT(val_1983,0.148835);
#define CTNODE_cmu_us_awb_dur_NO_3565 3569
DEF_STATIC_CONST_VAL_FLOAT(val_1984,-0.080991);
#define CTNODE_cmu_us_awb_dur_NO_3571 3573
DEF_STATIC_CONST_VAL_FLOAT(val_1985,0.070869);
#define CTNODE_cmu_us_awb_dur_NO_3574 3576
DEF_STATIC_CONST_VAL_FLOAT(val_1986,0.338904);
#define CTNODE_cmu_us_awb_dur_NO_3573 3577
DEF_STATIC_CONST_VAL_FLOAT(val_1987,0.563508);
#define CTNODE_cmu_us_awb_dur_NO_3570 3578
DEF_STATIC_CONST_VAL_FLOAT(val_1988,0.440611);
#define CTNODE_cmu_us_awb_dur_NO_3578 3580
DEF_STATIC_CONST_VAL_FLOAT(val_1989,0.221295);
#define CTNODE_cmu_us_awb_dur_NO_3582 3584
DEF_STATIC_CONST_VAL_FLOAT(val_1990,-0.253453);
#define CTNODE_cmu_us_awb_dur_NO_3581 3585
DEF_STATIC_CONST_VAL_FLOAT(val_1991,-0.470594);
#define CTNODE_cmu_us_awb_dur_NO_3585 3587
DEF_STATIC_CONST_VAL_FLOAT(val_1992,-0.171774);
#define CTNODE_cmu_us_awb_dur_NO_3580 3588
DEF_STATIC_CONST_VAL_FLOAT(val_1993,14.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_1994,0.067211);
#define CTNODE_cmu_us_awb_dur_NO_3589 3591
DEF_STATIC_CONST_VAL_FLOAT(val_1995,0.399086);
#define CTNODE_cmu_us_awb_dur_NO_3588 3592
DEF_STATIC_CONST_VAL_FLOAT(val_1996,-0.395801);
#define CTNODE_cmu_us_awb_dur_NO_3593 3595
DEF_STATIC_CONST_VAL_FLOAT(val_1997,0.101113);
#define CTNODE_cmu_us_awb_dur_NO_3592 3596
DEF_STATIC_CONST_VAL_FLOAT(val_1998,0.302019);
#define CTNODE_cmu_us_awb_dur_NO_3596 3598
DEF_STATIC_CONST_VAL_FLOAT(val_1999,-0.191833);
#define CTNODE_cmu_us_awb_dur_NO_3598 3600
DEF_STATIC_CONST_VAL_FLOAT(val_2000,0.147581);
#define CTNODE_cmu_us_awb_dur_NO_3569 3601
DEF_STATIC_CONST_VAL_FLOAT(val_2001,-0.187699);
#define CTNODE_cmu_us_awb_dur_NO_3601 3603
DEF_STATIC_CONST_VAL_FLOAT(val_2002,1.013380);
#define CTNODE_cmu_us_awb_dur_NO_3605 3607
DEF_STATIC_CONST_VAL_FLOAT(val_2003,0.349378);
#define CTNODE_cmu_us_awb_dur_NO_3604 3608
DEF_STATIC_CONST_VAL_FLOAT(val_2004,0.295580);
#define CTNODE_cmu_us_awb_dur_NO_3609 3611
DEF_STATIC_CONST_VAL_FLOAT(val_2005,-0.093166);
#define CTNODE_cmu_us_awb_dur_NO_3608 3612
DEF_STATIC_CONST_VAL_FLOAT(val_2006,0.518649);
#define CTNODE_cmu_us_awb_dur_NO_3612 3614
DEF_STATIC_CONST_VAL_FLOAT(val_2007,0.264761);
#define CTNODE_cmu_us_awb_dur_NO_3603 3615
DEF_STATIC_CONST_VAL_FLOAT(val_2008,0.512049);
#define CTNODE_cmu_us_awb_dur_NO_3616 3618
DEF_STATIC_CONST_VAL_FLOAT(val_2009,0.535243);
#define CTNODE_cmu_us_awb_dur_NO_3619 3621
DEF_STATIC_CONST_VAL_FLOAT(val_2010,0.276607);
#define CTNODE_cmu_us_awb_dur_NO_3623 3625
DEF_STATIC_CONST_VAL_FLOAT(val_2011,-0.019703);
#define CTNODE_cmu_us_awb_dur_NO_3622 3626
DEF_STATIC_CONST_VAL_FLOAT(val_2012,-0.146843);
#define CTNODE_cmu_us_awb_dur_NO_3621 3627
DEF_STATIC_CONST_VAL_FLOAT(val_2013,0.565006);
#define CTNODE_cmu_us_awb_dur_NO_3618 3628
DEF_STATIC_CONST_VAL_FLOAT(val_2014,0.180995);
#define CTNODE_cmu_us_awb_dur_NO_3628 3630
DEF_STATIC_CONST_VAL_FLOAT(val_2015,-0.110414);
#define CTNODE_cmu_us_awb_dur_NO_3615 3631
DEF_STATIC_CONST_VAL_FLOAT(val_2016,-0.301755);
#define CTNODE_cmu_us_awb_dur_NO_3632 3634
DEF_STATIC_CONST_VAL_FLOAT(val_2017,-0.023387);
#define CTNODE_cmu_us_awb_dur_NO_3631 3635
DEF_STATIC_CONST_VAL_FLOAT(val_2018,0.224015);
#define CTNODE_cmu_us_awb_dur_NO_3518 3636
DEF_STATIC_CONST_VAL_FLOAT(val_2019,-0.098967);
#define CTNODE_cmu_us_awb_dur_NO_3636 3638
DEF_STATIC_CONST_VAL_FLOAT(val_2020,1.031930);
#define CTNODE_cmu_us_awb_dur_NO_3639 3641
DEF_STATIC_CONST_VAL_FLOAT(val_2021,0.360563);
#define CTNODE_cmu_us_awb_dur_NO_3638 3642
DEF_STATIC_CONST_VAL_FLOAT(val_2022,1.017930);
#define CTNODE_cmu_us_awb_dur_NO_3643 3645
DEF_STATIC_CONST_VAL_FLOAT(val_2023,0.389486);
#define CTNODE_cmu_us_awb_dur_NO_3642 3646
DEF_STATIC_CONST_VAL_FLOAT(val_2024,0.724524);
#define CTNODE_cmu_us_awb_dur_NO_3646 3648
DEF_STATIC_CONST_VAL_FLOAT(val_2025,-0.202498);
#define CTNODE_cmu_us_awb_dur_NO_3648 3650
DEF_STATIC_CONST_VAL_FLOAT(val_2026,0.561306);
#define CTNODE_cmu_us_awb_dur_NO_3650 3652
DEF_STATIC_CONST_VAL_FLOAT(val_2027,0.023243);
#define CTNODE_cmu_us_awb_dur_NO_3653 3655
DEF_STATIC_CONST_VAL_FLOAT(val_2028,-0.243725);
#define CTNODE_cmu_us_awb_dur_NO_3652 3656
DEF_STATIC_CONST_VAL_FLOAT(val_2029,0.304881);
#define CTNODE_cmu_us_awb_dur_NO_3658 3660
DEF_STATIC_CONST_VAL_FLOAT(val_2030,0.412370);
#define CTNODE_cmu_us_awb_dur_NO_3660 3662
DEF_STATIC_CONST_VAL_FLOAT(val_2031,0.841357);
#define CTNODE_cmu_us_awb_dur_NO_3657 3663
DEF_STATIC_CONST_VAL_FLOAT(val_2032,0.110930);
#define CTNODE_cmu_us_awb_dur_NO_3656 3664
DEF_STATIC_CONST_VAL_FLOAT(val_2033,0.023882);
#define CTNODE_cmu_us_awb_dur_NO_3665 3667
DEF_STATIC_CONST_VAL_FLOAT(val_2034,0.112859);
#define CTNODE_cmu_us_awb_dur_NO_3667 3669
DEF_STATIC_CONST_VAL_FLOAT(val_2035,0.680782);
#define CTNODE_cmu_us_awb_dur_NO_3669 3671
DEF_STATIC_CONST_VAL_FLOAT(val_2036,0.614511);
#define CTNODE_cmu_us_awb_dur_NO_3672 3674
DEF_STATIC_CONST_VAL_FLOAT(val_2037,0.178084);
#define CTNODE_cmu_us_awb_dur_NO_3671 3675
DEF_STATIC_CONST_VAL_FLOAT(val_2038,-0.044572);
#define CTNODE_cmu_us_awb_dur_NO_3664 3676
DEF_STATIC_CONST_VAL_FLOAT(val_2039,-0.112339);
#define CTNODE_cmu_us_awb_dur_NO_3676 3678
DEF_STATIC_CONST_VAL_FLOAT(val_2040,0.142756);
#define CTNODE_cmu_us_awb_dur_NO_3053 3679
DEF_STATIC_CONST_VAL_FLOAT(val_2041,1.397880);
#define CTNODE_cmu_us_awb_dur_NO_3680 3682
DEF_STATIC_CONST_VAL_FLOAT(val_2042,1.208530);
#define CTNODE_cmu_us_awb_dur_NO_3682 3684
DEF_STATIC_CONST_VAL_FLOAT(val_2043,-0.464233);
#define CTNODE_cmu_us_awb_dur_NO_3685 3687
DEF_STATIC_CONST_VAL_FLOAT(val_2044,0.412514);
#define CTNODE_cmu_us_awb_dur_NO_3684 3688
DEF_STATIC_CONST_VAL_FLOAT(val_2045,0.930837);
#define CTNODE_cmu_us_awb_dur_NO_3688 3690
DEF_STATIC_CONST_VAL_FLOAT(val_2046,0.454211);
#define CTNODE_cmu_us_awb_dur_NO_3679 3691
DEF_STATIC_CONST_VAL_FLOAT(val_2047,0.196495);
#define CTNODE_cmu_us_awb_dur_NO_3694 3696
DEF_STATIC_CONST_VAL_FLOAT(val_2048,0.154327);
#define CTNODE_cmu_us_awb_dur_NO_3693 3697
DEF_STATIC_CONST_VAL_FLOAT(val_2049,0.026292);
#define CTNODE_cmu_us_awb_dur_NO_3697 3699
DEF_STATIC_CONST_VAL_FLOAT(val_2050,-0.270756);
#define CTNODE_cmu_us_awb_dur_NO_3700 3702
DEF_STATIC_CONST_VAL_FLOAT(val_2051,-0.202073);
#define CTNODE_cmu_us_awb_dur_NO_3699 3703
DEF_STATIC_CONST_VAL_FLOAT(val_2052,-0.694596);
#define CTNODE_cmu_us_awb_dur_NO_3692 3704
DEF_STATIC_CONST_VAL_FLOAT(val_2053,0.642200);
#define CTNODE_cmu_us_awb_dur_NO_3705 3707
DEF_STATIC_CONST_VAL_FLOAT(val_2054,1.351360);
#define CTNODE_cmu_us_awb_dur_NO_3704 3708
DEF_STATIC_CONST_VAL_FLOAT(val_2055,0.079602);
#define CTNODE_cmu_us_awb_dur_NO_3709 3711
DEF_STATIC_CONST_VAL_FLOAT(val_2056,0.545561);
#define CTNODE_cmu_us_awb_dur_NO_3712 3714
DEF_STATIC_CONST_VAL_FLOAT(val_2057,0.058614);
#define CTNODE_cmu_us_awb_dur_NO_3711 3715
DEF_STATIC_CONST_VAL_FLOAT(val_2058,0.583493);
#define CTNODE_cmu_us_awb_dur_NO_3716 3718
DEF_STATIC_CONST_VAL_FLOAT(val_2059,0.176977);
#define CTNODE_cmu_us_awb_dur_NO_3715 3719
DEF_STATIC_CONST_VAL_FLOAT(val_2060,0.577875);
#define CTNODE_cmu_us_awb_dur_NO_3719 3721
DEF_STATIC_CONST_VAL_FLOAT(val_2061,1.635280);
#define CTNODE_cmu_us_awb_dur_NO_3722 3724
DEF_STATIC_CONST_VAL_FLOAT(val_2062,1.051600);
#define CTNODE_cmu_us_awb_dur_NO_3721 3725
DEF_STATIC_CONST_VAL_FLOAT(val_2063,0.731152);
#define CTNODE_cmu_us_awb_dur_NO_3708 3726
DEF_STATIC_CONST_VAL_FLOAT(val_2064,0.189712);
#define CTNODE_cmu_us_awb_dur_NO_3727 3729
DEF_STATIC_CONST_VAL_FLOAT(val_2065,-0.159413);
#define CTNODE_cmu_us_awb_dur_NO_3726 3730
DEF_STATIC_CONST_VAL_FLOAT(val_2066,0.589126);
#define CTNODE_cmu_us_awb_dur_NO_3691 3731
DEF_STATIC_CONST_VAL_FLOAT(val_2067,-0.458776);
#define CTNODE_cmu_us_awb_dur_NO_3733 3735
DEF_STATIC_CONST_VAL_FLOAT(val_2068,0.045300);
#define CTNODE_cmu_us_awb_dur_NO_3732 3736
DEF_STATIC_CONST_VAL_FLOAT(val_2069,1.106220);
#define CTNODE_cmu_us_awb_dur_NO_3738 3740
DEF_STATIC_CONST_VAL_FLOAT(val_2070,0.833474);
#define CTNODE_cmu_us_awb_dur_NO_3737 3741
DEF_STATIC_CONST_VAL_FLOAT(val_2071,0.262347);
#define CTNODE_cmu_us_awb_dur_NO_3736 3742
DEF_STATIC_CONST_VAL_FLOAT(val_2072,1.369690);
#define CTNODE_cmu_us_awb_dur_NO_3731 3743
DEF_STATIC_CONST_VAL_FLOAT(val_2073,0.003195);
#define CTNODE_cmu_us_awb_dur_NO_3745 3747
DEF_STATIC_CONST_VAL_FLOAT(val_2074,0.699481);
#define CTNODE_cmu_us_awb_dur_NO_3744 3748
DEF_STATIC_CONST_VAL_FLOAT(val_2075,1.145110);
#define CTNODE_cmu_us_awb_dur_NO_3748 3750
DEF_STATIC_CONST_VAL_FLOAT(val_2076,0.863516);
#define CTNODE_cmu_us_awb_dur_NO_3750 3752
DEF_STATIC_CONST_VAL_FLOAT(val_2077,0.696407);
#define CTNODE_cmu_us_awb_dur_NO_3743 3753
DEF_STATIC_CONST_VAL_FLOAT(val_2078,-0.425413);
#define CTNODE_cmu_us_awb_dur_NO_3754 3756
DEF_STATIC_CONST_VAL_FLOAT(val_2079,-0.755625);
#define CTNODE_cmu_us_awb_dur_NO_3756 3758
DEF_STATIC_CONST_VAL_FLOAT(val_2080,-1.134480);
#define CTNODE_cmu_us_awb_dur_NO_3753 3759
DEF_STATIC_CONST_VAL_FLOAT(val_2081,-0.613999);
#define CTNODE_cmu_us_awb_dur_NO_3760 3762
DEF_STATIC_CONST_VAL_FLOAT(val_2082,0.908938);
#define CTNODE_cmu_us_awb_dur_NO_3763 3765
DEF_STATIC_CONST_VAL_FLOAT(val_2083,0.015100);
#define CTNODE_cmu_us_awb_dur_NO_3765 3767
DEF_STATIC_CONST_VAL_FLOAT(val_2084,0.584904);
#define CTNODE_cmu_us_awb_dur_NO_3762 3768
DEF_STATIC_CONST_VAL_FLOAT(val_2085,1.564620);
#define CTNODE_cmu_us_awb_dur_NO_3759 3769
DEF_STATIC_CONST_VAL_STRING(val_2086,"er_61");
DEF_STATIC_CONST_VAL_FLOAT(val_2087,0.169798);
#define CTNODE_cmu_us_awb_dur_NO_3771 3773
DEF_STATIC_CONST_VAL_FLOAT(val_2088,0.756808);
#define CTNODE_cmu_us_awb_dur_NO_3770 3774
DEF_STATIC_CONST_VAL_FLOAT(val_2089,1.045290);
#define CTNODE_cmu_us_awb_dur_NO_3776 3778
DEF_STATIC_CONST_VAL_FLOAT(val_2090,0.455522);
#define CTNODE_cmu_us_awb_dur_NO_3775 3779
DEF_STATIC_CONST_VAL_STRING(val_2091,"eh_57");
DEF_STATIC_CONST_VAL_FLOAT(val_2092,0.747368);
#define CTNODE_cmu_us_awb_dur_NO_3779 3781
DEF_STATIC_CONST_VAL_FLOAT(val_2093,-0.649487);
#define CTNODE_cmu_us_awb_dur_NO_3783 3785
DEF_STATIC_CONST_VAL_FLOAT(val_2094,-0.423878);
#define CTNODE_cmu_us_awb_dur_NO_3782 3786
DEF_STATIC_CONST_VAL_FLOAT(val_2095,0.019075);
#define CTNODE_cmu_us_awb_dur_NO_3781 3787
DEF_STATIC_CONST_VAL_FLOAT(val_2096,-0.326117);
#define CTNODE_cmu_us_awb_dur_NO_3787 3789
DEF_STATIC_CONST_VAL_FLOAT(val_2097,-0.237330);
#define CTNODE_cmu_us_awb_dur_NO_3791 3793
DEF_STATIC_CONST_VAL_FLOAT(val_2098,0.384186);
#define CTNODE_cmu_us_awb_dur_NO_3793 3795
DEF_STATIC_CONST_VAL_FLOAT(val_2099,-0.013405);
#define CTNODE_cmu_us_awb_dur_NO_3790 3796
DEF_STATIC_CONST_VAL_FLOAT(val_2100,0.667984);
#define CTNODE_cmu_us_awb_dur_NO_3796 3798
DEF_STATIC_CONST_VAL_FLOAT(val_2101,0.235674);
#define CTNODE_cmu_us_awb_dur_NO_3798 3800
DEF_STATIC_CONST_VAL_FLOAT(val_2102,-0.165151);
#define CTNODE_cmu_us_awb_dur_NO_3789 3801
DEF_STATIC_CONST_VAL_FLOAT(val_2103,-0.059452);
#define CTNODE_cmu_us_awb_dur_NO_3801 3803
DEF_STATIC_CONST_VAL_FLOAT(val_2104,-0.264164);
#define CTNODE_cmu_us_awb_dur_NO_3774 3804
DEF_STATIC_CONST_VAL_STRING(val_2105,"p_138");
DEF_STATIC_CONST_VAL_FLOAT(val_2106,-0.834140);
#define CTNODE_cmu_us_awb_dur_NO_3804 3806
DEF_STATIC_CONST_VAL_STRING(val_2107,"ey_68");
DEF_STATIC_CONST_VAL_FLOAT(val_2108,-0.690820);
#define CTNODE_cmu_us_awb_dur_NO_3807 3809
DEF_STATIC_CONST_VAL_FLOAT(val_2109,-0.652384);
#define CTNODE_cmu_us_awb_dur_NO_3809 3811
DEF_STATIC_CONST_VAL_FLOAT(val_2110,-0.259380);
#define CTNODE_cmu_us_awb_dur_NO_3806 3812
DEF_STATIC_CONST_VAL_STRING(val_2111,"p_137");
DEF_STATIC_CONST_VAL_FLOAT(val_2112,-0.876316);
#define CTNODE_cmu_us_awb_dur_NO_3812 3814
DEF_STATIC_CONST_VAL_FLOAT(val_2113,0.370497);
#define CTNODE_cmu_us_awb_dur_NO_3817 3819
DEF_STATIC_CONST_VAL_FLOAT(val_2114,-0.620391);
#define CTNODE_cmu_us_awb_dur_NO_3819 3821
DEF_STATIC_CONST_VAL_STRING(val_2115,"l_107");
DEF_STATIC_CONST_VAL_FLOAT(val_2116,0.295812);
#define CTNODE_cmu_us_awb_dur_NO_3821 3823
DEF_STATIC_CONST_VAL_FLOAT(val_2117,5.700000);
DEF_STATIC_CONST_VAL_FLOAT(val_2118,0.162371);
#define CTNODE_cmu_us_awb_dur_NO_3825 3827
DEF_STATIC_CONST_VAL_FLOAT(val_2119,-0.381522);
#define CTNODE_cmu_us_awb_dur_NO_3824 3828
DEF_STATIC_CONST_VAL_FLOAT(val_2120,0.405067);
#define CTNODE_cmu_us_awb_dur_NO_3823 3829
DEF_STATIC_CONST_VAL_FLOAT(val_2121,-0.554472);
#define CTNODE_cmu_us_awb_dur_NO_3832 3834
DEF_STATIC_CONST_VAL_FLOAT(val_2122,-0.367875);
#define CTNODE_cmu_us_awb_dur_NO_3834 3836
DEF_STATIC_CONST_VAL_FLOAT(val_2123,0.127621);
#define CTNODE_cmu_us_awb_dur_NO_3836 3838
DEF_STATIC_CONST_VAL_FLOAT(val_2124,-0.243265);
#define CTNODE_cmu_us_awb_dur_NO_3831 3839
DEF_STATIC_CONST_VAL_FLOAT(val_2125,-0.623993);
#define CTNODE_cmu_us_awb_dur_NO_3840 3842
DEF_STATIC_CONST_VAL_FLOAT(val_2126,-0.503225);
#define CTNODE_cmu_us_awb_dur_NO_3839 3843
DEF_STATIC_CONST_VAL_FLOAT(val_2127,-0.153409);
#define CTNODE_cmu_us_awb_dur_NO_3830 3844
DEF_STATIC_CONST_VAL_FLOAT(val_2128,0.110076);
#define CTNODE_cmu_us_awb_dur_NO_3829 3845
DEF_STATIC_CONST_VAL_FLOAT(val_2129,-0.401737);
#define CTNODE_cmu_us_awb_dur_NO_3845 3847
DEF_STATIC_CONST_VAL_FLOAT(val_2130,-0.285227);
#define CTNODE_cmu_us_awb_dur_NO_3847 3849
DEF_STATIC_CONST_VAL_FLOAT(val_2131,0.047139);
#define CTNODE_cmu_us_awb_dur_NO_3850 3852
DEF_STATIC_CONST_VAL_FLOAT(val_2132,-0.361108);
#define CTNODE_cmu_us_awb_dur_NO_3852 3854
DEF_STATIC_CONST_VAL_FLOAT(val_2133,-0.079910);
#define CTNODE_cmu_us_awb_dur_NO_3854 3856
DEF_STATIC_CONST_VAL_FLOAT(val_2134,-0.245171);
#define CTNODE_cmu_us_awb_dur_NO_3849 3857
DEF_STATIC_CONST_VAL_FLOAT(val_2135,0.459733);
#define CTNODE_cmu_us_awb_dur_NO_3857 3859
DEF_STATIC_CONST_VAL_FLOAT(val_2136,-0.275388);
#define CTNODE_cmu_us_awb_dur_NO_3860 3862
DEF_STATIC_CONST_VAL_FLOAT(val_2137,0.009466);
#define CTNODE_cmu_us_awb_dur_NO_3859 3863
DEF_STATIC_CONST_VAL_FLOAT(val_2138,0.280929);
#define CTNODE_cmu_us_awb_dur_NO_3863 3865
DEF_STATIC_CONST_VAL_FLOAT(val_2139,-0.073801);
#define CTNODE_cmu_us_awb_dur_NO_3816 3866
DEF_STATIC_CONST_VAL_FLOAT(val_2140,0.143944);
#define CTNODE_cmu_us_awb_dur_NO_3866 3868
DEF_STATIC_CONST_VAL_FLOAT(val_2141,-0.631309);
#define CTNODE_cmu_us_awb_dur_NO_3869 3871
DEF_STATIC_CONST_VAL_FLOAT(val_2142,-0.285371);
#define CTNODE_cmu_us_awb_dur_NO_3871 3873
DEF_STATIC_CONST_VAL_FLOAT(val_2143,-0.407811);
#define CTNODE_cmu_us_awb_dur_NO_3873 3875
DEF_STATIC_CONST_VAL_FLOAT(val_2144,-0.589815);
#define CTNODE_cmu_us_awb_dur_NO_3868 3876
DEF_STATIC_CONST_VAL_FLOAT(val_2145,-0.323198);
#define CTNODE_cmu_us_awb_dur_NO_3877 3879
DEF_STATIC_CONST_VAL_FLOAT(val_2146,-0.532535);
#define CTNODE_cmu_us_awb_dur_NO_3876 3880
DEF_STATIC_CONST_VAL_FLOAT(val_2147,0.284656);
#define CTNODE_cmu_us_awb_dur_NO_3882 3884
DEF_STATIC_CONST_VAL_FLOAT(val_2148,-0.028411);
#define CTNODE_cmu_us_awb_dur_NO_3881 3885
DEF_STATIC_CONST_VAL_FLOAT(val_2149,-0.133684);
#define CTNODE_cmu_us_awb_dur_NO_3885 3887
DEF_STATIC_CONST_VAL_FLOAT(val_2150,-0.463322);
#define CTNODE_cmu_us_awb_dur_NO_3880 3888
DEF_STATIC_CONST_VAL_STRING(val_2151,"ow");
DEF_STATIC_CONST_VAL_FLOAT(val_2152,-0.579223);
#define CTNODE_cmu_us_awb_dur_NO_3888 3890
DEF_STATIC_CONST_VAL_FLOAT(val_2153,-0.298028);
#define CTNODE_cmu_us_awb_dur_NO_3891 3893
DEF_STATIC_CONST_VAL_FLOAT(val_2154,0.051607);
#define CTNODE_cmu_us_awb_dur_NO_3890 3894
DEF_STATIC_CONST_VAL_FLOAT(val_2155,-0.473484);
#define CTNODE_cmu_us_awb_dur_NO_3894 3896
DEF_STATIC_CONST_VAL_FLOAT(val_2156,-0.209234);
#define CTNODE_cmu_us_awb_dur_NO_3815 3897
DEF_STATIC_CONST_VAL_STRING(val_2157,"uw_180");
DEF_STATIC_CONST_VAL_FLOAT(val_2158,0.828509);
#define CTNODE_cmu_us_awb_dur_NO_3897 3899
DEF_STATIC_CONST_VAL_FLOAT(val_2159,0.672449);
#define CTNODE_cmu_us_awb_dur_NO_3900 3902
DEF_STATIC_CONST_VAL_FLOAT(val_2160,0.119497);
#define CTNODE_cmu_us_awb_dur_NO_3899 3903
DEF_STATIC_CONST_VAL_FLOAT(val_2161,-0.129815);
#define CTNODE_cmu_us_awb_dur_NO_3904 3906
DEF_STATIC_CONST_VAL_FLOAT(val_2162,-0.693888);
#define CTNODE_cmu_us_awb_dur_NO_3906 3908
DEF_STATIC_CONST_VAL_FLOAT(val_2163,-0.349747);
#define CTNODE_cmu_us_awb_dur_NO_3908 3910
DEF_STATIC_CONST_VAL_FLOAT(val_2164,-0.620138);
#define CTNODE_cmu_us_awb_dur_NO_3903 3911
DEF_STATIC_CONST_VAL_FLOAT(val_2165,-0.518627);
#define CTNODE_cmu_us_awb_dur_NO_3911 3913
DEF_STATIC_CONST_VAL_FLOAT(val_2166,0.293406);
#define CTNODE_cmu_us_awb_dur_NO_3915 3917
DEF_STATIC_CONST_VAL_FLOAT(val_2167,-0.465160);
#define CTNODE_cmu_us_awb_dur_NO_3914 3918
DEF_STATIC_CONST_VAL_FLOAT(val_2168,1.237840);
#define CTNODE_cmu_us_awb_dur_NO_3913 3919
DEF_STATIC_CONST_VAL_FLOAT(val_2169,0.625525);
#define CTNODE_cmu_us_awb_dur_NO_3921 3923
DEF_STATIC_CONST_VAL_FLOAT(val_2170,-0.279569);
#define CTNODE_cmu_us_awb_dur_NO_3924 3926
DEF_STATIC_CONST_VAL_FLOAT(val_2171,-0.567191);
#define CTNODE_cmu_us_awb_dur_NO_3923 3927
DEF_STATIC_CONST_VAL_FLOAT(val_2172,-0.507150);
#define CTNODE_cmu_us_awb_dur_NO_3927 3929
DEF_STATIC_CONST_VAL_FLOAT(val_2173,0.113467);
#define CTNODE_cmu_us_awb_dur_NO_3931 3933
DEF_STATIC_CONST_VAL_FLOAT(val_2174,-0.243467);
#define CTNODE_cmu_us_awb_dur_NO_3930 3934
DEF_STATIC_CONST_VAL_FLOAT(val_2175,-0.250894);
#define CTNODE_cmu_us_awb_dur_NO_3934 3936
DEF_STATIC_CONST_VAL_FLOAT(val_2176,-0.391530);
#define CTNODE_cmu_us_awb_dur_NO_3929 3937
DEF_STATIC_CONST_VAL_FLOAT(val_2177,0.518692);
#define CTNODE_cmu_us_awb_dur_NO_3937 3939
DEF_STATIC_CONST_VAL_FLOAT(val_2178,-0.174676);
#define CTNODE_cmu_us_awb_dur_NO_3940 3942
DEF_STATIC_CONST_VAL_FLOAT(val_2179,-0.484149);
#define CTNODE_cmu_us_awb_dur_NO_3939 3943
DEF_STATIC_CONST_VAL_FLOAT(val_2180,-0.304855);
#define CTNODE_cmu_us_awb_dur_NO_3943 3945
DEF_STATIC_CONST_VAL_FLOAT(val_2181,-0.163721);
#define CTNODE_cmu_us_awb_dur_NO_3946 3948
DEF_STATIC_CONST_VAL_FLOAT(val_2182,0.517076);
#define CTNODE_cmu_us_awb_dur_NO_3948 3950
DEF_STATIC_CONST_VAL_FLOAT(val_2183,0.494782);
#define CTNODE_cmu_us_awb_dur_NO_3952 3954
DEF_STATIC_CONST_VAL_FLOAT(val_2184,0.086869);
#define CTNODE_cmu_us_awb_dur_NO_3951 3955
DEF_STATIC_CONST_VAL_FLOAT(val_2185,-0.476028);
#define CTNODE_cmu_us_awb_dur_NO_3955 3957
DEF_STATIC_CONST_VAL_FLOAT(val_2186,0.220569);
#define CTNODE_cmu_us_awb_dur_NO_3957 3959
DEF_STATIC_CONST_VAL_FLOAT(val_2187,-0.233106);
#define CTNODE_cmu_us_awb_dur_NO_3959 3961
DEF_STATIC_CONST_VAL_FLOAT(val_2188,0.217614);
#define CTNODE_cmu_us_awb_dur_NO_3950 3962
DEF_STATIC_CONST_VAL_FLOAT(val_2189,0.178926);
#define CTNODE_cmu_us_awb_dur_NO_3963 3965
DEF_STATIC_CONST_VAL_FLOAT(val_2190,0.351114);
#define CTNODE_cmu_us_awb_dur_NO_3965 3967
DEF_STATIC_CONST_VAL_FLOAT(val_2191,0.709441);
#define CTNODE_cmu_us_awb_dur_NO_3962 3968
DEF_STATIC_CONST_VAL_FLOAT(val_2192,-0.098158);
#define CTNODE_cmu_us_awb_dur_NO_3945 3969
DEF_STATIC_CONST_VAL_FLOAT(val_2193,-0.297958);
#define CTNODE_cmu_us_awb_dur_NO_3920 3970
DEF_STATIC_CONST_VAL_FLOAT(val_2194,0.002667);
#define CTNODE_cmu_us_awb_dur_NO_3970 3972
DEF_STATIC_CONST_VAL_FLOAT(val_2195,0.402205);
#define CTNODE_cmu_us_awb_dur_NO_3973 3975
DEF_STATIC_CONST_VAL_FLOAT(val_2196,0.786663);
#define CTNODE_cmu_us_awb_dur_NO_3972 3976
DEF_STATIC_CONST_VAL_FLOAT(val_2197,0.038100);
#define CTNODE_cmu_us_awb_dur_NO_3976 3978
DEF_STATIC_CONST_VAL_FLOAT(val_2198,0.465588);
#define CTNODE_cmu_us_awb_dur_NO_3919 3979
DEF_STATIC_CONST_VAL_FLOAT(val_2199,-0.663489);
#define CTNODE_cmu_us_awb_dur_NO_3979 3981
DEF_STATIC_CONST_VAL_FLOAT(val_2200,0.409082);
#define CTNODE_cmu_us_awb_dur_NO_3981 3983
DEF_STATIC_CONST_VAL_FLOAT(val_2201,0.408026);
#define CTNODE_cmu_us_awb_dur_NO_3984 3986
DEF_STATIC_CONST_VAL_FLOAT(val_2202,0.019993);
#define CTNODE_cmu_us_awb_dur_NO_3987 3989
DEF_STATIC_CONST_VAL_FLOAT(val_2203,0.465621);
#define CTNODE_cmu_us_awb_dur_NO_3989 3991
DEF_STATIC_CONST_VAL_FLOAT(val_2204,0.139317);
#define CTNODE_cmu_us_awb_dur_NO_3986 3992
DEF_STATIC_CONST_VAL_FLOAT(val_2205,0.185638);
#define CTNODE_cmu_us_awb_dur_NO_3992 3994
DEF_STATIC_CONST_VAL_FLOAT(val_2206,0.064565);
#define CTNODE_cmu_us_awb_dur_NO_3996 3998
DEF_STATIC_CONST_VAL_FLOAT(val_2207,-0.118629);
#define CTNODE_cmu_us_awb_dur_NO_3995 3999
DEF_STATIC_CONST_VAL_FLOAT(val_2208,-0.278032);
#define CTNODE_cmu_us_awb_dur_NO_3994 4000
DEF_STATIC_CONST_VAL_FLOAT(val_2209,-0.314528);
#define CTNODE_cmu_us_awb_dur_NO_3983 4001
DEF_STATIC_CONST_VAL_STRING(val_2210,"ay_32");
DEF_STATIC_CONST_VAL_FLOAT(val_2211,0.411491);
#define CTNODE_cmu_us_awb_dur_NO_4001 4003
DEF_STATIC_CONST_VAL_FLOAT(val_2212,0.570705);
#define CTNODE_cmu_us_awb_dur_NO_4004 4006
DEF_STATIC_CONST_VAL_FLOAT(val_2213,-0.158264);
#define CTNODE_cmu_us_awb_dur_NO_4003 4007
DEF_STATIC_CONST_VAL_FLOAT(val_2214,-0.600021);
#define CTNODE_cmu_us_awb_dur_NO_4007 4009
DEF_STATIC_CONST_VAL_FLOAT(val_2215,-0.057860);
#define CTNODE_cmu_us_awb_dur_NO_4010 4012
DEF_STATIC_CONST_VAL_FLOAT(val_2216,0.320269);
#define CTNODE_cmu_us_awb_dur_NO_4009 4013
DEF_STATIC_CONST_VAL_FLOAT(val_2217,0.741683);
#define CTNODE_cmu_us_awb_dur_NO_4014 4016
DEF_STATIC_CONST_VAL_FLOAT(val_2218,-0.252560);
#define CTNODE_cmu_us_awb_dur_NO_4016 4018
DEF_STATIC_CONST_VAL_FLOAT(val_2219,-0.360819);
#define CTNODE_cmu_us_awb_dur_NO_4013 4019
DEF_STATIC_CONST_VAL_FLOAT(val_2220,-0.498005);
#define CTNODE_cmu_us_awb_dur_NO_4019 4021
DEF_STATIC_CONST_VAL_FLOAT(val_2221,-0.429462);
#define CTNODE_cmu_us_awb_dur_NO_4021 4023
DEF_STATIC_CONST_VAL_FLOAT(val_2222,0.201459);
#define CTNODE_cmu_us_awb_dur_NO_4023 4025
DEF_STATIC_CONST_VAL_STRING(val_2223,"eh_58");
DEF_STATIC_CONST_VAL_FLOAT(val_2224,0.254410);
#define CTNODE_cmu_us_awb_dur_NO_4025 4027
DEF_STATIC_CONST_VAL_FLOAT(val_2225,0.212539);
#define CTNODE_cmu_us_awb_dur_NO_4028 4030
DEF_STATIC_CONST_VAL_FLOAT(val_2226,-0.068128);
#define CTNODE_cmu_us_awb_dur_NO_4027 4031
DEF_STATIC_CONST_VAL_FLOAT(val_2227,0.126429);
#define CTNODE_cmu_us_awb_dur_NO_4033 4035
DEF_STATIC_CONST_VAL_FLOAT(val_2228,0.025877);
#define CTNODE_cmu_us_awb_dur_NO_4032 4036
DEF_STATIC_CONST_VAL_FLOAT(val_2229,-0.141994);
#define CTNODE_cmu_us_awb_dur_NO_4031 4037
DEF_STATIC_CONST_VAL_FLOAT(val_2230,0.045177);
#define CTNODE_cmu_us_awb_dur_NO_4037 4039
DEF_STATIC_CONST_VAL_FLOAT(val_2231,-0.143747);
#define CTNODE_cmu_us_awb_dur_NO_4040 4042
DEF_STATIC_CONST_VAL_FLOAT(val_2232,-0.622123);
#define CTNODE_cmu_us_awb_dur_NO_4042 4044
DEF_STATIC_CONST_VAL_FLOAT(val_2233,-0.400861);
#define CTNODE_cmu_us_awb_dur_NO_4039 4045
DEF_STATIC_CONST_VAL_FLOAT(val_2234,0.400380);
#define CTNODE_cmu_us_awb_dur_NO_4046 4048
DEF_STATIC_CONST_VAL_FLOAT(val_2235,0.019237);
#define CTNODE_cmu_us_awb_dur_NO_4048 4050
DEF_STATIC_CONST_VAL_FLOAT(val_2236,-0.410769);
#define CTNODE_cmu_us_awb_dur_NO_4045 4051
DEF_STATIC_CONST_VAL_FLOAT(val_2237,-0.381629);
#define CTNODE_cmu_us_awb_dur_NO_4054 4056
DEF_STATIC_CONST_VAL_FLOAT(val_2238,-0.192807);
#define CTNODE_cmu_us_awb_dur_NO_4053 4057
DEF_STATIC_CONST_VAL_FLOAT(val_2239,-0.447805);
#define CTNODE_cmu_us_awb_dur_NO_4052 4058
DEF_STATIC_CONST_VAL_FLOAT(val_2240,-0.341276);
#define CTNODE_cmu_us_awb_dur_NO_4058 4060
DEF_STATIC_CONST_VAL_FLOAT(val_2241,0.049814);
#define CTNODE_cmu_us_awb_dur_NO_4060 4062
DEF_STATIC_CONST_VAL_FLOAT(val_2242,-0.309452);
#define CTNODE_cmu_us_awb_dur_NO_4063 4065
DEF_STATIC_CONST_VAL_FLOAT(val_2243,-0.072114);
#define CTNODE_cmu_us_awb_dur_NO_4066 4068
DEF_STATIC_CONST_VAL_FLOAT(val_2244,-0.433531);
#define CTNODE_cmu_us_awb_dur_NO_4065 4069
DEF_STATIC_CONST_VAL_FLOAT(val_2245,0.073020);
#define CTNODE_cmu_us_awb_dur_NO_4069 4071
DEF_STATIC_CONST_VAL_FLOAT(val_2246,-0.180810);
#define CTNODE_cmu_us_awb_dur_NO_4062 4072
DEF_STATIC_CONST_VAL_FLOAT(val_2247,-0.420207);
#define CTNODE_cmu_us_awb_dur_NO_4051 4073
DEF_STATIC_CONST_VAL_FLOAT(val_2248,-0.479912);
#define CTNODE_cmu_us_awb_dur_NO_3814 4074
DEF_STATIC_CONST_VAL_FLOAT(val_2249,0.063934);
#define CTNODE_cmu_us_awb_dur_NO_4076 4078
DEF_STATIC_CONST_VAL_FLOAT(val_2250,-0.413466);
#define CTNODE_cmu_us_awb_dur_NO_4075 4079
DEF_STATIC_CONST_VAL_FLOAT(val_2251,-0.665275);
#define CTNODE_cmu_us_awb_dur_NO_4080 4082
DEF_STATIC_CONST_VAL_FLOAT(val_2252,-0.574541);
#define CTNODE_cmu_us_awb_dur_NO_4079 4083
DEF_STATIC_CONST_VAL_FLOAT(val_2253,-0.334358);
#define CTNODE_cmu_us_awb_dur_NO_4083 4085
DEF_STATIC_CONST_VAL_FLOAT(val_2254,-0.539216);
#define CTNODE_cmu_us_awb_dur_NO_4074 4086
DEF_STATIC_CONST_VAL_FLOAT(val_2255,-0.484593);
#define CTNODE_cmu_us_awb_dur_NO_4088 4090
DEF_STATIC_CONST_VAL_FLOAT(val_2256,0.555484);
#define CTNODE_cmu_us_awb_dur_NO_4087 4091
DEF_STATIC_CONST_VAL_FLOAT(val_2257,-0.404075);
#define CTNODE_cmu_us_awb_dur_NO_4093 4095
DEF_STATIC_CONST_VAL_FLOAT(val_2258,-0.152453);
#define CTNODE_cmu_us_awb_dur_NO_4092 4096
DEF_STATIC_CONST_VAL_FLOAT(val_2259,-0.341393);
#define CTNODE_cmu_us_awb_dur_NO_4096 4098
DEF_STATIC_CONST_VAL_FLOAT(val_2260,-0.469238);
#define CTNODE_cmu_us_awb_dur_NO_4098 4100
DEF_STATIC_CONST_VAL_FLOAT(val_2261,-0.521248);
#define CTNODE_cmu_us_awb_dur_NO_4100 4102
DEF_STATIC_CONST_VAL_FLOAT(val_2262,-0.746081);
#define CTNODE_cmu_us_awb_dur_NO_4102 4104
DEF_STATIC_CONST_VAL_FLOAT(val_2263,-0.599015);
#define CTNODE_cmu_us_awb_dur_NO_4091 4105
DEF_STATIC_CONST_VAL_FLOAT(val_2264,-0.247194);
#define CTNODE_cmu_us_awb_dur_NO_4106 4108
DEF_STATIC_CONST_VAL_FLOAT(val_2265,-0.517211);
#define CTNODE_cmu_us_awb_dur_NO_4105 4109
DEF_STATIC_CONST_VAL_FLOAT(val_2266,0.403353);
#define CTNODE_cmu_us_awb_dur_NO_4086 4110
DEF_STATIC_CONST_VAL_STRING(val_2267,"ey_66");
DEF_STATIC_CONST_VAL_FLOAT(val_2268,0.440107);
#define CTNODE_cmu_us_awb_dur_NO_4110 4112
DEF_STATIC_CONST_VAL_FLOAT(val_2269,0.361569);
#define CTNODE_cmu_us_awb_dur_NO_4113 4115
DEF_STATIC_CONST_VAL_FLOAT(val_2270,-0.245408);
#define CTNODE_cmu_us_awb_dur_NO_4118 4120
DEF_STATIC_CONST_VAL_FLOAT(val_2271,0.266434);
#define CTNODE_cmu_us_awb_dur_NO_4120 4122
DEF_STATIC_CONST_VAL_FLOAT(val_2272,0.229129);
#define CTNODE_cmu_us_awb_dur_NO_4123 4125
DEF_STATIC_CONST_VAL_FLOAT(val_2273,0.313560);
#define CTNODE_cmu_us_awb_dur_NO_4126 4128
DEF_STATIC_CONST_VAL_FLOAT(val_2274,-0.186914);
#define CTNODE_cmu_us_awb_dur_NO_4128 4130
DEF_STATIC_CONST_VAL_FLOAT(val_2275,-0.064907);
#define CTNODE_cmu_us_awb_dur_NO_4125 4131
DEF_STATIC_CONST_VAL_FLOAT(val_2276,-0.089924);
#define CTNODE_cmu_us_awb_dur_NO_4131 4133
DEF_STATIC_CONST_VAL_FLOAT(val_2277,-0.309200);
#define CTNODE_cmu_us_awb_dur_NO_4122 4134
DEF_STATIC_CONST_VAL_FLOAT(val_2278,-0.265857);
#define CTNODE_cmu_us_awb_dur_NO_4117 4135
DEF_STATIC_CONST_VAL_FLOAT(val_2279,-0.322585);
#define CTNODE_cmu_us_awb_dur_NO_4116 4136
DEF_STATIC_CONST_VAL_FLOAT(val_2280,-0.367660);
#define CTNODE_cmu_us_awb_dur_NO_4115 4137
DEF_STATIC_CONST_VAL_FLOAT(val_2281,0.369795);
#define CTNODE_cmu_us_awb_dur_NO_4112 4138
DEF_STATIC_CONST_VAL_FLOAT(val_2282,0.278657);
#define CTNODE_cmu_us_awb_dur_NO_4138 4140
DEF_STATIC_CONST_VAL_FLOAT(val_2283,-0.595350);
#define CTNODE_cmu_us_awb_dur_NO_4141 4143
DEF_STATIC_CONST_VAL_FLOAT(val_2284,-0.386759);
#define CTNODE_cmu_us_awb_dur_NO_4145 4147
DEF_STATIC_CONST_VAL_FLOAT(val_2285,-0.197678);
#define CTNODE_cmu_us_awb_dur_NO_4144 4148
DEF_STATIC_CONST_VAL_FLOAT(val_2286,-0.004464);
#define CTNODE_cmu_us_awb_dur_NO_4143 4149
DEF_STATIC_CONST_VAL_FLOAT(val_2287,-0.190635);
#define CTNODE_cmu_us_awb_dur_NO_4149 4151
DEF_STATIC_CONST_VAL_FLOAT(val_2288,-0.722621);
#define CTNODE_cmu_us_awb_dur_NO_4151 4153
DEF_STATIC_CONST_VAL_FLOAT(val_2289,-0.355893);
#define CTNODE_cmu_us_awb_dur_NO_4140 4154
DEF_STATIC_CONST_VAL_FLOAT(val_2290,-0.352006);
#define CTNODE_cmu_us_awb_dur_NO_4156 4158
DEF_STATIC_CONST_VAL_FLOAT(val_2291,-0.163837);
#define CTNODE_cmu_us_awb_dur_NO_4159 4161
DEF_STATIC_CONST_VAL_FLOAT(val_2292,0.034881);
#define CTNODE_cmu_us_awb_dur_NO_4158 4162
DEF_STATIC_CONST_VAL_FLOAT(val_2293,-0.253112);
#define CTNODE_cmu_us_awb_dur_NO_4155 4163
DEF_STATIC_CONST_VAL_FLOAT(val_2294,-0.196106);
#define CTNODE_cmu_us_awb_dur_NO_4163 4165
DEF_STATIC_CONST_VAL_FLOAT(val_2295,-0.574386);
#define CTNODE_cmu_us_awb_dur_NO_4154 4166
#define CTNODE_cmu_us_awb_dur_NO_4167 4169
DEF_STATIC_CONST_VAL_FLOAT(val_2296,-0.550115);
#define CTNODE_cmu_us_awb_dur_NO_4166 4170
DEF_STATIC_CONST_VAL_FLOAT(val_2297,-0.338210);
#define CTNODE_cmu_us_awb_dur_NO_4172 4174
DEF_STATIC_CONST_VAL_FLOAT(val_2298,-0.114042);
#define CTNODE_cmu_us_awb_dur_NO_4171 4175
DEF_STATIC_CONST_VAL_FLOAT(val_2299,-0.114433);
#define CTNODE_cmu_us_awb_dur_NO_4176 4178
DEF_STATIC_CONST_VAL_FLOAT(val_2300,-0.298541);
#define CTNODE_cmu_us_awb_dur_NO_4175 4179
DEF_STATIC_CONST_VAL_FLOAT(val_2301,-0.180710);
#define CTNODE_cmu_us_awb_dur_NO_4181 4183
DEF_STATIC_CONST_VAL_FLOAT(val_2302,-0.298212);
#define CTNODE_cmu_us_awb_dur_NO_4180 4184
DEF_STATIC_CONST_VAL_FLOAT(val_2303,0.081493);
#define CTNODE_cmu_us_awb_dur_NO_4179 4185
DEF_STATIC_CONST_VAL_FLOAT(val_2304,0.161631);
#define CTNODE_cmu_us_awb_dur_NO_4186 4188
DEF_STATIC_CONST_VAL_FLOAT(val_2305,-0.198587);
#define CTNODE_cmu_us_awb_dur_NO_4185 4189
DEF_STATIC_CONST_VAL_FLOAT(val_2306,0.492718);
#define CTNODE_cmu_us_awb_dur_NO_4189 4191
DEF_STATIC_CONST_VAL_FLOAT(val_2307,0.108305);
#define CTNODE_cmu_us_awb_dur_NO_4170 4192
DEF_STATIC_CONST_VAL_FLOAT(val_2308,-0.100359);
#define CTNODE_cmu_us_awb_dur_NO_4193 4195
DEF_STATIC_CONST_VAL_FLOAT(val_2309,0.055011);
#define CTNODE_cmu_us_awb_dur_NO_4192 4196
DEF_STATIC_CONST_VAL_FLOAT(val_2310,-0.495716);
#define CTNODE_cmu_us_awb_dur_NO_4197 4199
DEF_STATIC_CONST_VAL_FLOAT(val_2311,-0.137825);
#define CTNODE_cmu_us_awb_dur_NO_4196 4200
DEF_STATIC_CONST_VAL_FLOAT(val_2312,0.149010);
#define CTNODE_cmu_us_awb_dur_NO_4200 4202
DEF_STATIC_CONST_VAL_FLOAT(val_2313,-0.437496);
#define CTNODE_cmu_us_awb_dur_NO_4203 4205
DEF_STATIC_CONST_VAL_FLOAT(val_2314,-0.257872);
#define CTNODE_cmu_us_awb_dur_NO_4202 4206
DEF_STATIC_CONST_VAL_FLOAT(val_2315,-0.045934);
#define CTNODE_cmu_us_awb_dur_NO_4206 4208
DEF_STATIC_CONST_VAL_FLOAT(val_2316,-0.329580);
#define CTNODE_cmu_us_awb_dur_NO_3769 4209
DEF_STATIC_CONST_VAL_FLOAT(val_2317,-1.068560);
#define CTNODE_cmu_us_awb_dur_NO_4210 4212
DEF_STATIC_CONST_VAL_FLOAT(val_2318,8.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_2319,-0.233689);
#define CTNODE_cmu_us_awb_dur_NO_4213 4215
DEF_STATIC_CONST_VAL_FLOAT(val_2320,0.343915);
#define CTNODE_cmu_us_awb_dur_NO_4212 4216
DEF_STATIC_CONST_VAL_FLOAT(val_2321,0.041157);
#define CTNODE_cmu_us_awb_dur_NO_4217 4219
DEF_STATIC_CONST_VAL_FLOAT(val_2322,-0.472634);
#define CTNODE_cmu_us_awb_dur_NO_4216 4220
DEF_STATIC_CONST_VAL_FLOAT(val_2323,-0.179498);
#define CTNODE_cmu_us_awb_dur_NO_4220 4222
DEF_STATIC_CONST_VAL_FLOAT(val_2324,-0.758784);
#define CTNODE_cmu_us_awb_dur_NO_4209 4223
DEF_STATIC_CONST_VAL_FLOAT(val_2325,-0.261210);
#define CTNODE_cmu_us_awb_dur_NO_4225 4227
DEF_STATIC_CONST_VAL_FLOAT(val_2326,-0.391041);
#define CTNODE_cmu_us_awb_dur_NO_4227 4229
DEF_STATIC_CONST_VAL_FLOAT(val_2327,-0.537627);
#define CTNODE_cmu_us_awb_dur_NO_4229 4231
DEF_STATIC_CONST_VAL_FLOAT(val_2328,-0.720979);
#define CTNODE_cmu_us_awb_dur_NO_4231 4233
DEF_STATIC_CONST_VAL_FLOAT(val_2329,-0.639293);
#define CTNODE_cmu_us_awb_dur_NO_4224 4234
DEF_STATIC_CONST_VAL_FLOAT(val_2330,0.221755);
#define CTNODE_cmu_us_awb_dur_NO_4234 4236
DEF_STATIC_CONST_VAL_FLOAT(val_2331,-0.284619);
#define CTNODE_cmu_us_awb_dur_NO_4223 4237
DEF_STATIC_CONST_VAL_FLOAT(val_2332,-0.211269);
#define CTNODE_cmu_us_awb_dur_NO_4238 4240
DEF_STATIC_CONST_VAL_FLOAT(val_2333,-0.565596);
#define CTNODE_cmu_us_awb_dur_NO_4240 4242
DEF_STATIC_CONST_VAL_FLOAT(val_2334,-0.409154);
#define CTNODE_cmu_us_awb_dur_NO_4237 4243
DEF_STATIC_CONST_VAL_FLOAT(val_2335,0.291847);
#define CTNODE_cmu_us_awb_dur_NO_4245 4247
DEF_STATIC_CONST_VAL_FLOAT(val_2336,-0.345624);
#define CTNODE_cmu_us_awb_dur_NO_4244 4248
DEF_STATIC_CONST_VAL_FLOAT(val_2337,-0.509295);
#define CTNODE_cmu_us_awb_dur_NO_4248 4250
DEF_STATIC_CONST_VAL_FLOAT(val_2338,-1.040700);
#define CTNODE_cmu_us_awb_dur_NO_4243 4251
DEF_STATIC_CONST_VAL_FLOAT(val_2339,1.072220);
#define CTNODE_cmu_us_awb_dur_NO_4252 4254
DEF_STATIC_CONST_VAL_FLOAT(val_2340,-0.353677);
#define CTNODE_cmu_us_awb_dur_NO_4257 4259
DEF_STATIC_CONST_VAL_FLOAT(val_2341,-0.536250);
#define CTNODE_cmu_us_awb_dur_NO_4256 4260
DEF_STATIC_CONST_VAL_FLOAT(val_2342,9.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_2343,-0.278439);
#define CTNODE_cmu_us_awb_dur_NO_4260 4262
DEF_STATIC_CONST_VAL_FLOAT(val_2344,-0.167563);
#define CTNODE_cmu_us_awb_dur_NO_4255 4263
DEF_STATIC_CONST_VAL_FLOAT(val_2345,-0.245915);
#define CTNODE_cmu_us_awb_dur_NO_4263 4265
DEF_STATIC_CONST_VAL_FLOAT(val_2346,-0.037656);
#define CTNODE_cmu_us_awb_dur_NO_4254 4266
DEF_STATIC_CONST_VAL_FLOAT(val_2347,-0.601613);
#define CTNODE_cmu_us_awb_dur_NO_4267 4269
DEF_STATIC_CONST_VAL_FLOAT(val_2348,-0.262348);
#define CTNODE_cmu_us_awb_dur_NO_4266 4270
DEF_STATIC_CONST_VAL_FLOAT(val_2349,-0.110537);
#define CTNODE_cmu_us_awb_dur_NO_4272 4274
DEF_STATIC_CONST_VAL_FLOAT(val_2350,-0.311591);
#define CTNODE_cmu_us_awb_dur_NO_4271 4275
DEF_STATIC_CONST_VAL_FLOAT(val_2351,1.581960);
#define CTNODE_cmu_us_awb_dur_NO_4270 4276
DEF_STATIC_CONST_VAL_FLOAT(val_2352,0.551493);
#define CTNODE_cmu_us_awb_dur_NO_4277 4279
DEF_STATIC_CONST_VAL_FLOAT(val_2353,-0.160737);
#define CTNODE_cmu_us_awb_dur_NO_4280 4282
DEF_STATIC_CONST_VAL_FLOAT(val_2354,0.626298);
#define CTNODE_cmu_us_awb_dur_NO_4282 4284
DEF_STATIC_CONST_VAL_FLOAT(val_2355,0.131470);
#define CTNODE_cmu_us_awb_dur_NO_4279 4285
DEF_STATIC_CONST_VAL_FLOAT(val_2356,-0.449963);
#define CTNODE_cmu_us_awb_dur_NO_4287 4289
DEF_STATIC_CONST_VAL_FLOAT(val_2357,-0.060544);
#define CTNODE_cmu_us_awb_dur_NO_4286 4290
DEF_STATIC_CONST_VAL_FLOAT(val_2358,-0.129590);
#define CTNODE_cmu_us_awb_dur_NO_4290 4292
DEF_STATIC_CONST_VAL_FLOAT(val_2359,0.482188);
#define CTNODE_cmu_us_awb_dur_NO_4285 4293
DEF_STATIC_CONST_VAL_FLOAT(val_2360,0.035755);
#define CTNODE_cmu_us_awb_dur_NO_4293 4295
DEF_STATIC_CONST_VAL_FLOAT(val_2361,-0.480335);
#define CTNODE_cmu_us_awb_dur_NO_4296 4298
DEF_STATIC_CONST_VAL_FLOAT(val_2362,-0.638255);
#define CTNODE_cmu_us_awb_dur_NO_4295 4299
DEF_STATIC_CONST_VAL_FLOAT(val_2363,0.129558);
#define CTNODE_cmu_us_awb_dur_NO_4300 4302
DEF_STATIC_CONST_VAL_FLOAT(val_2364,-0.344964);
#define CTNODE_cmu_us_awb_dur_NO_4299 4303
DEF_STATIC_CONST_VAL_FLOAT(val_2365,6.100000);
DEF_STATIC_CONST_VAL_FLOAT(val_2366,-0.257122);
#define CTNODE_cmu_us_awb_dur_NO_4303 4305
DEF_STATIC_CONST_VAL_FLOAT(val_2367,-0.478571);
#define CTNODE_cmu_us_awb_dur_NO_4305 4307
DEF_STATIC_CONST_VAL_FLOAT(val_2368,-0.611889);
#define CTNODE_cmu_us_awb_dur_NO_4276 4308
DEF_STATIC_CONST_VAL_FLOAT(val_2369,-0.661291);
#define CTNODE_cmu_us_awb_dur_NO_4309 4311
DEF_STATIC_CONST_VAL_FLOAT(val_2370,0.348036);
#define CTNODE_cmu_us_awb_dur_NO_4312 4314
DEF_STATIC_CONST_VAL_FLOAT(val_2371,-0.106174);
#define CTNODE_cmu_us_awb_dur_NO_4311 4315
DEF_STATIC_CONST_VAL_FLOAT(val_2372,-0.446907);
#define CTNODE_cmu_us_awb_dur_NO_4315 4317
DEF_STATIC_CONST_VAL_FLOAT(val_2373,-0.038006);
#define CTNODE_cmu_us_awb_dur_NO_4308 4318
DEF_STATIC_CONST_VAL_FLOAT(val_2374,1.124270);
#define CTNODE_cmu_us_awb_dur_NO_4320 4322
DEF_STATIC_CONST_VAL_FLOAT(val_2375,0.565318);
#define CTNODE_cmu_us_awb_dur_NO_4319 4323
DEF_STATIC_CONST_VAL_FLOAT(val_2376,0.312421);
#define CTNODE_cmu_us_awb_dur_NO_4323 4325
DEF_STATIC_CONST_VAL_FLOAT(val_2377,-0.200362);
#define CTNODE_cmu_us_awb_dur_NO_4318 4326
DEF_STATIC_CONST_VAL_FLOAT(val_2378,0.691751);
#define CTNODE_cmu_us_awb_dur_NO_4329 4331
DEF_STATIC_CONST_VAL_FLOAT(val_2379,1.105490);
#define CTNODE_cmu_us_awb_dur_NO_4328 4332
DEF_STATIC_CONST_VAL_FLOAT(val_2380,-0.299594);
#define CTNODE_cmu_us_awb_dur_NO_4327 4333
DEF_STATIC_CONST_VAL_FLOAT(val_2381,0.704255);
#define CTNODE_cmu_us_awb_dur_NO_4333 4335
DEF_STATIC_CONST_VAL_FLOAT(val_2382,-0.612923);
#define CTNODE_cmu_us_awb_dur_NO_4336 4338
DEF_STATIC_CONST_VAL_FLOAT(val_2383,-0.082452);
#define CTNODE_cmu_us_awb_dur_NO_4335 4339
DEF_STATIC_CONST_VAL_STRING(val_2384,"ow_128");
DEF_STATIC_CONST_VAL_FLOAT(val_2385,-0.156915);
#define CTNODE_cmu_us_awb_dur_NO_4341 4343
DEF_STATIC_CONST_VAL_FLOAT(val_2386,0.848564);
#define CTNODE_cmu_us_awb_dur_NO_4343 4345
DEF_STATIC_CONST_VAL_FLOAT(val_2387,0.422890);
#define CTNODE_cmu_us_awb_dur_NO_4347 4349
DEF_STATIC_CONST_VAL_FLOAT(val_2388,0.786385);
#define CTNODE_cmu_us_awb_dur_NO_4349 4351
DEF_STATIC_CONST_VAL_FLOAT(val_2389,0.534719);
#define CTNODE_cmu_us_awb_dur_NO_4346 4352
DEF_STATIC_CONST_VAL_FLOAT(val_2390,0.217386);
#define CTNODE_cmu_us_awb_dur_NO_4345 4353
DEF_STATIC_CONST_VAL_FLOAT(val_2391,0.559553);
#define CTNODE_cmu_us_awb_dur_NO_4353 4355
DEF_STATIC_CONST_VAL_FLOAT(val_2392,0.404483);
#define CTNODE_cmu_us_awb_dur_NO_4355 4357
DEF_STATIC_CONST_VAL_FLOAT(val_2393,-0.145798);
#define CTNODE_cmu_us_awb_dur_NO_4357 4359
DEF_STATIC_CONST_VAL_FLOAT(val_2394,0.164794);
#define CTNODE_cmu_us_awb_dur_NO_4340 4360
DEF_STATIC_CONST_VAL_FLOAT(val_2395,-0.184055);
#define CTNODE_cmu_us_awb_dur_NO_4361 4363
DEF_STATIC_CONST_VAL_FLOAT(val_2396,0.082836);
#define CTNODE_cmu_us_awb_dur_NO_4360 4364
DEF_STATIC_CONST_VAL_FLOAT(val_2397,-0.345403);
#define CTNODE_cmu_us_awb_dur_NO_4339 4365
DEF_STATIC_CONST_VAL_FLOAT(val_2398,-0.236319);
#define CTNODE_cmu_us_awb_dur_NO_4366 4368
DEF_STATIC_CONST_VAL_FLOAT(val_2399,-0.455993);
#define CTNODE_cmu_us_awb_dur_NO_4365 4369
DEF_STATIC_CONST_VAL_FLOAT(val_2400,-0.061481);
#define CTNODE_cmu_us_awb_dur_NO_4372 4374
DEF_STATIC_CONST_VAL_FLOAT(val_2401,1.007210);
#define CTNODE_cmu_us_awb_dur_NO_4371 4375
DEF_STATIC_CONST_VAL_STRING(val_2402,"ao_18");
DEF_STATIC_CONST_VAL_FLOAT(val_2403,-0.460373);
#define CTNODE_cmu_us_awb_dur_NO_4375 4377
DEF_STATIC_CONST_VAL_FLOAT(val_2404,0.760303);
#define CTNODE_cmu_us_awb_dur_NO_4379 4381
DEF_STATIC_CONST_VAL_FLOAT(val_2405,-0.156082);
#define CTNODE_cmu_us_awb_dur_NO_4381 4383
DEF_STATIC_CONST_VAL_FLOAT(val_2406,0.253990);
#define CTNODE_cmu_us_awb_dur_NO_4378 4384
DEF_STATIC_CONST_VAL_FLOAT(val_2407,-0.535669);
#define CTNODE_cmu_us_awb_dur_NO_4386 4388
DEF_STATIC_CONST_VAL_FLOAT(val_2408,0.325511);
#define CTNODE_cmu_us_awb_dur_NO_4389 4391
DEF_STATIC_CONST_VAL_FLOAT(val_2409,-0.223462);
#define CTNODE_cmu_us_awb_dur_NO_4388 4392
DEF_STATIC_CONST_VAL_FLOAT(val_2410,-0.481943);
#define CTNODE_cmu_us_awb_dur_NO_4393 4395
DEF_STATIC_CONST_VAL_FLOAT(val_2411,-0.344033);
#define CTNODE_cmu_us_awb_dur_NO_4392 4396
DEF_STATIC_CONST_VAL_FLOAT(val_2412,-0.253307);
#define CTNODE_cmu_us_awb_dur_NO_4396 4398
DEF_STATIC_CONST_VAL_FLOAT(val_2413,0.043342);
#define CTNODE_cmu_us_awb_dur_NO_4399 4401
DEF_STATIC_CONST_VAL_FLOAT(val_2414,-0.197047);
#define CTNODE_cmu_us_awb_dur_NO_4401 4403
DEF_STATIC_CONST_VAL_FLOAT(val_2415,-0.441585);
#define CTNODE_cmu_us_awb_dur_NO_4398 4404
DEF_STATIC_CONST_VAL_FLOAT(val_2416,0.133232);
#define CTNODE_cmu_us_awb_dur_NO_4385 4405
DEF_STATIC_CONST_VAL_FLOAT(val_2417,0.199535);
#define CTNODE_cmu_us_awb_dur_NO_4384 4406
DEF_STATIC_CONST_VAL_FLOAT(val_2418,0.969799);
#define CTNODE_cmu_us_awb_dur_NO_4408 4410
DEF_STATIC_CONST_VAL_FLOAT(val_2419,0.376371);
#define CTNODE_cmu_us_awb_dur_NO_4410 4412
DEF_STATIC_CONST_VAL_FLOAT(val_2420,-0.088196);
#define CTNODE_cmu_us_awb_dur_NO_4407 4413
DEF_STATIC_CONST_VAL_FLOAT(val_2421,-0.315824);
#define CTNODE_cmu_us_awb_dur_NO_4413 4415
DEF_STATIC_CONST_VAL_FLOAT(val_2422,-0.377069);
#define CTNODE_cmu_us_awb_dur_NO_4415 4417
DEF_STATIC_CONST_VAL_FLOAT(val_2423,0.525455);
#define CTNODE_cmu_us_awb_dur_NO_4417 4419
DEF_STATIC_CONST_VAL_FLOAT(val_2424,-0.442024);
#define CTNODE_cmu_us_awb_dur_NO_4420 4422
DEF_STATIC_CONST_VAL_FLOAT(val_2425,-0.021014);
#define CTNODE_cmu_us_awb_dur_NO_4419 4423
DEF_STATIC_CONST_VAL_FLOAT(val_2426,0.550240);
#define CTNODE_cmu_us_awb_dur_NO_4423 4425
DEF_STATIC_CONST_VAL_FLOAT(val_2427,-0.374320);
#define CTNODE_cmu_us_awb_dur_NO_4425 4427
DEF_STATIC_CONST_VAL_FLOAT(val_2428,-0.527965);
#define CTNODE_cmu_us_awb_dur_NO_4429 4431
DEF_STATIC_CONST_VAL_FLOAT(val_2429,-0.177919);
#define CTNODE_cmu_us_awb_dur_NO_4428 4432
DEF_STATIC_CONST_VAL_FLOAT(val_2430,0.101121);
#define CTNODE_cmu_us_awb_dur_NO_4427 4433
DEF_STATIC_CONST_VAL_FLOAT(val_2431,0.038577);
#define CTNODE_cmu_us_awb_dur_NO_4434 4436
DEF_STATIC_CONST_VAL_FLOAT(val_2432,0.655416);
#define CTNODE_cmu_us_awb_dur_NO_4433 4437
DEF_STATIC_CONST_VAL_FLOAT(val_2433,0.066876);
#define CTNODE_cmu_us_awb_dur_NO_4438 4440
DEF_STATIC_CONST_VAL_FLOAT(val_2434,0.564066);
#define CTNODE_cmu_us_awb_dur_NO_4437 4441
DEF_STATIC_CONST_VAL_FLOAT(val_2435,0.262378);
#define CTNODE_cmu_us_awb_dur_NO_4443 4445
DEF_STATIC_CONST_VAL_FLOAT(val_2436,0.610431);
#define CTNODE_cmu_us_awb_dur_NO_4442 4446
DEF_STATIC_CONST_VAL_FLOAT(val_2437,0.006004);
#define CTNODE_cmu_us_awb_dur_NO_4441 4447
DEF_STATIC_CONST_VAL_FLOAT(val_2438,-0.291356);
#define CTNODE_cmu_us_awb_dur_NO_4447 4449
DEF_STATIC_CONST_VAL_FLOAT(val_2439,0.272555);
#define CTNODE_cmu_us_awb_dur_NO_4451 4453
DEF_STATIC_CONST_VAL_FLOAT(val_2440,0.561470);
#define CTNODE_cmu_us_awb_dur_NO_4450 4454
DEF_STATIC_CONST_VAL_FLOAT(val_2441,-0.006397);
#define CTNODE_cmu_us_awb_dur_NO_4449 4455
DEF_STATIC_CONST_VAL_FLOAT(val_2442,-0.519979);
#define CTNODE_cmu_us_awb_dur_NO_4458 4460
DEF_STATIC_CONST_VAL_FLOAT(val_2443,-0.391460);
#define CTNODE_cmu_us_awb_dur_NO_4460 4462
DEF_STATIC_CONST_VAL_FLOAT(val_2444,-0.067347);
#define CTNODE_cmu_us_awb_dur_NO_4462 4464
DEF_STATIC_CONST_VAL_FLOAT(val_2445,0.008008);
#define CTNODE_cmu_us_awb_dur_NO_4457 4465
DEF_STATIC_CONST_VAL_FLOAT(val_2446,0.262693);
#define CTNODE_cmu_us_awb_dur_NO_4465 4467
DEF_STATIC_CONST_VAL_FLOAT(val_2447,-0.082339);
#define CTNODE_cmu_us_awb_dur_NO_4456 4468
DEF_STATIC_CONST_VAL_FLOAT(val_2448,0.533395);
#define CTNODE_cmu_us_awb_dur_NO_4469 4471
DEF_STATIC_CONST_VAL_FLOAT(val_2449,-0.132113);
#define CTNODE_cmu_us_awb_dur_NO_4472 4474
DEF_STATIC_CONST_VAL_FLOAT(val_2450,-0.334894);
#define CTNODE_cmu_us_awb_dur_NO_4471 4475
DEF_STATIC_CONST_VAL_FLOAT(val_2451,0.149588);
#define CTNODE_cmu_us_awb_dur_NO_4477 4479
DEF_STATIC_CONST_VAL_FLOAT(val_2452,0.485886);
#define CTNODE_cmu_us_awb_dur_NO_4476 4480
DEF_STATIC_CONST_VAL_FLOAT(val_2453,0.105402);
#define CTNODE_cmu_us_awb_dur_NO_4480 4482
DEF_STATIC_CONST_VAL_FLOAT(val_2454,-0.122237);
#define CTNODE_cmu_us_awb_dur_NO_4482 4484
DEF_STATIC_CONST_VAL_FLOAT(val_2455,-0.213096);
#define CTNODE_cmu_us_awb_dur_NO_4475 4485
DEF_STATIC_CONST_VAL_FLOAT(val_2456,-0.350521);
#define CTNODE_cmu_us_awb_dur_NO_4485 4487
DEF_STATIC_CONST_VAL_FLOAT(val_2457,0.356947);
#define CTNODE_cmu_us_awb_dur_NO_4487 4489
DEF_STATIC_CONST_VAL_FLOAT(val_2458,0.022321);
#define CTNODE_cmu_us_awb_dur_NO_4468 4490
DEF_STATIC_CONST_VAL_FLOAT(val_2459,0.465475);
#define CTNODE_cmu_us_awb_dur_NO_4455 4491
DEF_STATIC_CONST_VAL_FLOAT(val_2460,-0.316227);
#define CTNODE_cmu_us_awb_dur_NO_4406 4492
DEF_STATIC_CONST_VAL_FLOAT(val_2461,-0.205503);
#define CTNODE_cmu_us_awb_dur_NO_4492 4494
DEF_STATIC_CONST_VAL_FLOAT(val_2462,-0.398408);
#define CTNODE_cmu_us_awb_dur_NO_4377 4495
DEF_STATIC_CONST_VAL_FLOAT(val_2463,0.560126);
#define CTNODE_cmu_us_awb_dur_NO_4370 4496
DEF_STATIC_CONST_VAL_FLOAT(val_2464,0.022441);
#define CTNODE_cmu_us_awb_dur_NO_4496 4498
DEF_STATIC_CONST_VAL_FLOAT(val_2465,0.184920);
#define CTNODE_cmu_us_awb_dur_NO_4498 4500
DEF_STATIC_CONST_VAL_FLOAT(val_2466,0.714148);
#define CTNODE_cmu_us_awb_dur_NO_4369 4501
DEF_STATIC_CONST_VAL_FLOAT(val_2467,-0.429792);
#define CTNODE_cmu_us_awb_dur_NO_4501 4503
DEF_STATIC_CONST_VAL_FLOAT(val_2468,-0.417134);
#define CTNODE_cmu_us_awb_dur_NO_4503 4505
DEF_STATIC_CONST_VAL_FLOAT(val_2469,-0.510309);
#define CTNODE_cmu_us_awb_dur_NO_4507 4509
DEF_STATIC_CONST_VAL_FLOAT(val_2470,-0.205982);
#define CTNODE_cmu_us_awb_dur_NO_4506 4510
DEF_STATIC_CONST_VAL_FLOAT(val_2471,0.030329);
#define CTNODE_cmu_us_awb_dur_NO_4511 4513
DEF_STATIC_CONST_VAL_FLOAT(val_2472,14.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_2473,-0.265282);
#define CTNODE_cmu_us_awb_dur_NO_4513 4515
DEF_STATIC_CONST_VAL_FLOAT(val_2474,-0.127103);
#define CTNODE_cmu_us_awb_dur_NO_4510 4516
DEF_STATIC_CONST_VAL_FLOAT(val_2475,0.184850);
#define CTNODE_cmu_us_awb_dur_NO_4505 4517
DEF_STATIC_CONST_VAL_FLOAT(val_2476,0.547686);
#define CTNODE_cmu_us_awb_dur_NO_4326 4518
DEF_STATIC_CONST_VAL_FLOAT(val_2477,0.894437);
#define CTNODE_cmu_us_awb_dur_NO_4518 4520
DEF_STATIC_CONST_VAL_FLOAT(val_2478,-0.508472);
#define CTNODE_cmu_us_awb_dur_NO_4522 4524
DEF_STATIC_CONST_VAL_FLOAT(val_2479,-0.062635);
#define CTNODE_cmu_us_awb_dur_NO_4521 4525
DEF_STATIC_CONST_VAL_FLOAT(val_2480,-0.197271);
#define CTNODE_cmu_us_awb_dur_NO_4528 4530
DEF_STATIC_CONST_VAL_FLOAT(val_2481,0.099443);
#define CTNODE_cmu_us_awb_dur_NO_4527 4531
DEF_STATIC_CONST_VAL_FLOAT(val_2482,0.418460);
#define CTNODE_cmu_us_awb_dur_NO_4526 4532
DEF_STATIC_CONST_VAL_FLOAT(val_2483,0.561689);
#define CTNODE_cmu_us_awb_dur_NO_4525 4533
DEF_STATIC_CONST_VAL_FLOAT(val_2484,-0.404801);
#define CTNODE_cmu_us_awb_dur_NO_4533 4535
DEF_STATIC_CONST_VAL_FLOAT(val_2485,0.040376);
#define CTNODE_cmu_us_awb_dur_NO_4520 4536
DEF_STATIC_CONST_VAL_FLOAT(val_2486,0.349520);
#define CTNODE_cmu_us_awb_dur_NO_4540 4542
DEF_STATIC_CONST_VAL_FLOAT(val_2487,0.327371);
#define CTNODE_cmu_us_awb_dur_NO_4542 4544
DEF_STATIC_CONST_VAL_FLOAT(val_2488,-0.087330);
#define CTNODE_cmu_us_awb_dur_NO_4539 4545
DEF_STATIC_CONST_VAL_FLOAT(val_2489,0.888087);
#define CTNODE_cmu_us_awb_dur_NO_4545 4547
DEF_STATIC_CONST_VAL_FLOAT(val_2490,0.146920);
#define CTNODE_cmu_us_awb_dur_NO_4547 4549
DEF_STATIC_CONST_VAL_FLOAT(val_2491,0.339645);
#define CTNODE_cmu_us_awb_dur_NO_4538 4550
DEF_STATIC_CONST_VAL_FLOAT(val_2492,-0.127690);
#define CTNODE_cmu_us_awb_dur_NO_4552 4554
DEF_STATIC_CONST_VAL_FLOAT(val_2493,0.291395);
#define CTNODE_cmu_us_awb_dur_NO_4551 4555
DEF_STATIC_CONST_VAL_FLOAT(val_2494,0.562055);
#define CTNODE_cmu_us_awb_dur_NO_4550 4556
DEF_STATIC_CONST_VAL_FLOAT(val_2495,-0.197735);
#define CTNODE_cmu_us_awb_dur_NO_4537 4557
DEF_STATIC_CONST_VAL_FLOAT(val_2496,1.056330);
#define CTNODE_cmu_us_awb_dur_NO_4557 4559
DEF_STATIC_CONST_VAL_FLOAT(val_2497,0.700243);
#define CTNODE_cmu_us_awb_dur_NO_4559 4561
DEF_STATIC_CONST_VAL_FLOAT(val_2498,0.683024);
#define CTNODE_cmu_us_awb_dur_NO_4562 4564
DEF_STATIC_CONST_VAL_FLOAT(val_2499,0.338819);
#define CTNODE_cmu_us_awb_dur_NO_4561 4565
DEF_STATIC_CONST_VAL_FLOAT(val_2500,-0.026639);
#define CTNODE_cmu_us_awb_dur_NO_4536 4566
DEF_STATIC_CONST_VAL_FLOAT(val_2501,-0.307288);
#define CTNODE_cmu_us_awb_dur_NO_4566 4568
DEF_STATIC_CONST_VAL_FLOAT(val_2502,-0.373726);
#define CTNODE_cmu_us_awb_dur_NO_4568 4570
DEF_STATIC_CONST_VAL_FLOAT(val_2503,0.486401);
#define CTNODE_cmu_us_awb_dur_NO_4570 4572
DEF_STATIC_CONST_VAL_FLOAT(val_2504,0.012836);
#define CTNODE_cmu_us_awb_dur_NO_4575 4577
DEF_STATIC_CONST_VAL_FLOAT(val_2505,0.105264);
#define CTNODE_cmu_us_awb_dur_NO_4578 4580
DEF_STATIC_CONST_VAL_FLOAT(val_2506,0.351538);
#define CTNODE_cmu_us_awb_dur_NO_4577 4581
DEF_STATIC_CONST_VAL_FLOAT(val_2507,0.535756);
#define CTNODE_cmu_us_awb_dur_NO_4574 4582
DEF_STATIC_CONST_VAL_FLOAT(val_2508,-0.126696);
#define CTNODE_cmu_us_awb_dur_NO_4573 4583
DEF_STATIC_CONST_VAL_FLOAT(val_2509,0.504860);
#define CTNODE_cmu_us_awb_dur_NO_4572 4584
DEF_STATIC_CONST_VAL_FLOAT(val_2510,-0.236686);
#define CTNODE_cmu_us_awb_dur_NO_4251 4585
DEF_STATIC_CONST_VAL_FLOAT(val_2511,0.582754);
#define CTNODE_cmu_us_awb_dur_NO_4587 4589
DEF_STATIC_CONST_VAL_FLOAT(val_2512,0.051846);
#define CTNODE_cmu_us_awb_dur_NO_4591 4593
DEF_STATIC_CONST_VAL_FLOAT(val_2513,0.809657);
#define CTNODE_cmu_us_awb_dur_NO_4590 4594
DEF_STATIC_CONST_VAL_FLOAT(val_2514,-0.284868);
#define CTNODE_cmu_us_awb_dur_NO_4594 4596
DEF_STATIC_CONST_VAL_FLOAT(val_2515,0.265379);
#define CTNODE_cmu_us_awb_dur_NO_4589 4597
DEF_STATIC_CONST_VAL_FLOAT(val_2516,-0.464187);
#define CTNODE_cmu_us_awb_dur_NO_4598 4600
DEF_STATIC_CONST_VAL_FLOAT(val_2517,-0.413628);
#define CTNODE_cmu_us_awb_dur_NO_4600 4602
DEF_STATIC_CONST_VAL_FLOAT(val_2518,7.800000);
DEF_STATIC_CONST_VAL_FLOAT(val_2519,-0.375172);
#define CTNODE_cmu_us_awb_dur_NO_4603 4605
DEF_STATIC_CONST_VAL_FLOAT(val_2520,-0.044266);
#define CTNODE_cmu_us_awb_dur_NO_4602 4606
DEF_STATIC_CONST_VAL_FLOAT(val_2521,0.109028);
#define CTNODE_cmu_us_awb_dur_NO_4597 4607
DEF_STATIC_CONST_VAL_FLOAT(val_2522,0.306417);
#define CTNODE_cmu_us_awb_dur_NO_4607 4609
DEF_STATIC_CONST_VAL_FLOAT(val_2523,0.355041);
#define CTNODE_cmu_us_awb_dur_NO_4611 4613
DEF_STATIC_CONST_VAL_FLOAT(val_2524,0.176011);
#define CTNODE_cmu_us_awb_dur_NO_4613 4615
DEF_STATIC_CONST_VAL_FLOAT(val_2525,-0.277893);
#define CTNODE_cmu_us_awb_dur_NO_4615 4617
DEF_STATIC_CONST_VAL_FLOAT(val_2526,0.127041);
#define CTNODE_cmu_us_awb_dur_NO_4610 4618
DEF_STATIC_CONST_VAL_FLOAT(val_2527,-0.297287);
#define CTNODE_cmu_us_awb_dur_NO_4609 4619
DEF_STATIC_CONST_VAL_FLOAT(val_2528,-0.356090);
#define CTNODE_cmu_us_awb_dur_NO_4586 4620
DEF_STATIC_CONST_VAL_FLOAT(val_2529,0.977474);
#define CTNODE_cmu_us_awb_dur_NO_4620 4622
DEF_STATIC_CONST_VAL_FLOAT(val_2530,-0.026281);
#define CTNODE_cmu_us_awb_dur_NO_4622 4624
DEF_STATIC_CONST_VAL_FLOAT(val_2531,0.382288);
#define CTNODE_cmu_us_awb_dur_NO_4585 4625
DEF_STATIC_CONST_VAL_FLOAT(val_2532,0.856926);
#define CTNODE_cmu_us_awb_dur_NO_4626 4628
DEF_STATIC_CONST_VAL_FLOAT(val_2533,-0.008797);
#define CTNODE_cmu_us_awb_dur_NO_4625 4629
DEF_STATIC_CONST_VAL_FLOAT(val_2534,0.586430);
#define CTNODE_cmu_us_awb_dur_NO_4630 4632
DEF_STATIC_CONST_VAL_FLOAT(val_2535,0.296909);
#define CTNODE_cmu_us_awb_dur_NO_4632 4634
DEF_STATIC_CONST_VAL_FLOAT(val_2536,-0.051365);
#define CTNODE_cmu_us_awb_dur_NO_4629 4635
DEF_STATIC_CONST_VAL_FLOAT(val_2537,0.036360);
#define CTNODE_cmu_us_awb_dur_NO_4639 4641
DEF_STATIC_CONST_VAL_FLOAT(val_2538,-0.191059);
#define CTNODE_cmu_us_awb_dur_NO_4638 4642
DEF_STATIC_CONST_VAL_FLOAT(val_2539,-0.299578);
#define CTNODE_cmu_us_awb_dur_NO_4637 4643
DEF_STATIC_CONST_VAL_FLOAT(val_2540,-0.034157);
#define CTNODE_cmu_us_awb_dur_NO_4645 4647
DEF_STATIC_CONST_VAL_FLOAT(val_2541,0.240652);
#define CTNODE_cmu_us_awb_dur_NO_4644 4648
DEF_STATIC_CONST_VAL_FLOAT(val_2542,-0.223968);
#define CTNODE_cmu_us_awb_dur_NO_4643 4649
DEF_STATIC_CONST_VAL_FLOAT(val_2543,0.425134);
#define CTNODE_cmu_us_awb_dur_NO_4636 4650
DEF_STATIC_CONST_VAL_FLOAT(val_2544,-0.354586);
#define CTNODE_cmu_us_awb_dur_NO_4635 4651
DEF_STATIC_CONST_VAL_STRING(val_2545,"y_196");
DEF_STATIC_CONST_VAL_FLOAT(val_2546,0.455594);
#define CTNODE_cmu_us_awb_dur_NO_4652 4654
DEF_STATIC_CONST_VAL_FLOAT(val_2547,-0.161160);
#define CTNODE_cmu_us_awb_dur_NO_4651 4655
DEF_STATIC_CONST_VAL_FLOAT(val_2548,-0.667153);
#define CTNODE_cmu_us_awb_dur_NO_4657 4659
DEF_STATIC_CONST_VAL_FLOAT(val_2549,-0.592291);
#define CTNODE_cmu_us_awb_dur_NO_4656 4660
DEF_STATIC_CONST_VAL_FLOAT(val_2550,-0.324295);
#define CTNODE_cmu_us_awb_dur_NO_4655 4661
DEF_STATIC_CONST_VAL_FLOAT(val_2551,-0.259544);
#define CTNODE_cmu_us_awb_dur_NO_4662 4664
DEF_STATIC_CONST_VAL_FLOAT(val_2552,0.529933);
#define CTNODE_cmu_us_awb_dur_NO_4664 4666
DEF_STATIC_CONST_VAL_FLOAT(val_2553,0.128063);
#define CTNODE_cmu_us_awb_dur_NO_4661 4667
DEF_STATIC_CONST_VAL_STRING(val_2554,"ay_33");
DEF_STATIC_CONST_VAL_FLOAT(val_2555,0.128299);
#define CTNODE_cmu_us_awb_dur_NO_4667 4669
DEF_STATIC_CONST_VAL_FLOAT(val_2556,-0.435573);
#define CTNODE_cmu_us_awb_dur_NO_4670 4672
DEF_STATIC_CONST_VAL_FLOAT(val_2557,-0.059769);
#define CTNODE_cmu_us_awb_dur_NO_4673 4675
DEF_STATIC_CONST_VAL_FLOAT(val_2558,0.419813);
#define CTNODE_cmu_us_awb_dur_NO_4672 4676
DEF_STATIC_CONST_VAL_FLOAT(val_2559,0.144123);
#define CTNODE_cmu_us_awb_dur_NO_4676 4678
DEF_STATIC_CONST_VAL_FLOAT(val_2560,-0.397493);
#define CTNODE_cmu_us_awb_dur_NO_4679 4681
DEF_STATIC_CONST_VAL_FLOAT(val_2561,-0.017172);
#define CTNODE_cmu_us_awb_dur_NO_4678 4682
DEF_STATIC_CONST_VAL_FLOAT(val_2562,-0.493238);
#define CTNODE_cmu_us_awb_dur_NO_4669 4683
DEF_STATIC_CONST_VAL_FLOAT(val_2563,-0.679840);
#define CTNODE_cmu_us_awb_dur_NO_4684 4686
DEF_STATIC_CONST_VAL_FLOAT(val_2564,-0.584204);
#define CTNODE_cmu_us_awb_dur_NO_4686 4688
DEF_STATIC_CONST_VAL_FLOAT(val_2565,-0.415961);
#define CTNODE_cmu_us_awb_dur_NO_4689 4691
DEF_STATIC_CONST_VAL_FLOAT(val_2566,-0.392119);
#define CTNODE_cmu_us_awb_dur_NO_4691 4693
DEF_STATIC_CONST_VAL_FLOAT(val_2567,0.137797);
#define CTNODE_cmu_us_awb_dur_NO_4693 4695
DEF_STATIC_CONST_VAL_FLOAT(val_2568,-0.248219);
#define CTNODE_cmu_us_awb_dur_NO_4688 4696
DEF_STATIC_CONST_VAL_FLOAT(val_2569,-0.444222);
#define CTNODE_cmu_us_awb_dur_NO_4697 4699
DEF_STATIC_CONST_VAL_FLOAT(val_2570,-0.350588);
#define CTNODE_cmu_us_awb_dur_NO_4699 4701
DEF_STATIC_CONST_VAL_FLOAT(val_2571,-0.119304);
#define CTNODE_cmu_us_awb_dur_NO_4696 4702
DEF_STATIC_CONST_VAL_FLOAT(val_2572,-0.452097);
#define CTNODE_cmu_us_awb_dur_NO_4702 4704
DEF_STATIC_CONST_VAL_FLOAT(val_2573,-0.583857);
#define CTNODE_cmu_us_awb_dur_NO_4683 4705
DEF_STATIC_CONST_VAL_FLOAT(val_2574,0.310709);
#define CTNODE_cmu_us_awb_dur_NO_4705 4707
DEF_STATIC_CONST_VAL_FLOAT(val_2575,-0.268134);
#define CTNODE_cmu_us_awb_dur_NO_0004 4708
DEF_STATIC_CONST_VAL_FLOAT(val_2576,2.616460);
#define CTNODE_cmu_us_awb_dur_NO_4710 4712
DEF_STATIC_CONST_VAL_FLOAT(val_2577,1.901070);
#define CTNODE_cmu_us_awb_dur_NO_4709 4713
DEF_STATIC_CONST_VAL_FLOAT(val_2578,1.147670);
#define CTNODE_cmu_us_awb_dur_NO_4716 4718
DEF_STATIC_CONST_VAL_FLOAT(val_2579,0.326194);
#define CTNODE_cmu_us_awb_dur_NO_4715 4719
DEF_STATIC_CONST_VAL_FLOAT(val_2580,1.890340);
#define CTNODE_cmu_us_awb_dur_NO_4720 4722
DEF_STATIC_CONST_VAL_FLOAT(val_2581,1.591680);
#define CTNODE_cmu_us_awb_dur_NO_4719 4723
DEF_STATIC_CONST_VAL_FLOAT(val_2582,0.862901);
#define CTNODE_cmu_us_awb_dur_NO_4714 4724
DEF_STATIC_CONST_VAL_FLOAT(val_2583,1.578540);
#define CTNODE_cmu_us_awb_dur_NO_4724 4726
DEF_STATIC_CONST_VAL_FLOAT(val_2584,1.083800);
#define CTNODE_cmu_us_awb_dur_NO_4728 4730
DEF_STATIC_CONST_VAL_FLOAT(val_2585,0.507217);
#define CTNODE_cmu_us_awb_dur_NO_4731 4733
DEF_STATIC_CONST_VAL_FLOAT(val_2586,1.023680);
#define CTNODE_cmu_us_awb_dur_NO_4730 4734
DEF_STATIC_CONST_VAL_FLOAT(val_2587,0.394742);
#define CTNODE_cmu_us_awb_dur_NO_4727 4735
DEF_STATIC_CONST_VAL_FLOAT(val_2588,1.114560);
#define CTNODE_cmu_us_awb_dur_NO_4735 4737
DEF_STATIC_CONST_VAL_FLOAT(val_2589,10.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_2590,-0.131616);
#define CTNODE_cmu_us_awb_dur_NO_4738 4740
DEF_STATIC_CONST_VAL_FLOAT(val_2591,-0.397465);
#define CTNODE_cmu_us_awb_dur_NO_4737 4741
DEF_STATIC_CONST_VAL_FLOAT(val_2592,-0.037522);
#define CTNODE_cmu_us_awb_dur_NO_4741 4743
DEF_STATIC_CONST_VAL_FLOAT(val_2593,0.901840);
#define CTNODE_cmu_us_awb_dur_NO_4744 4746
DEF_STATIC_CONST_VAL_FLOAT(val_2594,0.462891);
#define CTNODE_cmu_us_awb_dur_NO_4743 4747
DEF_STATIC_CONST_VAL_FLOAT(val_2595,-0.016954);
#define CTNODE_cmu_us_awb_dur_NO_4747 4749
DEF_STATIC_CONST_VAL_FLOAT(val_2596,0.428145);
#define CTNODE_cmu_us_awb_dur_NO_4749 4751
DEF_STATIC_CONST_VAL_FLOAT(val_2597,0.532995);
#define CTNODE_cmu_us_awb_dur_NO_4726 4752
DEF_STATIC_CONST_VAL_FLOAT(val_2598,0.773177);
#define CTNODE_cmu_us_awb_dur_NO_4753 4755
DEF_STATIC_CONST_VAL_FLOAT(val_2599,1.607180);
#define CTNODE_cmu_us_awb_dur_NO_4752 4756
DEF_STATIC_CONST_VAL_FLOAT(val_2600,0.252461);
#define CTNODE_cmu_us_awb_dur_NO_4713 4757
DEF_STATIC_CONST_VAL_FLOAT(val_2601,0.614179);
#define CTNODE_cmu_us_awb_dur_NO_4757 4759
DEF_STATIC_CONST_VAL_FLOAT(val_2602,1.255590);
#define CTNODE_cmu_us_awb_dur_NO_4759 4761
DEF_STATIC_CONST_VAL_FLOAT(val_2603,2.101670);
#define CTNODE_cmu_us_awb_dur_NO_4708 4762
DEF_STATIC_CONST_VAL_FLOAT(val_2604,2.978120);
#define CTNODE_cmu_us_awb_dur_NO_4762 4764
DEF_STATIC_CONST_VAL_FLOAT(val_2605,2.187140);
#define CTNODE_cmu_us_awb_dur_NO_4765 4767
DEF_STATIC_CONST_VAL_FLOAT(val_2606,1.652290);
#define CTNODE_cmu_us_awb_dur_NO_4767 4769
DEF_STATIC_CONST_VAL_FLOAT(val_2607,0.742609);
#define CTNODE_cmu_us_awb_dur_NO_4764 4770
DEF_STATIC_CONST_VAL_FLOAT(val_2608,-0.320208);
#define CTNODE_cmu_us_awb_dur_NO_4773 4775
DEF_STATIC_CONST_VAL_FLOAT(val_2609,0.755053);
#define CTNODE_cmu_us_awb_dur_NO_4775 4777
DEF_STATIC_CONST_VAL_FLOAT(val_2610,1.735480);
#define CTNODE_cmu_us_awb_dur_NO_4772 4778
DEF_STATIC_CONST_VAL_FLOAT(val_2611,2.576530);
#define CTNODE_cmu_us_awb_dur_NO_4771 4779
DEF_STATIC_CONST_VAL_FLOAT(val_2612,11.400000);
DEF_STATIC_CONST_VAL_FLOAT(val_2613,-0.842487);
#define CTNODE_cmu_us_awb_dur_NO_4780 4782
DEF_STATIC_CONST_VAL_FLOAT(val_2614,-0.998436);
#define CTNODE_cmu_us_awb_dur_NO_4779 4783
DEF_STATIC_CONST_VAL_FLOAT(val_2615,1.223500);
#define CTNODE_cmu_us_awb_dur_NO_4783 4785
DEF_STATIC_CONST_VAL_FLOAT(val_2616,0.408771);
#define CTNODE_cmu_us_awb_dur_NO_4786 4788
DEF_STATIC_CONST_VAL_FLOAT(val_2617,1.053160);
#define CTNODE_cmu_us_awb_dur_NO_4785 4789
DEF_STATIC_CONST_VAL_FLOAT(val_2618,0.428814);
#define CTNODE_cmu_us_awb_dur_NO_4790 4792
DEF_STATIC_CONST_VAL_FLOAT(val_2619,0.898858);
#define CTNODE_cmu_us_awb_dur_NO_4789 4793
DEF_STATIC_CONST_VAL_FLOAT(val_2620,-0.213892);
#define CTNODE_cmu_us_awb_dur_NO_4794 4796
DEF_STATIC_CONST_VAL_FLOAT(val_2621,1.257310);
#define CTNODE_cmu_us_awb_dur_NO_4793 4797
DEF_STATIC_CONST_VAL_FLOAT(val_2622,-0.014776);
#define CTNODE_cmu_us_awb_dur_NO_4798 4800
DEF_STATIC_CONST_VAL_FLOAT(val_2623,1.139090);
#define CTNODE_cmu_us_awb_dur_NO_4797 4801
DEF_STATIC_CONST_VAL_FLOAT(val_2624,-0.666580);
#define CTNODE_cmu_us_awb_dur_NO_4803 4805
DEF_STATIC_CONST_VAL_FLOAT(val_2625,-0.830093);
#define CTNODE_cmu_us_awb_dur_NO_4802 4806
DEF_STATIC_CONST_VAL_FLOAT(val_2626,-0.352105);
#define CTNODE_cmu_us_awb_dur_NO_4801 4807
DEF_STATIC_CONST_VAL_FLOAT(val_2627,0.159123);
#define CTNODE_cmu_us_awb_dur_NO_4808 4810
DEF_STATIC_CONST_VAL_FLOAT(val_2628,0.833721);
#define CTNODE_cmu_us_awb_dur_NO_4807 4811
DEF_STATIC_CONST_VAL_FLOAT(val_2629,-0.090878);
#define CTNODE_cmu_us_awb_dur_NO_4813 4815
DEF_STATIC_CONST_VAL_FLOAT(val_2630,-0.619881);
#define CTNODE_cmu_us_awb_dur_NO_4815 4817
DEF_STATIC_CONST_VAL_FLOAT(val_2631,-0.503630);
#define CTNODE_cmu_us_awb_dur_NO_4812 4818
DEF_STATIC_CONST_VAL_FLOAT(val_2632,0.486581);
#define CTNODE_cmu_us_awb_dur_NO_4818 4820
DEF_STATIC_CONST_VAL_STRING(val_2633,"jh");
DEF_STATIC_CONST_VAL_FLOAT(val_2634,0.552084);
#define CTNODE_cmu_us_awb_dur_NO_4820 4822
DEF_STATIC_CONST_VAL_FLOAT(val_2635,-0.539544);
#define CTNODE_cmu_us_awb_dur_NO_4822 4824
DEF_STATIC_CONST_VAL_FLOAT(val_2636,0.429294);
#define CTNODE_cmu_us_awb_dur_NO_4824 4826
DEF_STATIC_CONST_VAL_FLOAT(val_2637,0.573245);
#define CTNODE_cmu_us_awb_dur_NO_4827 4829
DEF_STATIC_CONST_VAL_FLOAT(val_2638,0.119795);
#define CTNODE_cmu_us_awb_dur_NO_4826 4830
DEF_STATIC_CONST_VAL_FLOAT(val_2639,-0.466125);
#define CTNODE_cmu_us_awb_dur_NO_4830 4832
DEF_STATIC_CONST_VAL_FLOAT(val_2640,0.349983);
#define CTNODE_cmu_us_awb_dur_NO_4832 4834
DEF_STATIC_CONST_VAL_FLOAT(val_2641,0.250245);
#define CTNODE_cmu_us_awb_dur_NO_4834 4836
DEF_STATIC_CONST_VAL_FLOAT(val_2642,-0.440293);
#define CTNODE_cmu_us_awb_dur_NO_4836 4838
DEF_STATIC_CONST_VAL_FLOAT(val_2643,6.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_2644,-0.111012);
#define CTNODE_cmu_us_awb_dur_NO_4839 4841
DEF_STATIC_CONST_VAL_FLOAT(val_2645,-0.396286);
#define CTNODE_cmu_us_awb_dur_NO_4838 4842
DEF_STATIC_CONST_VAL_FLOAT(val_2646,-0.336669);
#define CTNODE_cmu_us_awb_dur_NO_4842 4844
DEF_STATIC_CONST_VAL_FLOAT(val_2647,-0.225164);
#define CTNODE_cmu_us_awb_dur_NO_4844 4846
DEF_STATIC_CONST_VAL_FLOAT(val_2648,11.200000);
DEF_STATIC_CONST_VAL_FLOAT(val_2649,0.164713);
#define CTNODE_cmu_us_awb_dur_NO_4851 4853
DEF_STATIC_CONST_VAL_FLOAT(val_2650,0.163843);
#define CTNODE_cmu_us_awb_dur_NO_4850 4854
DEF_STATIC_CONST_VAL_FLOAT(val_2651,-0.056582);
#define CTNODE_cmu_us_awb_dur_NO_4849 4855
DEF_STATIC_CONST_VAL_FLOAT(val_2652,-0.174449);
#define CTNODE_cmu_us_awb_dur_NO_4848 4856
DEF_STATIC_CONST_VAL_FLOAT(val_2653,-0.389409);
#define CTNODE_cmu_us_awb_dur_NO_4847 4857
DEF_STATIC_CONST_VAL_FLOAT(val_2654,-0.155742);
#define CTNODE_cmu_us_awb_dur_NO_4857 4859
DEF_STATIC_CONST_VAL_FLOAT(val_2655,0.650900);
#define CTNODE_cmu_us_awb_dur_NO_4859 4861
DEF_STATIC_CONST_VAL_FLOAT(val_2656,15.500000);
DEF_STATIC_CONST_VAL_FLOAT(val_2657,0.082167);
#define CTNODE_cmu_us_awb_dur_NO_4862 4864
DEF_STATIC_CONST_VAL_FLOAT(val_2658,0.416825);
#define CTNODE_cmu_us_awb_dur_NO_4861 4865
DEF_STATIC_CONST_VAL_FLOAT(val_2659,-0.167495);
#define CTNODE_cmu_us_awb_dur_NO_4846 4866
DEF_STATIC_CONST_VAL_FLOAT(val_2660,-0.275567);
#define CTNODE_cmu_us_awb_dur_NO_4811 4867
DEF_STATIC_CONST_VAL_FLOAT(val_2661,-0.047740);
#define CTNODE_cmu_us_awb_dur_NO_4870 4872
DEF_STATIC_CONST_VAL_FLOAT(val_2662,0.331308);
#define CTNODE_cmu_us_awb_dur_NO_4869 4873
DEF_STATIC_CONST_VAL_FLOAT(val_2663,-0.304919);
#define CTNODE_cmu_us_awb_dur_NO_4868 4874
DEF_STATIC_CONST_VAL_FLOAT(val_2664,-0.074454);
#define CTNODE_cmu_us_awb_dur_NO_4875 4877
DEF_STATIC_CONST_VAL_FLOAT(val_2665,-0.567005);
#define CTNODE_cmu_us_awb_dur_NO_4879 4881
DEF_STATIC_CONST_VAL_FLOAT(val_2666,-0.397856);
#define CTNODE_cmu_us_awb_dur_NO_4878 4882
DEF_STATIC_CONST_VAL_FLOAT(val_2667,-0.669988);
#define CTNODE_cmu_us_awb_dur_NO_4877 4883
DEF_STATIC_CONST_VAL_FLOAT(val_2668,-0.539627);
#define CTNODE_cmu_us_awb_dur_NO_4883 4885
DEF_STATIC_CONST_VAL_FLOAT(val_2669,-0.472820);
#define CTNODE_cmu_us_awb_dur_NO_4885 4887
DEF_STATIC_CONST_VAL_FLOAT(val_2670,13.000000);
DEF_STATIC_CONST_VAL_FLOAT(val_2671,-0.371383);
#define CTNODE_cmu_us_awb_dur_NO_4887 4889
DEF_STATIC_CONST_VAL_FLOAT(val_2672,-0.171012);
#define CTNODE_cmu_us_awb_dur_NO_4874 4890
DEF_STATIC_CONST_VAL_FLOAT(val_2673,-0.425482);
#define CTNODE_cmu_us_awb_dur_NO_4890 4892
DEF_STATIC_CONST_VAL_FLOAT(val_2674,0.149190);
#define CTNODE_cmu_us_awb_dur_NO_4893 4895
DEF_STATIC_CONST_VAL_FLOAT(val_2675,-0.176772);
#define CTNODE_cmu_us_awb_dur_NO_4892 4896
DEF_STATIC_CONST_VAL_FLOAT(val_2676,-0.260955);
#define CTNODE_cmu_us_awb_dur_NO_4896 4898
DEF_STATIC_CONST_VAL_FLOAT(val_2677,-0.474667);
#define CTNODE_cmu_us_awb_dur_NO_4867 4899
DEF_STATIC_CONST_VAL_FLOAT(val_2678,-0.090059);
#define CTNODE_cmu_us_awb_dur_NO_4900 4902
DEF_STATIC_CONST_VAL_FLOAT(val_2679,-0.472818);
#define CTNODE_cmu_us_awb_dur_NO_4902 4904
DEF_STATIC_CONST_VAL_FLOAT(val_2680,-0.605778);
#define CTNODE_cmu_us_awb_dur_NO_4899 4905
DEF_STATIC_CONST_VAL_FLOAT(val_2681,-0.047603);
#define CTNODE_cmu_us_awb_dur_NO_4906 4908
DEF_STATIC_CONST_VAL_FLOAT(val_2682,-0.159906);
#define CTNODE_cmu_us_awb_dur_NO_4908 4910
DEF_STATIC_CONST_VAL_FLOAT(val_2683,-0.403239);
#define CTNODE_cmu_us_awb_dur_NO_4905 4911
DEF_STATIC_CONST_VAL_FLOAT(val_2684,0.249110);
#define CTNODE_cmu_us_awb_dur_NO_4912 4914
DEF_STATIC_CONST_VAL_FLOAT(val_2685,-0.153103);
#define CTNODE_cmu_us_awb_dur_NO_4914 4916
DEF_STATIC_CONST_VAL_FLOAT(val_2686,0.053430);
#define CTNODE_cmu_us_awb_dur_NO_4911 4917
DEF_STATIC_CONST_VAL_FLOAT(val_2687,0.337086);
#define CTNODE_cmu_us_awb_dur_NO_4770 4918
DEF_STATIC_CONST_VAL_FLOAT(val_2688,2.078360);
#define CTNODE_cmu_us_awb_dur_NO_4918 4920
DEF_STATIC_CONST_VAL_FLOAT(val_2689,1.981230);
#define CTNODE_cmu_us_awb_dur_NO_4920 4922
DEF_STATIC_CONST_VAL_FLOAT(val_2690,2.350590);
#define CTNODE_cmu_us_awb_dur_NO_4922 4924
DEF_STATIC_CONST_VAL_FLOAT(val_2691,2.808860);
#define CTNODE_cmu_us_awb_dur_NO_4925 4927
DEF_STATIC_CONST_VAL_FLOAT(val_2692,0.062861);
#define CTNODE_cmu_us_awb_dur_NO_4924 4928
DEF_STATIC_CONST_VAL_FLOAT(val_2693,1.572810);
#define CTNODE_cmu_us_awb_dur_NO_4929 4931
DEF_STATIC_CONST_VAL_FLOAT(val_2694,0.601290);
#define CTNODE_cmu_us_awb_dur_NO_4928 4932
DEF_STATIC_CONST_VAL_FLOAT(val_2695,0.050899);
#define CTNODE_cmu_us_awb_dur_NO_4933 4935
DEF_STATIC_CONST_VAL_FLOAT(val_2696,1.628630);
#define CTNODE_cmu_us_awb_dur_NO_4935 4937
DEF_STATIC_CONST_VAL_FLOAT(val_2697,0.943040);
#define CTNODE_cmu_us_awb_dur_NO_4937 4939
DEF_STATIC_CONST_VAL_FLOAT(val_2698,1.436330);
#define CTNODE_cmu_us_awb_dur_NO_4932 4940
DEF_STATIC_CONST_VAL_FLOAT(val_2699,-0.321066);
#define CTNODE_cmu_us_awb_dur_NO_4942 4944
DEF_STATIC_CONST_VAL_FLOAT(val_2700,-0.636117);
#define CTNODE_cmu_us_awb_dur_NO_4941 4945
DEF_STATIC_CONST_VAL_FLOAT(val_2701,-0.821403);
#define CTNODE_cmu_us_awb_dur_NO_4940 4946
DEF_STATIC_CONST_VAL_FLOAT(val_2702,1.203750);
#define CTNODE_cmu_us_awb_dur_NO_4948 4950
DEF_STATIC_CONST_VAL_FLOAT(val_2703,1.739770);
#define CTNODE_cmu_us_awb_dur_NO_4947 4951
DEF_STATIC_CONST_VAL_FLOAT(val_2704,0.215850);
#define CTNODE_cmu_us_awb_dur_NO_4946 4952
DEF_STATIC_CONST_VAL_FLOAT(val_2705,0.084355);
#define CTNODE_cmu_us_awb_dur_NO_4953 4955
DEF_STATIC_CONST_VAL_FLOAT(val_2706,-0.430636);
#define CTNODE_cmu_us_awb_dur_NO_4955 4957
DEF_STATIC_CONST_VAL_FLOAT(val_2707,-0.749308);
#define CTNODE_cmu_us_awb_dur_NO_4952 4958
DEF_STATIC_CONST_VAL_FLOAT(val_2708,1.263600);
#define CTNODE_cmu_us_awb_dur_NO_4958 4960
DEF_STATIC_CONST_VAL_FLOAT(val_2709,-0.287827);
#define CTNODE_cmu_us_awb_dur_NO_4961 4963
DEF_STATIC_CONST_VAL_FLOAT(val_2710,-0.649653);
#define CTNODE_cmu_us_awb_dur_NO_4960 4964
DEF_STATIC_CONST_VAL_FLOAT(val_2711,-0.429785);
#define CTNODE_cmu_us_awb_dur_NO_4966 4968
DEF_STATIC_CONST_VAL_FLOAT(val_2712,-0.053756);
#define CTNODE_cmu_us_awb_dur_NO_4965 4969
DEF_STATIC_CONST_VAL_FLOAT(val_2713,-0.472113);
#define CTNODE_cmu_us_awb_dur_NO_4964 4970
DEF_STATIC_CONST_VAL_FLOAT(val_2714,1.326450);
#define CTNODE_cmu_us_awb_dur_NO_4971 4973
DEF_STATIC_CONST_VAL_FLOAT(val_2715,0.566416);
#define CTNODE_cmu_us_awb_dur_NO_4974 4976
DEF_STATIC_CONST_VAL_FLOAT(val_2716,-0.029424);
#define CTNODE_cmu_us_awb_dur_NO_4977 4979
DEF_STATIC_CONST_VAL_FLOAT(val_2717,0.454762);
#define CTNODE_cmu_us_awb_dur_NO_4976 4980
DEF_STATIC_CONST_VAL_FLOAT(val_2718,0.323419);
#define CTNODE_cmu_us_awb_dur_NO_4981 4983
DEF_STATIC_CONST_VAL_FLOAT(val_2719,0.007676);
#define CTNODE_cmu_us_awb_dur_NO_4980 4984
DEF_STATIC_CONST_VAL_FLOAT(val_2720,-0.441067);
#define CTNODE_cmu_us_awb_dur_NO_4985 4987
DEF_STATIC_CONST_VAL_FLOAT(val_2721,0.318470);
#define CTNODE_cmu_us_awb_dur_NO_4984 4988
DEF_STATIC_CONST_VAL_FLOAT(val_2722,-0.518601);
#define CTNODE_cmu_us_awb_dur_NO_4989 4991
DEF_STATIC_CONST_VAL_FLOAT(val_2723,-0.264080);
#define CTNODE_cmu_us_awb_dur_NO_4992 4994
DEF_STATIC_CONST_VAL_FLOAT(val_2724,0.007802);
#define CTNODE_cmu_us_awb_dur_NO_4991 4995
DEF_STATIC_CONST_VAL_FLOAT(val_2725,-0.448708);
#define CTNODE_cmu_us_awb_dur_NO_4988 4996
DEF_STATIC_CONST_VAL_FLOAT(val_2726,-0.639106);
#define CTNODE_cmu_us_awb_dur_NO_4997 4999
DEF_STATIC_CONST_VAL_FLOAT(val_2727,-0.390361);
#define CTNODE_cmu_us_awb_dur_NO_4996 5000
DEF_STATIC_CONST_VAL_FLOAT(val_2728,-0.683097);
#define CTNODE_cmu_us_awb_dur_NO_4973 5001
DEF_STATIC_CONST_VAL_FLOAT(val_2729,1.594120);
#define CTNODE_cmu_us_awb_dur_NO_5001 5003
DEF_STATIC_CONST_VAL_FLOAT(val_2730,-0.369843);
#define CTNODE_cmu_us_awb_dur_NO_5003 5005
DEF_STATIC_CONST_VAL_FLOAT(val_2731,0.579600);
#define CTNODE_cmu_us_awb_dur_NO_4970 5006
DEF_STATIC_CONST_VAL_FLOAT(val_2732,1.029200);
#define CTNODE_cmu_us_awb_dur_NO_5008 5010
DEF_STATIC_CONST_VAL_FLOAT(val_2733,-0.236492);
#define CTNODE_cmu_us_awb_dur_NO_5007 5011
DEF_STATIC_CONST_VAL_FLOAT(val_2734,1.808700);
#define CTNODE_cmu_us_awb_dur_NO_5006 5012
DEF_STATIC_CONST_VAL_FLOAT(val_2735,1.229560);
#define CTNODE_cmu_us_awb_dur_NO_5012 5014
DEF_STATIC_CONST_VAL_FLOAT(val_2736,1.505380);
#define CTNODE_cmu_us_awb_dur_NO_5015 5017
DEF_STATIC_CONST_VAL_FLOAT(val_2737,0.006899);
#define CTNODE_cmu_us_awb_dur_NO_5017 5019
DEF_STATIC_CONST_VAL_FLOAT(val_2738,0.758039);
#define CTNODE_cmu_us_awb_dur_NO_5014 5020
DEF_STATIC_CONST_VAL_STRING(val_2739,"w_190");
DEF_STATIC_CONST_VAL_FLOAT(val_2740,1.134930);
#define CTNODE_cmu_us_awb_dur_NO_5020 5022
DEF_STATIC_CONST_VAL_FLOAT(val_2741,0.974773);
#define CTNODE_cmu_us_awb_dur_NO_5022 5024
DEF_STATIC_CONST_VAL_FLOAT(val_2742,0.539993);
#define CTNODE_cmu_us_awb_dur_NO_5025 5027
DEF_STATIC_CONST_VAL_FLOAT(val_2743,1.270740);
#define CTNODE_cmu_us_awb_dur_NO_5024 5028
DEF_STATIC_CONST_VAL_FLOAT(val_2744,0.952498);
#define CTNODE_cmu_us_awb_dur_NO_5028 5030
DEF_STATIC_CONST_VAL_FLOAT(val_2745,-0.566351);
#define CTNODE_cmu_us_awb_dur_NO_5031 5033
DEF_STATIC_CONST_VAL_FLOAT(val_2746,-0.470450);
#define CTNODE_cmu_us_awb_dur_NO_5034 5036
DEF_STATIC_CONST_VAL_FLOAT(val_2747,0.006288);
#define CTNODE_cmu_us_awb_dur_NO_5033 5037
DEF_STATIC_CONST_VAL_FLOAT(val_2748,0.305057);
#define CTNODE_cmu_us_awb_dur_NO_5030 5038
DEF_STATIC_CONST_VAL_FLOAT(val_2749,-0.056337);
#define CTNODE_cmu_us_awb_dur_NO_5040 5042
DEF_STATIC_CONST_VAL_FLOAT(val_2750,0.223238);
#define CTNODE_cmu_us_awb_dur_NO_5039 5043
DEF_STATIC_CONST_VAL_FLOAT(val_2751,-0.602542);
#define CTNODE_cmu_us_awb_dur_NO_5038 5044
DEF_STATIC_CONST_VAL_FLOAT(val_2752,-0.411082);
#define CTNODE_cmu_us_awb_dur_NO_5044 5046
DEF_STATIC_CONST_VAL_FLOAT(val_2753,-0.544110);
#define CTNODE_cmu_us_awb_dur_NO_5046 5048
DEF_STATIC_CONST_VAL_FLOAT(val_2754,-0.238375);
#define CTNODE_cmu_us_awb_dur_NO_5049 5051
DEF_STATIC_CONST_VAL_FLOAT(val_2755,0.644797);
#define CTNODE_cmu_us_awb_dur_NO_5052 5054
DEF_STATIC_CONST_VAL_FLOAT(val_2756,0.058965);
#define CTNODE_cmu_us_awb_dur_NO_5051 5055
DEF_STATIC_CONST_VAL_FLOAT(val_2757,0.211070);
#define CTNODE_cmu_us_awb_dur_NO_5055 5057
DEF_STATIC_CONST_VAL_FLOAT(val_2758,0.686108);
#define CTNODE_cmu_us_awb_dur_NO_5058 5060
DEF_STATIC_CONST_VAL_FLOAT(val_2759,0.401033);
#define CTNODE_cmu_us_awb_dur_NO_5057 5061
DEF_STATIC_CONST_VAL_FLOAT(val_2760,0.756438);
#define CTNODE_cmu_us_awb_dur_NO_5061 5063
DEF_STATIC_CONST_VAL_FLOAT(val_2761,1.412210);
#define CTNODE_cmu_us_awb_dur_NO_5063 5065
DEF_STATIC_CONST_VAL_FLOAT(val_2762,0.868356);
#define CTNODE_cmu_us_awb_dur_NO_5048 5066
DEF_STATIC_CONST_VAL_FLOAT(val_2763,1.170470);
#define CTNODE_cmu_us_awb_dur_NO_5067 5069
DEF_STATIC_CONST_VAL_FLOAT(val_2764,0.522182);
#define CTNODE_cmu_us_awb_dur_NO_5066 5070
DEF_STATIC_CONST_VAL_FLOAT(val_2765,-0.322470);
#define CTNODE_cmu_us_awb_dur_NO_5070 5072
DEF_STATIC_CONST_VAL_FLOAT(val_2766,-0.278620);
#define CTNODE_cmu_us_awb_dur_NO_5072 5074
DEF_STATIC_CONST_VAL_FLOAT(val_2767,-0.372427);
#define CTNODE_cmu_us_awb_dur_NO_5074 5076
DEF_STATIC_CONST_VAL_FLOAT(val_2768,0.860507);
#define CTNODE_cmu_us_awb_dur_NO_5076 5078
DEF_STATIC_CONST_VAL_FLOAT(val_2769,1.764750);
#define CTNODE_cmu_us_awb_dur_NO_5081 5083
DEF_STATIC_CONST_VAL_FLOAT(val_2770,-0.267043);
#define CTNODE_cmu_us_awb_dur_NO_5083 5085
DEF_STATIC_CONST_VAL_FLOAT(val_2771,-0.145571);
#define CTNODE_cmu_us_awb_dur_NO_5086 5088
DEF_STATIC_CONST_VAL_FLOAT(val_2772,-0.091845);
#define CTNODE_cmu_us_awb_dur_NO_5088 5090
DEF_STATIC_CONST_VAL_FLOAT(val_2773,0.248201);
#define CTNODE_cmu_us_awb_dur_NO_5090 5092
DEF_STATIC_CONST_VAL_FLOAT(val_2774,0.808402);
#define CTNODE_cmu_us_awb_dur_NO_5085 5093
DEF_STATIC_CONST_VAL_FLOAT(val_2775,0.780948);
#define CTNODE_cmu_us_awb_dur_NO_5094 5096
DEF_STATIC_CONST_VAL_FLOAT(val_2776,1.557550);
#define CTNODE_cmu_us_awb_dur_NO_5093 5097
DEF_STATIC_CONST_VAL_FLOAT(val_2777,-0.054492);
#define CTNODE_cmu_us_awb_dur_NO_5097 5099
DEF_STATIC_CONST_VAL_FLOAT(val_2778,0.890205);
#define CTNODE_cmu_us_awb_dur_NO_5100 5102
DEF_STATIC_CONST_VAL_FLOAT(val_2779,0.516028);
#define CTNODE_cmu_us_awb_dur_NO_5102 5104
DEF_STATIC_CONST_VAL_FLOAT(val_2780,0.076478);
#define CTNODE_cmu_us_awb_dur_NO_5099 5105
DEF_STATIC_CONST_VAL_FLOAT(val_2781,1.169060);
#define CTNODE_cmu_us_awb_dur_NO_5080 5106
DEF_STATIC_CONST_VAL_FLOAT(val_2782,-0.569155);
#define CTNODE_cmu_us_awb_dur_NO_5106 5108
DEF_STATIC_CONST_VAL_FLOAT(val_2783,0.759315);
#define CTNODE_cmu_us_awb_dur_NO_5108 5110
DEF_STATIC_CONST_VAL_FLOAT(val_2784,-0.230000);
#define CTNODE_cmu_us_awb_dur_NO_5110 5112
DEF_STATIC_CONST_VAL_FLOAT(val_2785,0.142729);
#define CTNODE_cmu_us_awb_dur_NO_5079 5113
DEF_STATIC_CONST_VAL_FLOAT(val_2786,1.052970);
#define CTNODE_cmu_us_awb_dur_NO_5114 5116
DEF_STATIC_CONST_VAL_FLOAT(val_2787,0.660501);
#define CTNODE_cmu_us_awb_dur_NO_5116 5118
DEF_STATIC_CONST_VAL_FLOAT(val_2788,-0.173075);
#define CTNODE_cmu_us_awb_dur_NO_5118 5120
DEF_STATIC_CONST_VAL_FLOAT(val_2789,-0.125031);
#define CTNODE_cmu_us_awb_dur_NO_5120 5122
DEF_STATIC_CONST_VAL_FLOAT(val_2790,0.549424);
#define CTNODE_cmu_us_awb_dur_NO_5123 5125
DEF_STATIC_CONST_VAL_FLOAT(val_2791,0.190349);
#define CTNODE_cmu_us_awb_dur_NO_5122 5126
DEF_STATIC_CONST_VAL_FLOAT(val_2792,0.021834);
#define CTNODE_cmu_us_awb_dur_NO_5113 5127
DEF_STATIC_CONST_VAL_FLOAT(val_2793,0.139741);
#define CTNODE_cmu_us_awb_dur_NO_5129 5131
DEF_STATIC_CONST_VAL_FLOAT(val_2794,-0.032236);
#define CTNODE_cmu_us_awb_dur_NO_5128 5132
DEF_STATIC_CONST_VAL_FLOAT(val_2795,-0.188702);
#define CTNODE_cmu_us_awb_dur_NO_5132 5134
DEF_STATIC_CONST_VAL_FLOAT(val_2796,-0.437537);
#define CTNODE_cmu_us_awb_dur_NO_5127 5135
DEF_STATIC_CONST_VAL_FLOAT(val_2797,-0.039947);
#define CTNODE_cmu_us_awb_dur_NO_5135 5137
DEF_STATIC_CONST_VAL_FLOAT(val_2798,0.434581);
#define CTNODE_cmu_us_awb_dur_NO_5078 5138
DEF_STATIC_CONST_VAL_FLOAT(val_2799,0.828820);
#define CTNODE_cmu_us_awb_dur_NO_5138 5140
DEF_STATIC_CONST_VAL_FLOAT(val_2800,0.420688);
#define CTNODE_cmu_us_awb_dur_NO_5140 5142
DEF_STATIC_CONST_VAL_FLOAT(val_2801,0.533383);
#define CTNODE_cmu_us_awb_dur_NO_5143 5145
DEF_STATIC_CONST_VAL_FLOAT(val_2802,-0.129796);
#define CTNODE_cmu_us_awb_dur_NO_5145 5147
DEF_STATIC_CONST_VAL_FLOAT(val_2803,0.326528);
#define CTNODE_cmu_us_awb_dur_NO_5149 5151
DEF_STATIC_CONST_VAL_FLOAT(val_2804,0.107432);
#define CTNODE_cmu_us_awb_dur_NO_5148 5152
DEF_STATIC_CONST_VAL_FLOAT(val_2805,-0.088115);
#define CTNODE_cmu_us_awb_dur_NO_5147 5153
DEF_STATIC_CONST_VAL_FLOAT(val_2806,0.456574);
#define CTNODE_cmu_us_awb_dur_NO_5153 5155
DEF_STATIC_CONST_VAL_FLOAT(val_2807,0.403570);
#define CTNODE_cmu_us_awb_dur_NO_5142 5156
DEF_STATIC_CONST_VAL_FLOAT(val_2808,-0.296470);
#define CTNODE_cmu_us_awb_dur_NO_5157 5159
DEF_STATIC_CONST_VAL_FLOAT(val_2809,-0.124211);
#define CTNODE_cmu_us_awb_dur_NO_5156 5160
DEF_STATIC_CONST_VAL_FLOAT(val_2810,-0.328314);
#define CTNODE_cmu_us_awb_dur_NO_5162 5164
DEF_STATIC_CONST_VAL_FLOAT(val_2811,-0.163192);
#define CTNODE_cmu_us_awb_dur_NO_5161 5165
DEF_STATIC_CONST_VAL_FLOAT(val_2812,0.233285);
#define CTNODE_cmu_us_awb_dur_NO_5165 5167
DEF_STATIC_CONST_VAL_FLOAT(val_2813,-0.230044);
#define CTNODE_cmu_us_awb_dur_NO_5167 5169
DEF_STATIC_CONST_VAL_FLOAT(val_2814,0.117385);
#define CTNODE_cmu_us_awb_dur_NO_5160 5170
DEF_STATIC_CONST_VAL_FLOAT(val_2815,-0.079898);
#define CTNODE_cmu_us_awb_dur_NO_5170 5172
DEF_STATIC_CONST_VAL_FLOAT(val_2816,0.075529);
#define CTNODE_cmu_us_awb_dur_NO_5172 5174
DEF_STATIC_CONST_VAL_FLOAT(val_2817,0.746774);
| 133,366 |
347 | #
# ovirt-engine-setup -- ovirt engine setup
#
# Copyright oVirt Authors
# SPDX-License-Identifier: Apache-2.0
#
#
"""ovirt-host-setup network plugin."""
from otopi import util
from . import firewall_manager
from . import firewall_manager_firewalld
from . import firewall_manager_human
from . import firewall_manager_iptables
from . import hostname
@util.export
def createPlugins(context):
firewall_manager.Plugin(context=context)
firewall_manager_firewalld.Plugin(context=context)
firewall_manager_human.Plugin(context=context)
firewall_manager_iptables.Plugin(context=context)
hostname.Plugin(context=context)
# vim: expandtab tabstop=4 shiftwidth=4
| 215 |
2,225 | <filename>packages/linden-hill/package.json
{
"name": "@fontsource/linden-hill",
"version": "4.5.0",
"description": "Self-host the Linden Hill font in a neatly bundled NPM package.",
"main": "index.css",
"publishConfig": {
"access": "public"
},
"keywords": [
"fontsource",
"font",
"font family",
"google fonts",
"Linden Hill",
"linden-hill"
],
"author": "Lotus <<EMAIL>>",
"license": "MIT",
"homepage": "https://github.com/fontsource/fontsource/tree/master/packages/linden-hill#readme",
"repository": {
"type": "git",
"url": "https://github.com/fontsource/fontsource.git",
"directory": "packages/linden-hill"
}
}
| 274 |
2,707 | <filename>jetlinks-manager/rule-engine-manager/src/main/java/org/jetlinks/community/rule/engine/service/DebugMessage.java<gh_stars>1000+
package org.jetlinks.community.rule.engine.service;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.io.Serializable;
import java.util.Date;
@Getter
@Setter
@AllArgsConstructor(staticName = "of")
@NoArgsConstructor
public class DebugMessage implements Serializable {
private String type;
private String contextId;
private Object message;
private Date timestamp;
public static DebugMessage of(String type, String contextId, Object message) {
return of(type, contextId, message, new Date());
}
}
| 238 |
3,957 | <filename>sample/src/main/java/com/yanzhenjie/nohttp/sample/app/normal/NormalPresenter.java
/*
* Copyright 2018 <NAME>.
*
* 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.
*/
package com.yanzhenjie.nohttp.sample.app.normal;
import android.os.Bundle;
import android.support.annotation.Nullable;
import com.yanzhenjie.nohttp.RequestMethod;
import com.yanzhenjie.nohttp.sample.R;
import com.yanzhenjie.nohttp.sample.app.BaseActivity;
import com.yanzhenjie.nohttp.sample.config.UrlConfig;
import com.yanzhenjie.nohttp.sample.entity.News;
import com.yanzhenjie.nohttp.sample.entity.NewsWrapper;
import com.yanzhenjie.nohttp.sample.entity.Page;
import com.yanzhenjie.nohttp.sample.http.EntityRequest;
import com.yanzhenjie.nohttp.sample.http.HttpCallback;
import com.yanzhenjie.nohttp.sample.http.Result;
import java.util.List;
/**
* Created by YanZhenjie on 2018/3/27.
*/
public class NormalPresenter
extends BaseActivity
implements Contract.NormalPresenter {
private Contract.NormalView mView;
private List<News> mDataList;
private Page mPage;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_normal);
mView = new NormalView(this, this);
mView.setRefresh(true);
refresh();
}
@Override
public void refresh() {
EntityRequest<NewsWrapper> request =
new EntityRequest<>(UrlConfig.GET_LIST, RequestMethod.GET, NewsWrapper.class);
request.add("pageNum", 1).add("pageSize", 50);
request(request, false, new HttpCallback<NewsWrapper>() {
@Override
public void onResponse(Result<NewsWrapper> response) {
if (response.isSucceed()) {
NewsWrapper wrapper = response.get();
mDataList = wrapper.getDataList();
mPage = wrapper.getPage();
mView.setDataList(mDataList, mPage);
} else {
mView.toast(response.error());
}
// Finish refresh.
mView.setRefresh(false);
}
});
}
@Override
public void loadMore() {
EntityRequest<NewsWrapper> request =
new EntityRequest<>(UrlConfig.GET_LIST, RequestMethod.GET, NewsWrapper.class);
request.add("pageNum", mPage.getPageNum() + 1).add("pageSize", 50);
request(request, false, new HttpCallback<NewsWrapper>() {
@Override
public void onResponse(Result<NewsWrapper> response) {
if (response.isSucceed()) {
NewsWrapper wrapper = response.get();
List<News> dataList = wrapper.getDataList();
if (dataList != null && !dataList.isEmpty()) {
mDataList.addAll(dataList);
mPage = wrapper.getPage();
}
} else {
mView.toast(response.error());
}
// Finish load more.
mView.addDataList(mPage);
}
});
}
@Override
public void clickItem(int position) {
News news = mDataList.get(position);
mView.toast(news.getTitle());
}
} | 1,633 |
931 | /*
Src : LeetCode
--------------
Given a string s formed by digits ('0' - '9') and '#' . We want to map s to English lowercase characters as follows:
1. Characters ('a' to 'i') are represented by ('1' to '9') respectively.
2. Characters ('j' to 'z') are represented by ('10#' to '26#') respectively.
Return the string formed after mapping.
It's guaranteed that a unique mapping will always exist.
*/
class Solution {
public:
string freqAlphabets(string s) {
string ans="";
for(int i=0;i<s.length();i++) {
if(i+2<s.length() && s[i+2]=='#') {
int ss=(s[i]-'0')*10+(s[i+1]-'0');
ans+=char(ss+'a'-1);
i+=2;
}
else ans+=char(s[i]-'0'-1+'a');
}
return ans;
}
}; | 366 |
45,293 | <reponame>AndrewReitz/kotlin
import javax.annotation.*;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import javax.annotation.meta.TypeQualifierNickname;
import javax.annotation.meta.When;
import kotlin.annotations.jvm.*;
@Documented
@TypeQualifierNickname
@Nonnull(when = When.ALWAYS)
@Retention(RetentionPolicy.RUNTIME)
@UnderMigration(status = MigrationStatus.WARN)
public @interface MyMigrationNonnull {
}
| 168 |
313 | /*
* SimpleRenderEngine (https://github.com/mortennobel/SimpleRenderEngine)
*
* Created by <NAME> ( http://www.nobel-joergensen.com/ )
* License: MIT
*/
#pragma once
#include <vector>
#include <chrono>
#include <memory>
#include "sre/RenderStats.hpp"
#include "sre/Framebuffer.hpp"
#include "sre/WorldLights.hpp"
namespace sre {
// forward declarations
class Texture;
class Mesh;
class Shader;
class Camera;
class SpriteAtlas;
class SDLRenderer;
/**
* The inspector measures resources used by SimpleRenderEngine.
* Inspector.update() records the current state and must be called each frame.
* Inspector.gui() draws gui. Must be called within a RenderPass with GUI enabled.
*/
class Inspector {
public:
explicit Inspector(int frames = 300);
void update(); // must be called each in the beginning of each frame to capture data
void gui(bool useWindow = true);// called when gui should be shown
void showMesh(Mesh *mesh);
void showFramebufferObject(Framebuffer* fbo);
void showShader(Shader *shader);
void showMaterial(Material *material);
void showMatrix(const char* label,glm::mat4 matrix);
void showMatrix(const char* label,glm::mat3 matrix);
void showTexture(Texture *tex);
void showCamera(Camera *cam);
void showWorldLights(WorldLights *lights);
private:
std::shared_ptr<Texture> getTmpTexture();
std::vector<std::shared_ptr<Texture>> offscreenTextures;
int usedTextures = 0;
std::shared_ptr<Framebuffer> framebuffer;
int frames;
int frameCount;
std::weak_ptr<Shader> shaderEdit;
std::vector<float> millisecondsFrameTime;
std::vector<float> millisecondsEvent;
std::vector<float> millisecondsUpdate;
std::vector<float> millisecondsRender;
std::vector<RenderStats> stats;
std::vector<float> data;
float time;
std::chrono::time_point<std::chrono::high_resolution_clock> lastTick;
void showSpriteAtlas(SpriteAtlas *pAtlas);
void editShader(Shader* shader);
WorldLights worldLights;
void initFramebuffer();
const float previewSize = 100;
void plotTimings(float *inputData, const char *title);
};
} | 912 |
5,166 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Stub functions that are used by the AWS Lambda unit tests.
When tests are run against an actual AWS account, the stubber class does not
set up stubs and passes all calls through to the Boto 3 client.
"""
from botocore.stub import ANY
from test_tools.example_stubber import ExampleStubber
class LambdaStubber(ExampleStubber):
"""
A class that implements a variety of stub functions that are used by the
AWS Lambda unit tests.
The stubbed functions all expect certain parameters to be passed to them as
part of the tests, and will raise errors when the actual parameters differ from
the expected.
"""
def __init__(self, client, use_stubs=True):
"""
Initializes the object with a specific client and configures it for
stubbing or AWS passthrough.
:param client: A Boto 3 Lambda client.
:param use_stubs: When True, use stubs to intercept requests. Otherwise,
pass requests through to AWS.
"""
super().__init__(client, use_stubs)
def stub_create_function(self, function_name, function_arn, role_arn,
handler, zip_contents=ANY, error_code=None):
expected_params = {
'FunctionName': function_name,
'Runtime': ANY,
'Role': role_arn,
'Handler': handler,
'Code': {'ZipFile': zip_contents},
'Description': ANY,
'Publish': True
}
response = {'FunctionArn': function_arn}
self._stub_bifurcator(
'create_function', expected_params, response, error_code=error_code)
def stub_delete_function(self, function_name, error_code=None):
self._stub_bifurcator(
'delete_function',
expected_params={'FunctionName': function_name},
error_code=error_code)
def stub_invoke(
self, function_name, in_payload, out_payload, log_type=None,
error_code=None):
expected_params = {
'FunctionName': function_name,
'Payload': in_payload
}
if log_type is not None:
expected_params['LogType'] = log_type
response = {'Payload': out_payload}
self._stub_bifurcator(
'invoke', expected_params, response, error_code=error_code)
def stub_add_permission(
self, func_name, action, principal, source_arn=ANY,
error_code=None):
expected_params = {
'FunctionName': func_name, 'StatementId': ANY, 'Action': action,
'Principal': principal, 'SourceArn': source_arn}
self._stub_bifurcator(
'add_permission', expected_params, error_code=error_code)
| 1,190 |
521 | /*
* 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.
*/
#include <sys/errno.h>
#include <sys/stat.h>
#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/systm.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/cpuvar.h>
#include <sys/kmem.h>
#include <sys/strsubr.h>
#include <sys/dtrace.h>
#include <sys/cyclic.h>
#include <sys/atomic.h>
static dev_info_t *profile_devi;
static dtrace_provider_id_t profile_id;
/*
* Regardless of platform, the stack frames look like this in the case of the
* profile provider:
*
* profile_fire
* cyclic_expire
* cyclic_fire
* [ cbe ]
* [ interrupt code ]
*
* On x86, there are five frames from the generic interrupt code; further, the
* interrupted instruction appears as its own stack frame, giving us a total of
* 10.
*
* On SPARC, the picture is further complicated because the compiler
* optimizes away tail-calls -- so the following frames are optimized away:
*
* profile_fire
* cyclic_expire
*
* This gives three frames. However, on DEBUG kernels, the cyclic_expire
* frame cannot be tail-call eliminated, yielding four frames in this case.
*
* All of the above constraints lead to the mess below. Yes, the profile
* provider should ideally figure this out on-the-fly by hitting one of its own
* probes and then walking its own stack trace. This is complicated, however,
* and the static definition doesn't seem to be overly brittle. Still, we
* allow for a manual override in case we get it completely wrong.
*/
#ifdef __x86
#define PROF_ARTIFICIAL_FRAMES 10
#else
#ifdef __sparc
#ifdef DEBUG
#define PROF_ARTIFICIAL_FRAMES 4
#else
#define PROF_ARTIFICIAL_FRAMES 3
#endif
#endif
#endif
#define PROF_NAMELEN 15
#define PROF_PROFILE 0
#define PROF_TICK 1
#define PROF_PREFIX_PROFILE "profile-"
#define PROF_PREFIX_TICK "tick-"
typedef struct profile_probe {
char prof_name[PROF_NAMELEN];
dtrace_id_t prof_id;
int prof_kind;
hrtime_t prof_interval;
cyclic_id_t prof_cyclic;
} profile_probe_t;
typedef struct profile_probe_percpu {
hrtime_t profc_expected;
hrtime_t profc_interval;
profile_probe_t *profc_probe;
} profile_probe_percpu_t;
hrtime_t profile_interval_min = NANOSEC / 5000; /* 5000 hz */
int profile_aframes = 0; /* override */
static int profile_rates[] = {
97, 199, 499, 997, 1999,
4001, 4999, 0, 0, 0,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0
};
static int profile_ticks[] = {
1, 10, 100, 500, 1000,
5000, 0, 0, 0, 0,
0, 0, 0, 0, 0
};
/*
* profile_max defines the upper bound on the number of profile probes that
* can exist (this is to prevent malicious or clumsy users from exhausing
* system resources by creating a slew of profile probes). At mod load time,
* this gets its value from PROFILE_MAX_DEFAULT or profile-max-probes if it's
* present in the profile.conf file.
*/
#define PROFILE_MAX_DEFAULT 1000 /* default max. number of probes */
static uint32_t profile_max; /* maximum number of profile probes */
static uint32_t profile_total; /* current number of profile probes */
static void
profile_fire(void *arg)
{
profile_probe_percpu_t *pcpu = arg;
profile_probe_t *prof = pcpu->profc_probe;
hrtime_t late;
late = dtrace_gethrtime() - pcpu->profc_expected;
pcpu->profc_expected += pcpu->profc_interval;
dtrace_probe(prof->prof_id, CPU->cpu_profile_pc,
CPU->cpu_profile_upc, late, 0, 0);
}
static void
profile_tick(void *arg)
{
profile_probe_t *prof = arg;
dtrace_probe(prof->prof_id, CPU->cpu_profile_pc,
CPU->cpu_profile_upc, 0, 0, 0);
}
static void
profile_create(hrtime_t interval, const char *name, int kind)
{
profile_probe_t *prof;
int nr_frames = PROF_ARTIFICIAL_FRAMES + dtrace_mach_aframes();
if (profile_aframes)
nr_frames = profile_aframes;
if (interval < profile_interval_min)
return;
if (dtrace_probe_lookup(profile_id, NULL, NULL, name) != 0)
return;
atomic_add_32(&profile_total, 1);
if (profile_total > profile_max) {
atomic_add_32(&profile_total, -1);
return;
}
prof = kmem_zalloc(sizeof (profile_probe_t), KM_SLEEP);
(void) strcpy(prof->prof_name, name);
prof->prof_interval = interval;
prof->prof_cyclic = CYCLIC_NONE;
prof->prof_kind = kind;
prof->prof_id = dtrace_probe_create(profile_id,
NULL, NULL, name, nr_frames, prof);
}
/*ARGSUSED*/
static void
profile_provide(void *arg, const dtrace_probedesc_t *desc)
{
int i, j, rate, kind;
hrtime_t val = 0, mult = 1, len;
const char *name, *suffix = NULL;
const struct {
char *prefix;
int kind;
} types[] = {
{ PROF_PREFIX_PROFILE, PROF_PROFILE },
{ PROF_PREFIX_TICK, PROF_TICK },
{ NULL, NULL }
};
const struct {
char *name;
hrtime_t mult;
} suffixes[] = {
{ "ns", NANOSEC / NANOSEC },
{ "nsec", NANOSEC / NANOSEC },
{ "us", NANOSEC / MICROSEC },
{ "usec", NANOSEC / MICROSEC },
{ "ms", NANOSEC / MILLISEC },
{ "msec", NANOSEC / MILLISEC },
{ "s", NANOSEC / SEC },
{ "sec", NANOSEC / SEC },
{ "m", NANOSEC * (hrtime_t)60 },
{ "min", NANOSEC * (hrtime_t)60 },
{ "h", NANOSEC * (hrtime_t)(60 * 60) },
{ "hour", NANOSEC * (hrtime_t)(60 * 60) },
{ "d", NANOSEC * (hrtime_t)(24 * 60 * 60) },
{ "day", NANOSEC * (hrtime_t)(24 * 60 * 60) },
{ "hz", 0 },
{ NULL }
};
if (desc == NULL) {
char n[PROF_NAMELEN];
/*
* If no description was provided, provide all of our probes.
*/
for (i = 0; i < sizeof (profile_rates) / sizeof (int); i++) {
if ((rate = profile_rates[i]) == 0)
continue;
(void) snprintf(n, PROF_NAMELEN, "%s%d",
PROF_PREFIX_PROFILE, rate);
profile_create(NANOSEC / rate, n, PROF_PROFILE);
}
for (i = 0; i < sizeof (profile_ticks) / sizeof (int); i++) {
if ((rate = profile_ticks[i]) == 0)
continue;
(void) snprintf(n, PROF_NAMELEN, "%s%d",
PROF_PREFIX_TICK, rate);
profile_create(NANOSEC / rate, n, PROF_TICK);
}
return;
}
name = desc->dtpd_name;
for (i = 0; types[i].prefix != NULL; i++) {
len = strlen(types[i].prefix);
if (strncmp(name, types[i].prefix, len) != 0)
continue;
break;
}
if (types[i].prefix == NULL)
return;
kind = types[i].kind;
j = strlen(name) - len;
/*
* We need to start before any time suffix.
*/
for (j = strlen(name); j >= len; j--) {
if (name[j] >= '0' && name[j] <= '9')
break;
suffix = &name[j];
}
ASSERT(suffix != NULL);
/*
* Now determine the numerical value present in the probe name.
*/
for (; j >= len; j--) {
if (name[j] < '0' || name[j] > '9')
return;
val += (name[j] - '0') * mult;
mult *= (hrtime_t)10;
}
if (val == 0)
return;
/*
* Look-up the suffix to determine the multiplier.
*/
for (i = 0, mult = 0; suffixes[i].name != NULL; i++) {
if (strcasecmp(suffixes[i].name, suffix) == 0) {
mult = suffixes[i].mult;
break;
}
}
if (suffixes[i].name == NULL && *suffix != '\0')
return;
if (mult == 0) {
/*
* The default is frequency-per-second.
*/
val = NANOSEC / val;
} else {
val *= mult;
}
profile_create(val, name, kind);
}
/*ARGSUSED*/
static void
profile_destroy(void *arg, dtrace_id_t id, void *parg)
{
profile_probe_t *prof = parg;
ASSERT(prof->prof_cyclic == CYCLIC_NONE);
kmem_free(prof, sizeof (profile_probe_t));
ASSERT(profile_total >= 1);
atomic_add_32(&profile_total, -1);
}
/*ARGSUSED*/
static void
profile_online(void *arg, cpu_t *cpu, cyc_handler_t *hdlr, cyc_time_t *when)
{
profile_probe_t *prof = arg;
profile_probe_percpu_t *pcpu;
pcpu = kmem_zalloc(sizeof (profile_probe_percpu_t), KM_SLEEP);
pcpu->profc_probe = prof;
hdlr->cyh_func = profile_fire;
hdlr->cyh_arg = pcpu;
hdlr->cyh_level = CY_HIGH_LEVEL;
when->cyt_interval = prof->prof_interval;
when->cyt_when = dtrace_gethrtime() + when->cyt_interval;
pcpu->profc_expected = when->cyt_when;
pcpu->profc_interval = when->cyt_interval;
}
/*ARGSUSED*/
static void
profile_offline(void *arg, cpu_t *cpu, void *oarg)
{
profile_probe_percpu_t *pcpu = oarg;
ASSERT(pcpu->profc_probe == arg);
kmem_free(pcpu, sizeof (profile_probe_percpu_t));
}
/*ARGSUSED*/
static int
profile_enable(void *arg, dtrace_id_t id, void *parg)
{
profile_probe_t *prof = parg;
cyc_omni_handler_t omni;
cyc_handler_t hdlr;
cyc_time_t when;
ASSERT(prof->prof_interval != 0);
ASSERT(MUTEX_HELD(&cpu_lock));
if (prof->prof_kind == PROF_TICK) {
hdlr.cyh_func = profile_tick;
hdlr.cyh_arg = prof;
hdlr.cyh_level = CY_HIGH_LEVEL;
when.cyt_interval = prof->prof_interval;
when.cyt_when = dtrace_gethrtime() + when.cyt_interval;
} else {
ASSERT(prof->prof_kind == PROF_PROFILE);
omni.cyo_online = profile_online;
omni.cyo_offline = profile_offline;
omni.cyo_arg = prof;
}
if (prof->prof_kind == PROF_TICK) {
prof->prof_cyclic = cyclic_add(&hdlr, &when);
} else {
prof->prof_cyclic = cyclic_add_omni(&omni);
}
return (0);
}
/*ARGSUSED*/
static void
profile_disable(void *arg, dtrace_id_t id, void *parg)
{
profile_probe_t *prof = parg;
ASSERT(prof->prof_cyclic != CYCLIC_NONE);
ASSERT(MUTEX_HELD(&cpu_lock));
cyclic_remove(prof->prof_cyclic);
prof->prof_cyclic = CYCLIC_NONE;
}
/*ARGSUSED*/
static int
profile_usermode(void *arg, dtrace_id_t id, void *parg)
{
return (CPU->cpu_profile_pc == 0);
}
static dtrace_pattr_t profile_attr = {
{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
{ DTRACE_STABILITY_UNSTABLE, DTRACE_STABILITY_UNSTABLE, DTRACE_CLASS_UNKNOWN },
{ DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN },
{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
{ DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON },
};
static dtrace_pops_t profile_pops = {
profile_provide,
NULL,
profile_enable,
profile_disable,
NULL,
NULL,
NULL,
NULL,
profile_usermode,
profile_destroy
};
static int
profile_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (ddi_create_minor_node(devi, "profile", S_IFCHR, 0,
DDI_PSEUDO, NULL) == DDI_FAILURE ||
dtrace_register("profile", &profile_attr,
DTRACE_PRIV_KERNEL | DTRACE_PRIV_USER, NULL,
&profile_pops, NULL, &profile_id) != 0) {
ddi_remove_minor_node(devi, NULL);
return (DDI_FAILURE);
}
profile_max = ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
"profile-max-probes", PROFILE_MAX_DEFAULT);
ddi_report_dev(devi);
profile_devi = devi;
return (DDI_SUCCESS);
}
static int
profile_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
{
switch (cmd) {
case DDI_DETACH:
break;
case DDI_SUSPEND:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (dtrace_unregister(profile_id) != 0)
return (DDI_FAILURE);
ddi_remove_minor_node(devi, NULL);
return (DDI_SUCCESS);
}
/*ARGSUSED*/
static int
profile_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
int error;
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
*result = (void *)profile_devi;
error = DDI_SUCCESS;
break;
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)0;
error = DDI_SUCCESS;
break;
default:
error = DDI_FAILURE;
}
return (error);
}
/*ARGSUSED*/
static int
profile_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
{
return (0);
}
static struct cb_ops profile_cb_ops = {
profile_open, /* open */
nodev, /* close */
nulldev, /* strategy */
nulldev, /* print */
nodev, /* dump */
nodev, /* read */
nodev, /* write */
nodev, /* ioctl */
nodev, /* devmap */
nodev, /* mmap */
nodev, /* segmap */
nochpoll, /* poll */
ddi_prop_op, /* cb_prop_op */
0, /* streamtab */
D_NEW | D_MP /* Driver compatibility flag */
};
static struct dev_ops profile_ops = {
DEVO_REV, /* devo_rev, */
0, /* refcnt */
profile_info, /* get_dev_info */
nulldev, /* identify */
nulldev, /* probe */
profile_attach, /* attach */
profile_detach, /* detach */
nodev, /* reset */
&profile_cb_ops, /* driver operations */
NULL, /* bus operations */
nodev, /* dev power */
ddi_quiesce_not_needed, /* quiesce */
};
/*
* Module linkage information for the kernel.
*/
static struct modldrv modldrv = {
&mod_driverops, /* module type (this is a pseudo driver) */
"Profile Interrupt Tracing", /* name of module */
&profile_ops, /* driver ops */
};
static struct modlinkage modlinkage = {
MODREV_1,
(void *)&modldrv,
NULL
};
int
_init(void)
{
return (mod_install(&modlinkage));
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
int
_fini(void)
{
return (mod_remove(&modlinkage));
}
| 5,673 |
5,169 | {
"name": "SwiftPhoneFormat",
"version": "1.0.0",
"summary": "A framework for formatting phone numbers in Swift for iOS projects.",
"description": "A phone number string formatting framework designed and built for iOS in Swift.",
"homepage": "https://github.com/appteur/phoneformat.git",
"license": {
"type": "INTERNAL",
"file": "LICENSE"
},
"authors": "<NAME>",
"platforms": {
"ios": "10.0"
},
"source": {
"git": "https://github.com/appteur/phoneformat.git",
"tag": "1.0.0"
},
"source_files": [
"SwiftPhoneFormat/*.{h,m,swift}",
"UIWidgetKit/**/*.{h,m,swift}"
],
"swift_version": "4.1",
"pod_target_xcconfig": {
"SWIFT_VERSION": "4.0"
}
}
| 291 |
497 | <reponame>valentinmamontov/sgrc187
{
"name": "mongoose-deep-populate",
"version": "3.2.0",
"description": "Mongoose plugin to enable deep population of nested models",
"keywords": [
"mongo",
"mongodb",
"mongoose",
"populate",
"population",
"deep populate",
"deep population",
"models",
"nested models",
"populate models",
"model population",
"documents",
"nested documents",
"populate documents",
"documents population"
],
"main": "index.js",
"scripts": {
"test": "gulp test --db mongodb://127.0.0.1/mongoose_deep_populate_test_db"
},
"repository": {
"type": "git",
"url": "https://github.com/buunguyen/mongoose-deep-populate"
},
"author": "<NAME> <<EMAIL>> (https://github.com/buunguyen)",
"license": "MIT",
"bugs": {
"url": "https://github.com/buunguyen/mongoose-deep-populate/issues"
},
"homepage": "https://github.com/buunguyen/mongoose-deep-populate",
"devDependencies": {
"async": "^0.9.0",
"chai": "^2.1.1",
"gulp": "^3.8.11",
"gulp-exit": "0.0.2",
"gulp-jshint": "^1.9.2",
"gulp-load-plugins": "^0.8.1",
"gulp-mocha": "^2.0.0",
"jshint-stylish": "^1.0.1",
"lodash": "^3.4.0",
"minimist": "^1.1.0",
"mongoose": "^5.0.0"
}
}
| 614 |
916 | <reponame>coder-chriswang/java-study<filename>src/main/java/com/pancm/basics/AbstractTest.java<gh_stars>100-1000
package com.pancm.basics;
/**
* @author pancm
* @Data 2017-6-1
* @Description abstract 抽象类测试
*/
public class AbstractTest {
public static void main(String[] args) {
// 这句会报错，因为抽象类不能实例化
// Animal a=new Animal();
Animal a = new Dog();
a.show();
E p = new F();
p.show();
E q = new G();
q.show();
/*
*
* 1、抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。
*
* 2、抽象类不可以创建实例，原因：调用抽象方法没有意义。
*
* 3、只有覆盖了抽象类中所有的抽象方法后，其子类才可以实例化。否则该子类还是一个抽象类。
*
* 之所以继承，更多的是在思想，是面对共性类型操作会更简单。
*
*/
}
}
abstract class Animal {
abstract void show();
public void print() {
System.out.println("Animal");
}
}
class Dog extends Animal {
@Override
void show() {
System.out.println("This is Dog!");
}
}
abstract class E {
public abstract void show();
}
class F extends E {
public void show() {
System.out.print("test all FFFF \n");
}
}
class G extends E {
public void show() {
System.out.print("test all GGGG \n");
}
}
| 710 |
340 | # Copyright (c) 2019, NVIDIA CORPORATION. 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.
# pylint: disable=invalid-name, too-few-public-methods
# pylint: disable=too-many-instance-attributes
"""Kokkos building block"""
from __future__ import absolute_import
from __future__ import unicode_literals
from __future__ import print_function
from distutils.version import StrictVersion
import hpccm.config
import hpccm.templates.downloader
import hpccm.templates.envvars
from hpccm.building_blocks.base import bb_base
from hpccm.building_blocks.generic_cmake import generic_cmake
from hpccm.building_blocks.packages import packages
from hpccm.common import linux_distro
from hpccm.primitives.comment import comment
class kokkos(bb_base, hpccm.templates.downloader, hpccm.templates.envvars):
"""The `kokkos` building block downloads and installs the
[Kokkos](https://github.com/kokkos/kokkos) component.
The [CMake](#cmake) building block should be installed prior to
this building block.
# Parameters
annotate: Boolean flag to specify whether to include annotations
(labels). The default is False.
arch: List of target architectures to build. If set adds
`-DKokkos_ARCH_<value>=ON` to the list of CMake options. The
default value is `VOLTA70`, i.e., sm_70. If a CUDA aware build is
not selected, then a non-default value should be used.
branch: The git branch to clone. Only recognized if the
`repository` parameter is specified. The default is empty, i.e.,
use the default branch for the repository.
check: Boolean flag to specify whether the build should be
checked. If True, adds `-DKokkos_ENABLE_TESTS=ON` to the list of
CMake options. The default is False.
cmake_opts: List of options to pass to `cmake`. The default is
`-DCMAKE_BUILD_TYPE=RELEASE`.
commit: The git commit to clone. Only recognized if the
`repository` parameter is specified. The default is empty, i.e.,
use the latest commit on the default branch for the repository.
cuda: Flag to control whether a CUDA aware build is performed. If
True, adds `-DKokkos_ENABLE_CUDA=ON` and
`-DCMAKE_CXX_COMPILER=$(pwd)/../bin/nvcc_wrapper` to the list of
CMake options. The default value is True.
environment: Boolean flag to specify whether the environment
(`LD_LIBRARY_PATH` and `PATH`) should be modified to include
Kokkos. The default is True.
hwloc: Flag to control whether a hwloc aware build is performed.
If True, adds `-DKokkos_ENABLE_HWLOC=ON` to the list of CMake
options. The default value is True.
ospackages: List of OS packages to install prior to building. For
Ubuntu, the default values are `gzip`, `libhwloc-dev`, `make`,
`tar`, and `wget`. For RHEL-based Linux distributions the default
values are `gzip`, `hwloc-devel`, `make`, `tar`, and `wget`.
prefix: The top level installation location. The default value
is `/usr/local/kokkos`.
repository: The location of the git repository that should be used to build OpenMPI. If True, then use the default `https://github.com/kokkos/kokkos.git`
repository. The default is empty, i.e., use the release package
specified by `version`.
url: The location of the tarball that should be used to build
Kokkos. The default is empty, i.e., use the release package
specified by `version`.
version: The version of Kokkos source to download. The default
value is `3.2.00`.
# Examples
```python
kokkos(prefix='/opt/kokkos/3.1.01', version='3.1.01')
```
"""
def __init__(self, **kwargs):
"""Initialize building block"""
super(kokkos, self).__init__(**kwargs)
self.__arch = kwargs.pop('arch', ['VOLTA70'])
self.__baseurl = kwargs.pop('baseurl',
'https://github.com/kokkos/kokkos/archive')
self.__check = kwargs.pop('check', False)
self.__cmake_opts = kwargs.pop('cmake_opts',
['-DCMAKE_BUILD_TYPE=RELEASE'])
self.__cuda = kwargs.pop('cuda', True)
self.__default_repository = 'https://github.com/kokkos/kokkos.git'
self.__hwloc = kwargs.pop('hwloc', True)
self.__ospackages = kwargs.pop('ospackages', [])
self.__powertools = False # enable the CentOS PowerTools repo
self.__prefix = kwargs.pop('prefix', '/usr/local/kokkos')
self.__version = kwargs.pop('version', '3.2.00')
if self.repository:
self.__directory = ''
else:
self.__directory = kwargs.pop('directory',
'kokkos-{}'.format(self.__version))
# Set the CMake options
self.__cmake()
# Set the Linux distribution specific parameters
self.__distro()
# Set the download specific parameters
self.__download()
kwargs['repository'] = self.repository
kwargs['url'] = self.url
# Setup the environment variables
self.environment_variables['PATH'] = '{}/bin:$PATH'.format(
self.__prefix)
# Setup build configuration
self.__bb = generic_cmake(
annotations={'version': self.__version},
base_annotation=self.__class__.__name__,
cmake_opts=self.__cmake_opts,
comment=False,
devel_environment=self.environment_variables,
directory=self.__directory,
prefix=self.__prefix,
runtime_environment=self.environment_variables,
**kwargs)
# Container instructions
self += comment('Kokkos version {}'.format(self.__version))
self += packages(ospackages=self.__ospackages,
powertools=self.__powertools)
self += self.__bb
def __cmake(self):
"""Set CMake options based on user input"""
# Set options
if self.__arch:
for arch in self.__arch:
self.__cmake_opts.append('-DKokkos_ARCH_{}=ON'.format(
arch.upper()))
if self.__check:
self.__cmake_opts.append('-DKokkos_ENABLE_TESTS=ON')
if self.__cuda:
self.__cmake_opts.append('-DKokkos_ENABLE_CUDA=ON')
self.__cmake_opts.append(
'-DCMAKE_CXX_COMPILER=$(pwd)/../bin/nvcc_wrapper')
if self.__hwloc:
self.__cmake_opts.append('-DKokkos_ENABLE_HWLOC=ON')
def __distro(self):
"""Based on the Linux distribution, set values accordingly. A user
specified value overrides any defaults."""
if hpccm.config.g_linux_distro == linux_distro.UBUNTU:
if not self.__ospackages:
self.__ospackages = ['libhwloc-dev', 'make']
elif hpccm.config.g_linux_distro == linux_distro.CENTOS:
if not self.__ospackages:
self.__ospackages = ['hwloc-devel', 'make']
if hpccm.config.g_linux_version >= StrictVersion('8.0'):
# hwloc-devel is in the CentOS powertools repository
self.__powertools = True
else: # pragma: no cover
raise RuntimeError('Unknown Linux distribution')
if self.repository:
self.__ospackages.extend(['ca-certificates', 'git'])
else:
self.__ospackages.extend(['gzip', 'tar', 'wget'])
def __download(self):
"""Set download source based on user parameters"""
# Use the default repository if set to True
if self.repository is True:
self.repository = self.__default_repository
if not self.repository and not self.url:
self.url='{0}/{1}.tar.gz'.format(self.__baseurl, self.__version)
def runtime(self, _from='0'):
"""Generate the set of instructions to install the runtime specific
components from a build in a previous stage.
# Examples
```python
k = kokkos(...)
Stage0 += k
Stage1 += k.runtime()
```
"""
self.rt += comment('Kokkos')
self.rt += self.__bb.runtime(_from=_from)
return str(self.rt)
| 3,533 |
4,407 | <reponame>Anita1017/nlp-recipes
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
import argparse
import os
import sys
import time
import torch
import torch.distributed as dist
import torch.multiprocessing as mp
# torch.set_printoptions(threshold=5000)
nlp_path = os.path.abspath("../../")
if nlp_path not in sys.path:
sys.path.insert(0, nlp_path)
sys.path.insert(0, "./")
from utils_nlp.models.transformers.abstractive_summarization_bertsum import (
BertSumAbs,
BertSumAbsProcessor,
validate,
)
from utils_nlp.dataset.cnndm import CNNDMSummarizationDataset
os.environ["NCCL_IB_DISABLE"] = "0"
# os.environ["NCCL_DEBUG"] = "INFO"
os.environ["NCCL_DEBUG_SUBSYS"] = "ALL"
# os.environ["MASTER_PORT"] = "29952"
# os.environ["MASTER_ADDR"] = "192.168.3.11"
# os.environ['NCCL_SOCKET_IFNAME'] = 'lo'
parser = argparse.ArgumentParser()
parser.add_argument(
"--rank", type=int, default=0, help="The rank of the current node in the cluster"
)
parser.add_argument(
"--dist_url",
type=str,
default="tcp://127.0.0.1:29507",
help="URL specifying how to initialize the process groupi.",
)
parser.add_argument(
"--node_count", type=int, default=1, help="Number of nodes in the cluster."
)
parser.add_argument(
"--cache_dir",
type=str,
default="./abstemp",
help="Directory to cache the tokenizer.",
)
parser.add_argument(
"--data_dir",
type=str,
default="./abstemp",
help="Directory to download the preprocessed data.",
)
parser.add_argument(
"--output_dir",
type=str,
default="./abstemp",
help="Directory to save the output model and prediction results.",
)
parser.add_argument(
"--quick_run",
type=str.lower,
default="false",
choices=["true", "false"],
help="Whether to have a quick run",
)
parser.add_argument(
"--model_name",
type=str,
default="bert-base-uncased",
help='Transformer model used in the summarization model, only \
"bert-uncased" is supported so far.',
)
parser.add_argument(
"--lr_bert", type=float, default=2e-3, help="Learning rate for the BERT encoder."
)
parser.add_argument(
"--lr_dec", type=float, default=2e-1, help="Learning rate for the decoder."
)
parser.add_argument(
"--batch_size",
type=int,
default=5,
help="batch size in terms of input token numbers in training",
)
parser.add_argument(
"--max_pos_length",
type=int,
default=512,
help="maximum input length in terms of input token numbers in training",
)
parser.add_argument(
"--max_steps",
type=int,
default=5e4,
help="""Maximum number of training steps run in training.
If quick_run is set, it's not used.""",
)
parser.add_argument(
"--warmup_steps_bert",
type=int,
default=2e4,
help="Warm-up number of training steps run in training for the encoder. \
If quick_run is set, it's not used.",
)
parser.add_argument(
"--warmup_steps_dec",
type=int,
default=1e4,
help="Warm-up number of training steps run in training for the decoder. \
If quick_run is set, it's not used.",
)
parser.add_argument(
"--summary_filename",
type=str,
default="generated_summaries.txt",
help="Summary file name generated by prediction for evaluation.",
)
parser.add_argument(
"--model_filename",
type=str,
default="dist_abssum_model.pt",
help="model file name saved for evaluation.",
)
parser.add_argument(
"--checkpoint_filename",
type=str,
default=None,
help="filename of a checkpoint where the trainging resumes from. \
default path is at cache_dir",
)
parser.add_argument(
"--report_every",
type=int,
default=10,
help="number of steps between each loss report",
)
parser.add_argument(
"--save_every",
type=int,
default=500,
help="number of steps between each model save and validation",
)
parser.add_argument(
"--fp16",
type=str.lower,
default="false",
choices=["true", "false"],
help="Whether to use mixed precision training",
)
parser.add_argument(
"--fp16_opt_level",
type=str.upper,
default="O2",
choices=["O0", "O1", "O2", "O3"],
help="optimization level, refer to \
https://nvidia.github.io/apex/amp.html#opt-levels for details ",
)
def main():
args = parser.parse_args()
print("NCCL_IB_DISABLE: {}".format(os.getenv("NCCL_IB_DISABLE")))
print("quick_run is {}".format(args.quick_run))
print("output_dir is {}".format(args.output_dir))
print("data_dir is {}".format(args.data_dir))
print("cache_dir is {}".format(args.cache_dir))
TOP_N = -1
if args.quick_run.lower() == "false":
TOP_N = 10
train_dataset, test_dataset = CNNDMSummarizationDataset(
top_n=TOP_N, local_cache_path=args.data_dir, prepare_extractive=False
)
ngpus_per_node = torch.cuda.device_count()
processor = BertSumAbsProcessor(
cache_dir=args.cache_dir, max_src_len=args.max_pos_length
)
summarizer = BertSumAbs(
processor, cache_dir=args.cache_dir, max_pos_length=args.max_pos_length
)
mp.spawn(
main_worker,
nprocs=ngpus_per_node,
args=(ngpus_per_node, summarizer, train_dataset, test_dataset, args),
)
def main_worker(
local_rank, ngpus_per_node, summarizer, train_dataset, test_dataset, args
):
rank = args.rank * ngpus_per_node + local_rank
world_size = args.node_count * ngpus_per_node
print("world_size is {}".format(world_size))
print("local_rank is {} and rank is {}".format(local_rank, rank))
torch.distributed.init_process_group(
backend="nccl", init_method=args.dist_url, world_size=world_size, rank=rank,
)
# return
## should not load checkpoint from this place, otherwise, huge memory increase
if args.checkpoint_filename:
checkpoint = os.path.join(args.cache_dir, args.checkpoint_filename)
else:
checkpoint = None
# train_sum_dataset, test_sum_dataset = load_processed_cnndm_abs(args.data_dir)
def this_validate(class_obj):
return validate(class_obj, test_dataset)
if rank not in [-1, 0]:
save_every = -1
this_validate = None
else:
save_every = args.save_every
fp16 = args.fp16.lower() == "true"
print("fp16 is {}".format(fp16))
# total number of steps for training
MAX_STEPS = 10
SAVE_EVERY = 10
REPORT_EVERY = 10
# number of steps for warm up
WARMUP_STEPS_BERT = MAX_STEPS
WARMUP_STEPS_DEC = MAX_STEPS
if args.quick_run.lower() == "false":
MAX_STEPS = args.max_steps
WARMUP_STEPS_BERT = args.warmup_steps_bert
WARMUP_STEPS_DEC = args.warmup_steps_dec
SAVE_EVERY = save_every
REPORT_EVERY = args.report_every
print("max steps is {}".format(MAX_STEPS))
print("warmup steps for encoder bert is {}".format(WARMUP_STEPS_BERT))
print("warmup steps for decoder is {}".format(WARMUP_STEPS_DEC))
start = time.time()
# summarizer.model.load_checkpoint(checkpoint['model'])
summarizer.fit(
train_dataset,
world_size=world_size,
num_gpus=None,
local_rank=local_rank,
rank=rank,
batch_size=args.batch_size,
max_steps=MAX_STEPS / world_size,
learning_rate_bert=args.lr_bert,
learning_rate_dec=args.lr_dec,
warmup_steps_bert=WARMUP_STEPS_BERT,
warmup_steps_dec=WARMUP_STEPS_DEC,
save_every=SAVE_EVERY,
report_every=REPORT_EVERY,
validation_function=this_validate,
fp16=fp16,
fp16_opt_level=args.fp16_opt_level,
checkpoint=checkpoint,
)
end = time.time()
print("rank {0}, duration {1:.6f}s".format(rank, end - start))
if local_rank in [0, -1] and args.rank == 0:
TOP_N = -1
if args.quick_run.lower() == "false":
TOP_N = ngpus_per_node
saved_model_path = os.path.join(
args.output_dir, "{}_step{}".format(args.model_filename, MAX_STEPS)
)
summarizer.save_model(MAX_STEPS, saved_model_path)
prediction = summarizer.predict(
test_dataset.shorten(top_n=TOP_N), batch_size=ngpus_per_node, num_gpus=ngpus_per_node
)
print(prediction[0])
def _write_list_to_file(list_items, filename):
with open(filename, "w") as filehandle:
# for cnt, line in enumerate(filehandle):
for item in list_items:
filehandle.write("%s\n" % item)
print("writing generated summaries")
_write_list_to_file(
prediction, os.path.join(args.output_dir, args.summary_filename)
)
# only use the following line when you use your own cluster.
# AML distributed training run cleanup for you.
dist.destroy_process_group()
if __name__ == "__main__":
main()
| 3,787 |
2,151 | <gh_stars>1000+
/*
* Copyright (c) 2013 The WebRTC 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 in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*
* Some code in this file was originally from file omxSP_FFTGetBufSize_R_S32.c
* which was licensed as follows.
* It has been relicensed with permission from the copyright holders.
*/
/*
* OpenMAX DL: v1.0.2
* Last Modified Revision:
* Last Modified Date:
*/
#include "dl/api/arm/armOMX.h"
#include "dl/api/omxtypes.h"
#include "dl/sp/api/armSP.h"
#include "dl/sp/api/omxSP.h"
/**
* Function: omxSP_FFTGetBufSize_R_S16
*
* Description:
* Computes the size of the specification structure required for the length
* 2^order real FFT and IFFT functions.
*
* Remarks:
* This function is used in conjunction with the 16-bit functions
* <FFTFwd_RToCCS_S16_Sfs> and <FFTInv_CCSToR_S16_Sfs>.
*
* Parameters:
* [in] order base-2 logarithm of the length; valid in the range
* [1,12].
* [out] pSize pointer to the number of bytes required for the
* specification structure.
*
* Return Value:
* Standard omxError result. See enumeration for possible result codes.
*
*/
OMXResult omxSP_FFTGetBufSize_R_S16(OMX_INT order, OMX_INT *pSize) {
OMX_INT NBy2,N,twiddleSize;
/* Order zero not allowed */
if (order == 0) {
return OMX_Sts_BadArgErr;
}
NBy2 = 1 << (order - 1);
N = NBy2 << 1;
twiddleSize = 5 * N / 8; /* 3 / 4 (N / 2) + N / 4 */
/* 2 pointers to store bitreversed array and twiddle factor array */
*pSize = sizeof(ARMsFFTSpec_R_SC16)
/* Twiddle factors */
+ sizeof(OMX_SC16) * twiddleSize
/* Ping Pong buffer for doing the N/2 point complex FFT; */
/* extra size 'N' as a temporary buf for FFTInv_CCSToR_S16_Sfs */
+ sizeof(OMX_S16) * (N << 1)
/* Extra bytes to get 32 byte alignment of ptwiddle and pBuf */
+ 62 ;
return OMX_Sts_NoErr;
}
/*****************************************************************************
* END OF FILE
*****************************************************************************/
| 887 |
971 | package com.ucar.datalink.biz.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.ucar.datalink.biz.service.JobControlService;
import com.ucar.datalink.biz.service.JobService;
import com.ucar.datalink.biz.utils.flinker.FlinkerJobUtil;
import com.ucar.datalink.biz.utils.URLConnectionUtil;
import com.ucar.datalink.domain.job.JobCommand;
import com.ucar.datalink.domain.job.JobConfigInfo;
import com.ucar.datalink.domain.job.JobExecutionInfo;
import com.ucar.datalink.domain.job.JobExecutionState;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.sql.Timestamp;
import java.util.Date;
import java.util.List;
/**
* Created by user on 2017/9/21.
*/
@Service("dynamic")
public class JobServiceDynamicArgs implements JobControlService {
private static final Logger logger = LoggerFactory.getLogger(JobServiceDynamicArgs.class);
@Autowired
JobService jobService;
@Override
public String start(JobCommand command, Object additional) {
String workerAddress = (String)additional;
if(StringUtils.isBlank(workerAddress)) {
workerAddress = FlinkerJobUtil.dynamicChoosenDataxMacheine();
}
if(StringUtils.isBlank(workerAddress)) {
throw new RuntimeException("work address is emtpy");
}
command.setDebug(false);
String json = JSONObject.toJSONString(command);
logger.info("[JobServiceDynamicArgs]worker address="+workerAddress);
logger.info("[JobServiceDynamicArgs]json content="+json);
String address = FlinkerJobUtil.startURL(workerAddress);
Timestamp start_time = new Timestamp(new Date().getTime());
String result = URLConnectionUtil.retryPOST(address, json);
if (result != null && result.contains("failure")) {
logger.error("invoke datax failure,"+result);
return "-1";
}
long id = command.getJobId();
JobConfigInfo info = jobService.getJobConfigById(id);
int count = 0;
JobExecutionInfo executionInfo = null;
while (true) { //这个while循环的目的是判断任务是否启动了，任务启动后会在zookeeper上注册
if (count > 20) {
throw new RuntimeException("[JobServiceDynamicArgs]job start check failure,count > 20");
}
try {
Thread.sleep(1000);
count++;
} catch (InterruptedException e) {
throw new RuntimeException("[JobServiceDynamicArgs] job start check failure(interrupted exception)");
}
executionInfo = jobService.getJobExecutionById( Long.parseLong(result) );
//如果获取到的job状态不是 UNEXECUTE 未初始化则返回
if( executionInfo!=null && !JobExecutionState.UNEXECUTE.equals(executionInfo.getState()) ) {
break;
}
}
logger.info("[JobServiceDynamicArgs] " + executionInfo.toString());
return executionInfo.getId()+"";
}
@Override
public List<JobExecutionInfo> history(long id) {
List<JobExecutionInfo> list = jobService.getJobExecutionByJobId(id);
return list;
}
@Override
public List<JobExecutionInfo> history(long jobId,long startPage,long count) {
return jobService.getJobExecutionByJobId(jobId,startPage,count);
}
@Override
public JobExecutionInfo state(long id) {
return jobService.getJobExecutionById(id);
}
}
| 1,490 |
2,637 | /* Copyright Statement:
*
* (C) 2005-2016 MediaTek Inc. All rights reserved.
*
* This software/firmware and related documentation ("MediaTek Software") are
* protected under relevant copyright laws. The information contained herein
* is confidential and proprietary to MediaTek Inc. ("MediaTek") and/or its licensors.
* Without the prior written permission of MediaTek and/or its licensors,
* any reproduction, modification, use or disclosure of MediaTek Software,
* and information contained herein, in whole or in part, shall be strictly prohibited.
* You may only use, reproduce, modify, or distribute (as applicable) MediaTek Software
* if you have agreed to and been bound by the applicable license agreement with
* MediaTek ("License Agreement") and been granted explicit permission to do so within
* the License Agreement ("Permitted User"). If you are not a Permitted User,
* please cease any access or use of MediaTek Software immediately.
* BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
* THAT MEDIATEK SOFTWARE RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES
* ARE PROVIDED TO RECEIVER ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
* WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
* SUPPLIED WITH MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
* THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
* CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
* SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
* STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
* CUMULATIVE LIABILITY WITH RESPECT TO MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE MEDIATEK SOFTWARE AT ISSUE,
* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*/
/**
* @file dma_sw.h
*
* This header file exposes the API for DMA.
*
*/
#ifndef _DMA_SW_H
#define _DMA_SW_H
#include "hal_platform.h"
#ifdef HAL_GDMA_MODULE_ENABLED
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
#define DMA_CON_MASTER_I2C1_TX 0x02
#define DMA_CON_MASTER_I2C1_RX 0x03
#define DMA_CON_MASTER_I2C2_TX 0x04
#define DMA_CON_MASTER_I2C2_RX 0x05
#define DMA_CON_MASTER_I2S_TX 0x06
#define DMA_CON_MASTER_I2S_RX 0x07
#define DMA_CON_MASTER_UART1TX 0x08
#define DMA_CON_MASTER_UART1RX 0x09
#define DMA_CON_MASTER_UART2TX 0x0A
#define DMA_CON_MASTER_UART2RX 0x0B
#define DMA_CON_MASTER_BTIF_TX 0x0C
#define DMA_CON_MASTER_BTIF_RX 0x0D
#define DMA_CON_MASTER_EP2I_TX 0x0E
#define DMA_CON_MASTER_EP2O_RX 0x0F
#define DMA_CON_MASTER_EP3I_TX 0x10
#define DMA_CON_MASTER_EP3O_RX 0x11
#define DMA_CON_MASTER_EP4I_TX 0x12
#define DMA_CON_MASTER_EP4O_RX 0x13
#define DMA_CON_MASTER_ADC_RX 0x14
#define DMA_CON_MASTER_HIF_TRX 0x15
#define DMA_CON_MASTER_SPIM_TX 0x16
#define DMA_CON_MASTER_SPIM_RX 0x17
#define DMA_VFIFO_CH_S 12 /* VFIFO start channel */
#define DMA_VFIFO_CH_E 25 /* VFIFO end channel */
#define DMA_MAX_CHANNEL 11 // not include VFF DMA
#define DMA_MAX_FULL_CHANNEL 2
typedef enum {
DMA_I2C1_TX = DMA_CON_MASTER_I2C1_TX,
DMA_I2C1_RX,
DMA_I2C2_TX,
DMA_I2C2_RX,
DMA_I2S_TX,
DMA_I2S_RX,
DMA_UART1TX,
DMA_UART1RX,
DMA_UART2TX,
DMA_UART2RX,
DMA_BTIF_TX,
DMA_BTIF_RX,
DMA_EP2I_TX,
DMA_EP2O_RX,
DMA_EP3I_TX,
DMA_EP3O_RX,
DMA_EP4IH_TX,
DMA_EP4IV_TX,
DMA_EP4O_RX,
DMA_ADC_RX,
DMA_HIF_TRX,
DMA_SPIM_TX,
DMA_SPIM_RX,
DMA_SW,
DMA_IDLE
} DMA_Master;
typedef enum {
DMA_BYTE = 0,
DMA_SHORT,
DMA_LONG
} DMA_TranSize;
typedef enum {
DMA_HWTX, /* use DMA_HWMENU, from RAM to register */
DMA_HWRX, /* use DMA_HWMENU, from register to RAM */
DMA_SWCOPY, /* use DMA_SWCOPYMENU, from RAM to RAM */
DMA_HWTX_RINGBUFF, /* use DMA_HWRINGBUFF_MENU, from RAM to register */
DMA_HWRX_RINGBUFF /* use DMA_HWRINGBUFF_MENU, from register to RAM */
} DMA_Type;
typedef struct {
bool burst_mode; /* burst mode = 0 ==> single mode */
uint8_t cycle; /* active only when (burst_mode == TRUE) */
} DMA_TMODE;
typedef enum {
VDMA_I2S_TX_CH = DMA_VFIFO_CH_S,
VDMA_I2S_RX_CH,
VDMA_UART1TX_CH,
VDMA_UART1RX_CH,
VDMA_UART2TX_CH,
VDMA_UART2RX_CH,
VDMA_BTIF_TX_CH,
VDMA_BTIF_RX_CH,
VDMA_USB_EP2O_CH,
VDMA_USB_EP3I_CH,
VDMA_USB_EP3O_CH,
VDMA_USB_EP4I_CH,
VDMA_USB_EP4O_CH,
VDMA_ADC_RX_CH,
} DMA_VFIFO_CHANNEL;
typedef struct {
DMA_TMODE TMOD;
DMA_Master master;
uint32_t addr;
void *WPPT;
void *WPTO;
} DMA_HWRINGBUFF_MENU;
typedef struct {
DMA_TMODE TMOD;
DMA_Master master;
uint32_t addr;
} DMA_HWMENU;
typedef struct {
DMA_TMODE TMOD;
DMA_Master master;
uint32_t source;
uint32_t destination;
void *WPPT;
void *WPTO;
} DMA_FULLSIZE_HWRINGBUFF_MENU;
typedef struct {
DMA_TMODE TMOD;
DMA_Master master;
uint32_t source;
uint32_t destination;
} DMA_FULLSIZE_HWMENU;
typedef struct {
uint32_t srcaddr;
uint32_t dstaddr;
} DMA_SWCOPYMENU;
typedef union {
DMA_HWMENU menu_hw;
DMA_HWRINGBUFF_MENU menu_hw_ringbuff;
DMA_SWCOPYMENU menu_swcopy;
DMA_FULLSIZE_HWMENU menu_fullsize_hw;
DMA_FULLSIZE_HWRINGBUFF_MENU menu_fullsize_hw_ringbuff;
} DMA_MENU;
typedef struct {
DMA_Type type;
DMA_TranSize size;
uint32_t count;
void *menu;
void (*callback)(void);
} DMA_INPUT;
typedef void (* VOID_FUNC)(void);
#define DMA_Start(_n) DRV_WriteReg32(DMA_START(_n), DMA_START_BIT)
#define DMA_Stop_Now(_n) DRV_WriteReg32(DMA_START(_n), DMA_STOP_BIT)
#define DMA_GetCount(_n) DRV_Reg32(DMA_COUNT(_n))
#define DMA_ACKI(_n) DRV_WriteReg32(DMA_ACKINT(_n), DMA_ACKINT_BIT)
#define DMA_ACKTOI(_n) DRV_WriteReg32(DMA_ACKINT(_n), DMA_ACKTOINT_BIT)
#define DMA_CheckRunStat(_n) ( _n > 16 ? ((DRV_Reg32(DMA_GLBSTA1) & DMA_GLBSTA_RUN(_n)) != 0) : ((DRV_Reg32(DMA_GLBSTA0) & DMA_GLBSTA_RUN(_n)) != 0))
#define DMA_CheckITStat(_n) ( _n > 16 ? ((DRV_Reg32(DMA_GLBSTA1) & DMA_GLBSTA_IT(_n)) != 0) : ((DRV_Reg32(DMA_GLBSTA0) & DMA_GLBSTA_IT(_n)) != 0))
#define DMA_WaitUntilRdy(_n) while(DMA_CheckRunStat(_n))
#define DMA_Config(dma_no, dma_menu, start) DMA_Config_Internal(dma_no, dma_menu, false, false, 0, start)
#define DMA_FullSize_Config(dma_no, dma_menu, start) DMA_Config_Internal(dma_no, dma_menu, true, false, 0, start)
#define DMA_Config_B2W(dma_no, dma_menu, start, b2w) DMA_Config_Internal(dma_no, dma_menu, false, b2w, 0, start)
#define DMA_Vfifo_Get_Read_Pointer(uart_port) DRV_Reg32(DMA_RDPTR(UARTPort[uart_port].Rx_DMA_Ch))
#define DMA_Vfifo_Get_Write_Pointer(uart_port) DRV_Reg32(DMA_WRPTR(UARTPort[uart_port].Rx_DMA_Ch))
/**
* @brief Initialize DMA hardware
*
* @param void
*
* @return void
*
* @note Initialize the DMA before operations.
*/
void DMA_Init(void);
/**
* @brief Stop the DMA channel
*
* @param channel [IN] the number of operating channel
*
* @return void
*
* @note Stop the specified DMA channel
*/
void DMA_Stop(uint8_t channel);
/**
* @brief Start the DMA channel
*
* @param channel [IN] the number of operating channel
*
* @return void
*
* @note Start the specified DMA channel
*/
void DMA_Run(uint8_t channel);
/**
* @brief Get the half-size DMA channel
*
* @param DMA_CODE [IN] the peripheral on which for DMA operating
*
* @return the channel number of DMA to work with specified peripheral
*
* @note Get a channel of half-sized DMA to perform data movement
*/
uint8_t DMA_GetChannel(DMA_Master DMA_CODE);
/**
* @brief Free the half-size DMA channel
*
* @param handle [IN] the number of operating channel
*
* @return void
*
* @note Free the resource of the specified DMA channel
*/
void DMA_FreeChannel(uint8_t handle);
/**
* @brief full-size DMA channel get valid channel
*
* @param DMA_CODE [IN] the peripheral owns the DMA resource
*
* @param channel [IN] full channel dma number
*
* @return channel number
*
* @note full-sized DMA init for performing data movement
*/
uint8_t DMA_FullSize_CheckIdleChannel(DMA_Master DMA_CODE, uint8_t channel);
/**
* @brief Free the full-size DMA channel
*
* @param handle [IN] the number of operating channel
*
* @return void
*
* @note Free the resource of the specified DMA channel
*/
void DMA_FullSize_FreeChannel(uint8_t handle);
/**
* @brief Config the DMA channel
*
* @param dma_no [IN] the number of operating channel
* @param dma_menu [IN] the parameters for setting the DMA
* @param fullsize [IN] specify if full-size DMA
* @param b2w [IN] specify if enable the byte to word function
* @param limit [IN] specify if the limitation function is used
* @param start [IN] specify if the DMA starts after configured
*
* @return void
*
* @note Config the DMA after got a DMA resource
*/
void DMA_Config_Internal(uint8_t dma_no,
DMA_INPUT *dma_menu,
bool fullsize,
bool b2w, uint8_t limit,
bool start);
/**
* @brief Configure the DMA throttle and handshake control
*
* @param handle [IN] the number of operating channel
* @param enable [IN] specify if the DRQ function is enabled
*
* @return void
*
* @note Set the DMA DRQ function before use
*/
void DMA_DRQ(uint8_t dma_no,
uint8_t enable);
/**
* @brief Initialize the DMA VFIFO
*
* @param void
*
* @return void
*
* @note Initialize the DMA VFIFO hardware
*/
void DMA_Vfifo_init(void);
/**
* @brief Configure the DMA VFIFO
*
* @param adrs [IN] the start address of VFIFO buffer
* @param len [IN] the length of VFIFO buffer
* @param ch [IN] the VFIFO channel to configure
* @param alt_len [IN] the alert length of VFIFO
* @param dma_count [IN] the threshold for triggering the interrupt to MCU
* @param timeout_counter [IN] the timeout for triggering the interrupt to MCU
*
* @return void
*
* @note Configure the DMA VFIFO channel
*/
void DMA_Vfifo_SetAdrs(uint32_t adrs,
uint32_t len, DMA_VFIFO_CHANNEL ch,
uint32_t alt_len,
uint32_t dma_count,
uint32_t timeout_counter);
void DMA_Vfifo_Set_timeout(DMA_VFIFO_CHANNEL ch, uint32_t timeout_counter);
void DMA_Vfifo_enable_interrupt(DMA_VFIFO_CHANNEL ch);
void DMA_Vfifo_disable_interrupt(DMA_VFIFO_CHANNEL ch);
/**
* @brief Flush the DMA VFIFO
*
* @param ch [IN] the VFIFO channel to flush
*
* @return void
*
* @note Flush the DMA VFIFO channel
*/
void DMA_Vfifo_Flush(DMA_VFIFO_CHANNEL ch);
/**
* @brief Register the callback function for threshold interrupt
*
* @param ch [IN] the interrupt source VFIFO channel
* @param callback_func [IN] callback function to handle the interrupt
*
* @return void
*
* @note Register the callback function for threshold interrupt
*/
void DMA_Vfifo_Register_Callback(DMA_VFIFO_CHANNEL ch,
VOID_FUNC callback_func);
/**
* @brief Register the callback function for timeout interrupt
*
* @param ch [IN] the interrupt source VFIFO channel
* @param callback_func [IN] callback function to handle the interrupt
*
* @return void
*
* @note Register the callback function for timeout interrupt
*/
void DMA_Vfifo_Register_TO_Callback(DMA_VFIFO_CHANNEL ch,
VOID_FUNC callback_func);
/**
* @brief Enable the power and clock for the DMA channel
*
* @param channel [IN] the operating DMA channel
*
* @return void
*
* @note Enable the clock of DMA before use
*/
void DMA_Clock_Enable(uint8_t channel);
/**
* @brief Disable the power and clock for the DMA channel
*
* @param channel [IN] the operating DMA channel
*
* @return void
*
* @note Disable the clock of DMA after use
*/
void DMA_Clock_Disable(uint8_t channel);
/**
* @brief Register the callback function for receiving DMA done event
*
* @param dma_ch [IN] the interrupt source DMA channel
* @param handler [IN] callback function to handle the interrupt
*
* @return void
*
* @note Register the callback function for DMA done event
*/
int DMA_Register(uint8_t dma_ch, VOID_FUNC handler);
/**
* @brief De-register the callback function for receiving DMA done event
*
* @param dma_ch [IN] the interrupt source DMA channel
*
* @return void
*
* @note De-register the callback function for DMA done event
*/
int DMA_UnRegister(uint8_t dma_ch);
bool DMA_memcpy(const void *src, const void *dst, unsigned int length);
uint8_t dma_set_channel_idle(uint8_t channel);
uint8_t dma_set_channel_busy(uint8_t channel);
#ifdef __cplusplus
}
#endif
#endif //#ifdef HAL_GDMA_MODULE_ENABLED
#endif /*_DMA_SW_H*/
| 6,438 |
1,405 | package com.lenovo.safecenter.aidl.healthcheck;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.text.TextUtils;
import android.util.Log;
import com.lenovo.safecenter.HealthCheck.HealthCheckCallback;
import com.lenovo.safecenter.HealthCheck.HealthItemResult;
import com.lenovo.safecenter.HealthCheck.HealthManager;
import com.lenovo.safecenter.HealthCheck.util.HealthStatus;
import com.lenovo.safecenter.HealthCheck.util.HealthViewType;
import com.lenovo.safecenter.aidl.JsonUtil;
import com.lenovo.safecenter.aidl.healthcheck.IRemoteHealthCheckService;
import com.lenovo.safecenter.floatwindow.util.SettingUtil;
import com.lenovo.safecenter.utils.TrackEvent;
import java.util.ArrayList;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.json.JSONTokener;
public class RemoteHealthCheckService extends Service {
public static final String COMMAND_ACTION_HEALTH_CANCEL_OPTIMIZE = "health_canceloptimize";
public static final String COMMAND_ACTION_HEALTH_CANCEL_SCAN = "health_cancelscan";
public static final String COMMAND_ACTION_HEALTH_OPTIMIZE = "health_optimize";
public static final String COMMAND_ACTION_HEALTH_SCAN = "health_scan";
final RemoteCallbackList<IRemoteHealthCheckCallback> a = new RemoteCallbackList<>();
private HealthManager b;
private final IRemoteHealthCheckService.Stub c = new IRemoteHealthCheckService.Stub() {
/* class com.lenovo.safecenter.aidl.healthcheck.RemoteHealthCheckService.AnonymousClass1 */
@Override // com.lenovo.safecenter.aidl.healthcheck.IRemoteHealthCheckService
public final void registerCallback(IRemoteHealthCheckCallback cb) {
if (cb != null) {
RemoteHealthCheckService.this.a.register(cb);
}
}
@Override // com.lenovo.safecenter.aidl.healthcheck.IRemoteHealthCheckService
public final void unregisterCallback(IRemoteHealthCheckCallback cb) {
if (cb != null) {
RemoteHealthCheckService.this.a.unregister(cb);
}
}
@Override // com.lenovo.safecenter.aidl.healthcheck.IRemoteHealthCheckService
public final void receiveCommand(String command) throws RemoteException {
try {
Log.i("wu0wu", "command=" + command);
JSONObject object = (JSONObject) new JSONTokener(command).nextValue();
String action = null;
if (object.has("action")) {
action = object.getString("action");
}
String context = null;
if (object.has("context")) {
context = object.getString("context");
}
Log.i("wu0wu", "action=" + action);
Log.i("wu0wu", "context=" + context);
if (TextUtils.isEmpty(action)) {
return;
}
if (RemoteHealthCheckService.COMMAND_ACTION_HEALTH_SCAN.equals(action)) {
RemoteHealthCheckService.a(RemoteHealthCheckService.this, context);
} else if (RemoteHealthCheckService.COMMAND_ACTION_HEALTH_CANCEL_SCAN.equals(action)) {
RemoteHealthCheckService.a(RemoteHealthCheckService.this);
} else if (RemoteHealthCheckService.COMMAND_ACTION_HEALTH_OPTIMIZE.equals(action)) {
ArrayList<Integer> keysList = new ArrayList<>();
if (object.has(SettingUtil.DATA)) {
JSONObject data = (JSONObject) object.get(SettingUtil.DATA);
if (data.has("keys")) {
JSONArray keys = data.getJSONArray("keys");
for (int i = 0; i < keys.length(); i++) {
try {
int key = ((Integer) keys.get(i)).intValue();
Log.i("wu0wu", "health_optimize key=" + key);
keysList.add(Integer.valueOf(key));
} catch (Exception e) {
}
}
}
}
Log.i("wu0wu", "aidl doOptimize");
RemoteHealthCheckService.a(RemoteHealthCheckService.this, context, keysList);
} else if (RemoteHealthCheckService.COMMAND_ACTION_HEALTH_CANCEL_OPTIMIZE.equals(action)) {
RemoteHealthCheckService.b(RemoteHealthCheckService.this);
}
} catch (JSONException e2) {
Log.i("wu0wu", "aidl JSONException");
e2.printStackTrace();
}
}
};
private HealthCheckCallback d = new HealthCheckCallback() {
/* class com.lenovo.safecenter.aidl.healthcheck.RemoteHealthCheckService.AnonymousClass2 */
@Override // com.lenovo.safecenter.HealthCheck.HealthCheckCallback
public final void setProgressBarIndeterminate(boolean isIndeterminate) {
}
@Override // com.lenovo.safecenter.HealthCheck.HealthCheckCallback
public final void onProgressChanged(int progress) {
Log.i("wu0wu", "onProgressChanged progress=" + progress);
String strProgressChanged = JsonUtil.healthProgressChanged(progress, RemoteHealthCheckService.this.f);
for (int i = 0; i < RemoteHealthCheckService.this.e; i++) {
try {
RemoteHealthCheckService.this.a.getBroadcastItem(i).onResult(strProgressChanged);
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override // com.lenovo.safecenter.HealthCheck.HealthCheckCallback
public final void onScoreChanged(int score) {
Log.i("wu0wu", "onScoreChanged score=" + score);
String strScoreChanged = JsonUtil.healthScoreChanged(score, RemoteHealthCheckService.this.f);
for (int i = 0; i < RemoteHealthCheckService.this.e; i++) {
try {
RemoteHealthCheckService.this.a.getBroadcastItem(i).onResult(strScoreChanged);
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override // com.lenovo.safecenter.HealthCheck.HealthCheckCallback
public final void onStatusChanged(int statusId) {
Log.i("wu0wu", "onStatusChanged statusId=" + statusId);
String strStatusChanged = JsonUtil.healthStatusChanged(statusId, RemoteHealthCheckService.this.f);
for (int i = 0; i < RemoteHealthCheckService.this.e; i++) {
try {
RemoteHealthCheckService.this.a.getBroadcastItem(i).onResult(strStatusChanged);
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override // com.lenovo.safecenter.HealthCheck.HealthCheckCallback
public final void onStarted(int maxProgress, int action) {
String strstarted;
Log.i("wu0wu", "RemoteHealthCheckService onScanStarted....");
Log.i("wu0wu", "onStarted maxProgress=" + maxProgress);
try {
RemoteHealthCheckService.this.e = RemoteHealthCheckService.this.a.beginBroadcast();
Log.i("wu0wu", "onStarted mCallbacks.beginBroadcast() N=" + RemoteHealthCheckService.this.e);
} catch (Exception e) {
e.printStackTrace();
}
if (action == 0) {
strstarted = JsonUtil.healthScanStarted(RemoteHealthCheckService.this.f, maxProgress, HealthStatus.getStatus(RemoteHealthCheckService.this.getApplicationContext()), HealthViewType.getViewTypes(RemoteHealthCheckService.this.getApplicationContext()));
} else {
strstarted = JsonUtil.healthOptimizesStarted(RemoteHealthCheckService.this.f);
}
for (int i = 0; i < RemoteHealthCheckService.this.e; i++) {
try {
RemoteHealthCheckService.this.a.getBroadcastItem(i).onResult(strstarted);
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
@Override // com.lenovo.safecenter.HealthCheck.HealthCheckCallback
public final void onOneItemProcess(HealthItemResult result) {
Log.i("wu0wu", "onOneItemProcess ");
String strProcessing = JsonUtil.healthProcessing(result, RemoteHealthCheckService.this.f);
for (int i = 0; i < RemoteHealthCheckService.this.e; i++) {
try {
RemoteHealthCheckService.this.a.getBroadcastItem(i).onResult(strProcessing);
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override // com.lenovo.safecenter.HealthCheck.HealthCheckCallback
public final void onResult(HealthItemResult result) {
Log.i("wu0wu", "onResult ");
String strScanresult = JsonUtil.healthProcessed(result, RemoteHealthCheckService.this.f);
for (int i = 0; i < RemoteHealthCheckService.this.e; i++) {
try {
RemoteHealthCheckService.this.a.getBroadcastItem(i).onResult(strScanresult);
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Override // com.lenovo.safecenter.HealthCheck.HealthCheckCallback
public final void onFinished(int action) {
String strScanFinished;
Log.i("wu0wu", "RemoteHealthCheckService onScanFinished....");
if (action == 0) {
strScanFinished = JsonUtil.healthScanFinished(RemoteHealthCheckService.this.f);
} else {
strScanFinished = JsonUtil.healthOptimizeComplete(RemoteHealthCheckService.this.f);
}
for (int i = 0; i < RemoteHealthCheckService.this.e; i++) {
try {
RemoteHealthCheckService.this.a.getBroadcastItem(i).onResult(strScanFinished);
} catch (Exception e) {
e.printStackTrace();
}
}
try {
RemoteHealthCheckService.this.a.finishBroadcast();
} catch (Exception e2) {
e2.printStackTrace();
}
}
};
private int e = 0;
private String f;
static /* synthetic */ void a(RemoteHealthCheckService x0) {
Log.i("wu0wu", "RemoteScanvirusService doCancelScan....");
x0.b.exit();
}
static /* synthetic */ void a(RemoteHealthCheckService x0, String x1) {
x0.b = new HealthManager(x0.getApplicationContext(), true);
x0.f = x1;
TrackEvent.reportHealthcheckWithAIDL();
x0.b.scan(x0.d);
}
static /* synthetic */ void a(RemoteHealthCheckService x0, String x1, ArrayList x2) {
x0.f = x1;
x0.b.optimize(x2);
}
static /* synthetic */ void b(RemoteHealthCheckService x0) {
Log.i("wu0wu", "RemoteScanvirusService doCancelOptimize....");
x0.b.exit();
}
public void onCreate() {
super.onCreate();
}
public void onDestroy() {
Log.i("wu0wu", "RemoteService onDestroy()");
this.a.kill();
super.onDestroy();
}
public IBinder onBind(Intent intent) {
Log.i("wu0wu", "RemoteService onBind action=" + intent.getAction());
return this.c;
}
}
| 5,466 |
542 | import os
import sys
import numpy as np
from mxnet.gluon.data.vision import transforms
| 31 |
348 | {"nom":"Bony","circ":"2ème circonscription","dpt":"Aisne","inscrits":105,"abs":48,"votants":57,"blancs":3,"nuls":0,"exp":54,"res":[{"nuance":"FN","nom":"Mme <NAME>","voix":33},{"nuance":"LR","nom":"M. <NAME>","voix":21}]} | 92 |
305 | package org.mamute.model;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.mamute.dao.TestCase;
import org.mamute.model.Flag;
import org.mamute.model.FlagType;
public class FlagTest extends TestCase {
@Test(expected=IllegalStateException.class)
public void should_throw_exception_when_setting_reason_in_not_other_type() {
Flag flag = flag(FlagType.OBSOLETE, user("author", "<EMAIL>"));
flag.setReason("blabla");
}
@Test
public void should_set_reason_in_flag_with_type_other() {
Flag flag = flag(FlagType.OTHER, user("author", "<EMAIL>"));
String reason = "blabla";
flag.setReason(reason);
assertEquals(reason, flag.getReason());
}
}
| 256 |
5,169 | {
"name": "IndexArray",
"version": "1.0.1",
"summary": "The combination of dictionary and array.",
"homepage": "https://github.com/lincf0912/IndexArray",
"license": "MIT",
"authors": {
"lincf0912": "<EMAIL>"
},
"platforms": {
"ios": "7.0"
},
"source": {
"git": "https://github.com/lincf0912/IndexArray.git",
"tag": "1.0.1",
"submodules": true
},
"requires_arc": true,
"source_files": "IndexArrayDemo/class/*.{h,m}",
"public_header_files": "IndexArrayDemo/class/*.h"
}
| 222 |
879 | <reponame>luiz158/Hibernate-SpringBoot<gh_stars>100-1000
package com.bookstore.repository;
import com.bookstore.entity.Author;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
@Repository
@Transactional(readOnly = true)
public interface AuthorRepository extends SoftDeleteRepository<Author, Long> {
@Query("SELECT a FROM Author a WHERE a.name=?1 AND a.deleted=false")
Author fetchByName(String name);
}
| 173 |
Subsets and Splits