poses(double retreat_dis,double approach_dis,const tf::Transform &target_tf)
{
  geometry_msgs::Pose start_pose, target_pose, end_pose;
  std::vector<geometry_msgs::Pose> poses;

  // creating start pose by applying a translation along +z by approach distance
  tf::poseTFToMsg(Transform(Quaternion::getIdentity(),Vector3(0,0,approach_dis))*target_tf,start_pose);

  // converting target pose
  tf::poseTFToMsg(target_tf,target_pose);

  // creating end pose by applying a translation along +z by retreat distance
  tf::poseTFToMsg(Transform(Quaternion::getIdentity(),Vector3(0,0,retreat_dis))*target_tf,end_pose);

  poses.clear();
  poses.push_back(start_pose);
  poses.push_back(target_pose);
  poses.push_back(end_pose);

  return poses;
}

std::vector<geometry_msgs::Pose> transform_from_tcp_to_wrist(tf::Transform tcp_to_wrist_tf,const std::vector<geometry_msgs::Pose> tcp_poses)
{
  // array for poses of the wrist
  std::vector<geometry_msgs::Pose> wrist_poses;
  wrist_poses.resize(tcp_poses.size());

  // applying transform to each tcp poses
  tf::Transform world_to_wrist_tf, world_to_tcp_tf;
  wrist_poses.resize(tcp_poses.size());
  for(unsigned int i = 0; i < tcp_poses.size(); i++)
  {
    tf::poseMsgToTF(tcp_poses[i],world_to_tcp_tf);
    world_to_wrist_tf = world_to_tcp_tf * tcp_to_wrist_tf;
    tf::poseTFToMsg(world_to_wrist_tf,wrist_poses[i]);
  }

  return wrist_poses;
}

moveit_msgs::Constraints create_path_orientation_constraints(const geometry_msgs::Pose &goal_pose,
		float x_tolerance,float y_tolerance,float z_tolerance,std::string link_name)
{
	moveit_msgs::Constraints path_constraints = moveit_msgs::Constraints();
	path_constraints.name = "tcp_orientation_constraint";

	// setting constraint properties
	moveit_msgs::OrientationConstraint orientation_constraint = moveit_msgs::OrientationConstraint();
	orientation_constraint.header.frame_id="world_frame";
	//orientation_constraint.orientation = goal_pose.orientation;
	orientation_constraint.orientation.w = 1;
	orientation_constraint.absolute_x_axis_tolerance = x_tolerance;
	orientation_constraint.absolute_y_axis_tolerance = y_tolerance;
	orientation_constraint.absolute_z_axis_tolerance = z_tolerance;
	orientation_constraint.weight = 1.0f;
	orientation_constraint.link_name = link_name;

	// adding orientation constraint to path_constraints object
	path_constraints.orientation_constraints.push_back(orientation_constraint);
	return path_constraints;
}

std::ostream& operator<<(std::ostream& os, const tf::Vector3 vec)
{
  return os << "[" << vec.getX() << ", " << vec.getY() << ", " << vec.getZ() << "]";
}

std::ostream& operator<<(std::ostream& os, const geometry_msgs::Point pt)
{
  return os << "[" << pt.x << ", " << pt.y << ", " << pt.z << "]";
}

bool pick_and_place_config::init()
{
  ros::NodeHandle nh("~");
  double


#pragma once

#include "optimizers/quantizer.h"
#include "training/graph_group.h"

namespace marian {

class SyncGraphGroup : public GraphGroup {
  using Base = GraphGroup;
  const double delay_{1.}; // optimizer-delay parameter. Fractional means to use a fraction of whatever the MB size is

  // @TODO: instead, create an array of ExponentialSmoothing objects, and don't use ExponentialSmoothing as a base class
  std::vector<Ptr<TensorAllocator>> paramsAllocs_; // [deviceIndex] we must hold a reference to the memory until this class dies

  // model quantizer
  std::vector<Ptr<ModelQuantizer>> quantizers_;

  // state for update()
  bool first_{ true };                           // gets interpreted and cleared by update()
  std::vector<Ptr<data::Batch>> pendingBatches_; // in case of dynamic MB-size scaling, we temporarly buffer up batches across update() calls until enough
  double updateMultiplier_{1};                  // multiplier not applied in collectStats() (no multiplier if not mini-batch-fit)

  void initialize(const Ptr<data::Batch>& exampleBatch);

  bool tryGetSubBatches(Ptr<data::Batch> newBatch, std::vector<Ptr<data::Batch>>& subBatches, size_t& numReadBatches);
  void update(std::vector<Ptr<data::Batch>> subBatches, size_t numReadBatches);

public:
  SyncGraphGroup(Ptr<Options> config, Ptr<IMPIWrapper> mpi);

  void setScheduler(Ptr<Scheduler> scheduler) override;

  void update(Ptr<data::Batch> batch) override;

  Ptr<data::BatchStats> collectStats(const std::vector<Ptr<Vocab>>&) override;
  void finalize() override;

  // @TODO: consider to make this a virtual as well? Currently it is a template dispatch
};
}  // namespace marian


ackground-position:-110px -80px; background-image:url("./img/zTreeStandard.png"); *background-image:url("./img/zTreeStandard.gif")}

ul.ztree.zTreeDragUL {margin:0; padding:0; position:absolute; width:auto; height:auto;overflow:hidden; background-color:#cfcfcf; border:1px #00B83F dotted; opacity:0.8; filter:alpha(opacity=80)}
.zTreeMask {z-index:10000; background-color:#cfcfcf; opacity:0.0; filter:alpha(opacity=0); position:absolute}

/* level style*/
/*.ztree li span.button.level0 {
	display:none;
}
.ztree li ul.level0 {
	padding:0;
	background:none;
}*//* container */
.ke-container-simple {
	display: block;
	border: 1px solid #CCC;
	background-color: #FFF;
	overflow: hidden;
}
/* toolbar */
.ke-container-simple .ke-toolbar {
	border-bottom: 1px solid #CCC;
	background-color: #FFF;
	padding: 2px 5px;
	overflow: hidden;
}
.ke-container-simple .ke-toolbar .ke-outline {
	border: 1px solid #FFF;
	background-color: transparent;
	margin: 1px;
	padding: 1px 2px;
	font-size: 0;
	line-height: 0;
	overflow: hidden;
	cursor: pointer;
}
.ke-container-simple .ke-toolbar .ke-on {
	border: 1px solid #5690D2;
}
.ke-container-simple .ke-toolbar .ke-selected {
	border: 1px solid #5690D2;
	background-color: #E9EFF6;
}
.ke-container-simple .ke-toolbar  .ke-disabled {
	cursor: default;
}
/* statusbar */
.ke-container-simple .ke-statusbar {
	position: relative;
	background-color: #FFF;
	border-top: 1px solid #CCCCCC;
	font-size: 0;
	line-height: 0;
	*height: 12px;
	overflow: hidden;
	text-align: center;
	cursor: s-resize;
}
/* menu */
.ke-menu-simple {
	border: 1px solid #A0A0A0;
	background-color: #FFF;
	color: #222222;
	padding: 2px;
	font-family: "sans serif",tahoma,verdana,helvetica;
	font-size: 12px;
	text-align: left;
	overflow: hidden;
}
.ke-menu-simple .ke-menu-item {
	border: 1px solid #FFF;
	background-color: #FFF;
	color: #222222;
	height: 24px;
	overflow: hidden;
	cursor: pointer;
}
.ke-menu-simple .ke-menu-item-on {
	border: 1px solid #5690D2;
	background-color: #FFF;
}
/* colorpicker */
.ke-colorpicker-simple {
	border: 1px solid #A0A0A0;
	background-color: #FEFEFE;
	color: #222222;
	padding: 2px;
}
.ke-colorpicker-simple .ke-colorpicker-cell {
	font-size: 0;
	line-height: 0;
	border: 1px solid #FEFEFE;
	cursor: pointer;
	margin:3px;
	padding:0;
}
.ke-colorpicker-simple .ke-colorpicker-cell-top {
	font-family: "sans serif",tahoma,verdana,helvetica;
	font-size: 12px;
	line-height: 24px;
	border: 1px solid #FEFEFE;
	cursor: pointer;
	margin:0;
	padding:0;
	text-align: center;
}
.ke-colorpicker-simple .ke-colorpicker-cell-on {
	border: 1px solid #5690D2;
}
.ke-colorpicker-simple .ke-colorpicker-cell-selected {
	border: 1px solid #2446AB;
}
/*!
 laypage默


delete(dict, keys, true)
}

// Flush removes all specified keys from the dictionary. If no key is specified, all keys are removed.
func (dh DictHelper) Flush(dict baseIDict, keys []interface{}) baseIDict {
	if len(keys) == 0 {
		keys = dict.GetKeys().AsArray()
	}
	dh.delete(dict, keys, false)
	return dict
}

// Get returns the value associated with key.
func (dh DictHelper) Get(dict baseIDict, keys []interface{}) interface{} {
	switch len(keys) {
	case 0:
		return nil
	case 1:
		return dict.AsMap()[fmt.Sprint(keys[0])]
	}
	result := dict.CreateList(len(keys))
	for i := range result.AsArray() {
		result.Set(i, dict.Get(keys[i]))
	}
	return result
}

// Has returns true if the dictionary object contains all the keys.
func (dh DictHelper) Has(dict baseIDict, keys []interface{}) bool {
	for _, key := range keys {
		if _, ok := dict.AsMap()[fmt.Sprint(key)]; !ok {
			return false
		}
	}
	return dict.Len() > 0
}

// GetKeys returns the keys in the dictionary in alphabetical order.
func (dh DictHelper) GetKeys(dict baseIDict) baseIList {
	keys := dict.KeysAsString()
	result := dh.CreateList(dict.Len())

	for i := range keys {
		result.Set(i, keys[i])
	}
	return result
}

// GetTypes returns a dictionary with key and type (or kind) for each element.
func (dh DictHelper) GetTypes(dict baseIDict, kind bool) baseIDict {
	result := dh.CreateDictionary(dict.Len())

	for key, value := range dict.AsMap() {
		result.Set(key, iif(kind, reflect.TypeOf(value).Kind().String(), reflect.TypeOf(value).Name()))
	}
	return result
}

// KeysAsString returns the keys in the dictionary in alphabetical order.
func (dh DictHelper) KeysAsString(dict baseIDict) collections.StringArray {
	keys := make(collections.StringArray, 0, dict.Len())
	for key := range dict.AsMap() {
		keys = append(keys, str(key))
	}
	return keys.Sorted()
}

// Merge merges the other dictionaries into the current dictionary.
func (dh DictHelper) Merge(target baseIDict, sources []baseIDict) baseIDict {
	for i := range sources {
		if sources[i] == nil {
			continue
		}
		target = dh.deepMerge(target, dh.ConvertDict(sources[i]))
	}
	return target
}

func (dh DictHelper) deepMerge(target baseIDict, source baseIDict) baseIDict {
	targetMap := target.AsMap()
	sourceMap := source.AsMap()
	for key := range sourceMap {
		sourceValue, sourceHasKey := sourceMap[key]
		targetValue, targetHasKey := targetMap[key]

		if sourceHasKey && !targetHasKey {
			targetMap[key] = sourceValue
			continue
		}

		targetValueDict, targetValueIsDict := targetValue.(baseIDict)
		sourceValueDict, sourceValueIsDict := sourceValue.(baseIDict)

		if sourceValueIsDict && targetValueIsDict {
			targetMap[key] = dh.deepMerge(targetValueDict, sourceValueDict)
		}
	}

	return target
}

// Omit returns a distinct copy of the object including all keys except specified ones.
func (dh DictHelper) Omit(dict baseIDict, keys []interface{}) baseIDict {
	if len(keys) == 0 {
		return dict.Clone()
	}
	return dict


id vcpu_events_set(struct kvm_vm *vm, uint32_t vcpuid,
		     struct kvm_vcpu_events *events);
#endif
#ifdef __x86_64__
void vcpu_nested_state_get(struct kvm_vm *vm, uint32_t vcpuid,
			   struct kvm_nested_state *state);
int vcpu_nested_state_set(struct kvm_vm *vm, uint32_t vcpuid,
			  struct kvm_nested_state *state, bool ignore_error);
#endif

const char *exit_reason_str(unsigned int exit_reason);

void virt_pgd_alloc(struct kvm_vm *vm, uint32_t pgd_memslot);
void virt_pg_map(struct kvm_vm *vm, uint64_t vaddr, uint64_t paddr,
		 uint32_t pgd_memslot);
vm_paddr_t vm_phy_page_alloc(struct kvm_vm *vm, vm_paddr_t paddr_min,
			     uint32_t memslot);
vm_paddr_t vm_phy_pages_alloc(struct kvm_vm *vm, size_t num,
			      vm_paddr_t paddr_min, uint32_t memslot);

struct kvm_vm *vm_create_default(uint32_t vcpuid, uint64_t extra_mem_size,
				 void *guest_code);
void vm_vcpu_add_default(struct kvm_vm *vm, uint32_t vcpuid, void *guest_code);

bool vm_is_unrestricted_guest(struct kvm_vm *vm);

unsigned int vm_get_page_size(struct kvm_vm *vm);
unsigned int vm_get_page_shift(struct kvm_vm *vm);
unsigned int vm_get_max_gfn(struct kvm_vm *vm);

struct kvm_userspace_memory_region *
kvm_userspace_memory_region_find(struct kvm_vm *vm, uint64_t start,
				 uint64_t end);

struct kvm_dirty_log *
allocate_kvm_dirty_log(struct kvm_userspace_memory_region *region);

int vm_create_device(struct kvm_vm *vm, struct kvm_create_device *cd);

#define sync_global_to_guest(vm, g) ({				\
	typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g));	\
	memcpy(_p, &(g), sizeof(g));				\
})

#define sync_global_from_guest(vm, g) ({			\
	typeof(g) *_p = addr_gva2hva(vm, (vm_vaddr_t)&(g));	\
	memcpy(&(g), _p, sizeof(g));				\
})

/* Common ucalls */
enum {
	UCALL_NONE,
	UCALL_SYNC,
	UCALL_ABORT,
	UCALL_DONE,
};

#define UCALL_MAX_ARGS 6

struct ucall {
	uint64_t cmd;
	uint64_t args[UCALL_MAX_ARGS];
};

void ucall_init(struct kvm_vm *vm, void *arg);
void ucall_uninit(struct kvm_vm *vm);
void ucall(uint64_t cmd, int nargs, ...);
uint64_t get_ucall(struct kvm_vm *vm, uint32_t vcpu_id, struct ucall *uc);

#define GUEST_SYNC(stage)	ucall(UCALL_SYNC, 2, "hello", stage)
#define GUEST_DONE()		ucall(UCALL_DONE, 0)
#define GUEST_ASSERT(_condition) do {			\
	if (!(_condition))				\
		ucall(UCALL_ABORT, 2,			\
			"Failed guest assert: "		\
			#_condition, __LINE__);		\
} while (0)

#endif /* SELFTEST_KVM_UTIL_H */


     O
HETATM41608  O2P FMN B3994     176.629 144.030 124.178  1.00 20.00           O
HETATM41609  O3' FMN B3994     181.797 147.921 124.196  1.00 20.00           O
HETATM41610  O3P FMN B3994     176.819 144.839 121.850  1.00 20.00           O
HETATM41611  O4  FMN B3994     187.140 146.009 130.088  1.00 20.00           O
HETATM41612  O4' FMN B3994     180.624 144.527 124.429  1.00 20.00           O
HETATM41613  O5' FMN B3994     178.295 145.862 123.627  1.00 20.00           O
HETATM41614  P   FMN B3994     177.571 144.536 123.116  1.00 20.00           P
TER
END
"""

def exercise_00():
  """ Verify that ligand is properly included by default """
  pdb_inp = iotbx.pdb.input(lines=pdb_str_1,source_info=None)
  hierarchy = pdb_inp.construct_hierarchy()
  asc = hierarchy.atom_selection_cache()
  ncs_inp = iotbx.ncs.input(hierarchy = hierarchy)
  ncs_groups = ncs_inp.get_ncs_restraints_group_list()
  assert len(ncs_groups) == 1
  assert len(ncs_groups[0].copies) == 1, len(ncs_groups[0].copies)
  # print list(ncs_groups[0].master_iselection)
  assert ncs_groups[0].master_iselection.size() == 58 # all chain
  # print hierarchy.select(asc.selection("chain A")).atoms_size()
  assert ncs_groups[0].copies[0].iselection.size() == 58 # all chain

if(__name__=='__main__'):
  exercise_00()


ram-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
 */
api.cat.prototype.count = ca({
  params: {
    format: {
      type: 'string'
    },
    local: {
      type: 'boolean'
    },
    masterTimeout: {
      type: 'time',
      name: 'master_timeout'
    },
    h: {
      type: 'list'
    },
    help: {
      type: 'boolean',
      'default': false
    },
    s: {
      type: 'list'
    },
    v: {
      type: 'boolean',
      'default': false
    }
  },
  urls: [
    {
      fmt: '/_cat/count/<%=index%>',
      req: {
        index: {
          type: 'list'
        }
      }
    },
    {
      fmt: '/_cat/count'
    }
  ]
});

/**
 * Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/6.8/cat-fielddata.html) request
 *
 * @param {Object} params - An object with parameters used to carry out this action
 * @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
 * @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
 * @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
 * @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
 * @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
 * @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
 * @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
 * @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
 * @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return the fielddata size
 */
api.cat.prototype.fielddata = ca({
  params: {
    format: {
      type: 'string'
    },
    bytes: {
      type: 'enum',
      options: [
        'b',
        'k',
        'kb',
        'm',
        'mb',
        'g',
        'gb',
        't',
        'tb',
        'p',
        'pb'
      ]
    },
    local: {
      type: 'boolean'
    },
    masterTimeout: {
      type: 'time',
      name: 'master_timeout'
    },
    h: {
      type: 'list'
    },
    help: {
      type: 'boolean',
      'default': false
    },
    s: {
      type: 'list'
    },
    v: {
      type: 'boolean',
      'default': false
    },
    fields: {
      type: 'list'
    }
  },
  urls: [
    {
      fmt: '/_cat/fielddata/<%=fields%>',
      req: {
        fields: {
          type: 'list'
        }
      }
    },


] = center_x + width / 2;
				dst_box[i, 3] = center_y + height / 2;
			}

			return dst_box;
		}

		private float[] DecodeScore(float[,] src_score)
		{
			int numElements = src_score.GetLength(0);
			float[] dst_score = new float[numElements];

			for (int i = 0; i < numElements; i++)
			{
				dst_score[i] = src_score[i, 1];
			}

			return dst_score;
		}

		private float[,] DecodeLandmark(float[,] src_landmark, float[,] priors, float[] variances)
		{
			int numBoxes = priors.GetLength(0);
			float[,] dst_landmark = new float[numBoxes, 10];
			for (int i = 0; i < numBoxes; i++)
			{
				for (int j = 0; j < NUM_KEYPOINTS; j++)
				{
					dst_landmark[i, 2 * j] = priors[i, 0] + src_landmark[i, 2 * j] * variances[0] * priors[i, 2];
					dst_landmark[i, 2 * j + 1] = priors[i, 1] + src_landmark[i, 2 * j + 1] * variances[0] * priors[i, 3];
				}
			}

			return dst_landmark;
		}

		private float[,] Scale(float[,] src, int[] scale)
		{
			int src_width = src.GetLength(0);
			int src_height = src.GetLength(1);
			float[,] dst = new float[src_width, src_height];

			if(src_height != scale.Length){
				return null;
			}

			for (int i = 0; i < src_width; i++)
			{
				for (int j = 0; j < src_height; j++)
				{
					dst[i, j] = src[i, j] * scale[j];
				}
			}

			return dst;
		}

		private float[] Filter(float[] src, List<int> inds){

			float[] dst = new float[inds.Count];
			for (int i = 0; i < inds.Count; i++)
			{
				int index = inds[i];
				dst[i] = src[index];
			}

			return dst;
		}

		private float[,] Filter(float[,] src, List<int> inds){

			int src_element_num = src.GetLength(1);

			float[,] dst = new float[inds.Count, src_element_num];

			for (int i = 0; i < inds.Count; i++)
			{
				int index = inds[i];
				for (int j = 0; j < src_element_num; j++)
				{
					dst[i, j] = src[index, j];
				}
			}

			return dst;

		}

		private float[] KeepTopKBeforeNMS(float[] src, int[] order, int top_k)
		{
			float[] dst = new float[top_k];

			for (int i = 0; i < top_k; i++)
			{
				int index = order[i];
				dst[i] = src[index];
			}

			return dst;
		}

		private float[,] KeepTopKBeforeNMS(float[,] src, int[] order, int top_k)
		{
			int src_element_num =


5s,
    background-color 0.5s;
  line-height: 1.6;
  font-family:
    Inter,
    -apple-system,
    BlinkMacSystemFont,
    'Segoe UI',
    Roboto,
    Oxygen,
    Ubuntu,
    Cantarell,
    'Fira Sans',
    'Droid Sans',
    'Helvetica Neue',
    sans-serif;
  font-size: 15px;
  text-rendering: optimizeLegibility;
  -webkit-font-smoothing: antialiased;
  -moz-osx-font-smoothing: grayscale;
}
.cesium-viewer-geocoderContainer .cesium-geocoder-input{border:solid 1px #444;background-color:rgba(40,40,40,0.7);color:white;display:inline-block;vertical-align:middle;width:0;height:32px;margin:0;padding:0 32px 0 0;border-radius:0;box-sizing:border-box;transition:width ease-in-out 0.25s,background-color 0.2s ease-in-out;-webkit-appearance:none;}.cesium-viewer-geocoderContainer:hover .cesium-geocoder-input{border-color:#aef;box-shadow:0 0 8px #fff;}.cesium-viewer-geocoderContainer .cesium-geocoder-input:focus{border-color:#ea4;background-color:rgba(15,15,15,0.9);box-shadow:none;outline:none;}.cesium-viewer-geocoderContainer:hover .cesium-geocoder-input,.cesium-viewer-geocoderContainer .cesium-geocoder-input:focus,.cesium-viewer-geocoderContainer .cesium-geocoder-input-wide{padding-left:4px;width:250px;}.cesium-viewer-geocoderContainer .search-results{position:absolute;background-color:#000;color:#eee;overflow-y:auto;opacity:0.8;width:100%;}.cesium-viewer-geocoderContainer .search-results ul{list-style-type:none;margin:0;padding:0;}.cesium-viewer-geocoderContainer .search-results ul li{font-size:14px;padding:3px 10px;}.cesium-viewer-geocoderContainer .search-results ul li:hover{cursor:pointer;}.cesium-viewer-geocoderContainer .search-results ul li.active{background:#48b;}.cesium-geocoder-searchButton{background-color:#303336;display:inline-block;position:absolute;cursor:pointer;width:32px;top:1px;right:1px;height:30px;vertical-align:middle;fill:#edffff;}.cesium-geocoder-searchButton:hover{background-color:#48b;}span.cesium-sceneModePicker-wrapper{display:inline-block;position:relative;margin:0 3px;}.cesium-sceneModePicker-visible{visibility:visible;opacity:1;transition:opacity 0.25s linear;}.cesium-sceneModePicker-hidden{visibility:hidden;opacity:0;transition:visibility 0s 0.25s,opacity 0.25s linear;}.cesium-sceneModePicker-wrapper .cesium-sceneModePicker-none{display:none;}.cesium-sceneModePicker-slide-svg{transition:left 2s;top:0;left:0;}.cesium-sceneModePicker-wrapper .cesium-sceneModePicker-dropDown-icon{box-sizing:border-box;padding:0;margin:3px 0;}.cesium-sceneModePicker-wrapper .cesium-sceneModePicker-button3D


new MinimapLogger( this );

		load();

		logger.infoTr( LocaleConstants.MINIMAP_DEFAULT_ROTATION, settings.getRotation().name().toLowerCase() );
		logger.infoTr( LocaleConstants.MINIMAP_DEFAULT_SHOWNAME, settings.getShowName().name().toLowerCase() );
		logger.infoTr( LocaleConstants.MINIMAP_AUTO_UPDATE, settings.isAutoUpdate() );
		logger.infoTr( LocaleConstants.MINIMAP_ZOOM_CIRCULAR, settings.isCircularZoom() );
		logger.infoTr( LocaleConstants.MINIMAP_RENDER, settings.isRenderOutOfBorder() );
		logger.infoTr( LocaleConstants.MINIMAP_ZOOM_DEFAULT, settings.getDefaultZoom() );
		logger.infoTr( LocaleConstants.MINIMAP_ZOOM_ALLOWED, String.join( ", ", settings.allowedZooms.stream()
				.map( d -> { return String.valueOf( d ); } )
				.collect( Collectors.toList() ) ) );

		if ( settings.isWhitelist ) {
			logger.infoTr( LocaleConstants.MINIMAP_WORLD_WHITELIST, String.join( ", ", settings.blacklistedWorlds ) );
		} else {
			logger.infoTr( LocaleConstants.MINIMAP_WORLD_BLACKLIST, String.join( ", ", settings.blacklistedWorlds ) );
		}

//		cache.setChunkDataStorage( new MipMapChunkDataStorage( 4 ) );

		// Show at least the player, if nothing else
		registerProvider( new DefaultPlayerCursorProvider() );
		registerProvider( new DefaultPointerCursorProvider() );
	}

	protected void load() {
		try {
			if ( OVERLAY_IMAGE_FILE != null && !OVERLAY_IMAGE_FILE.isEmpty() ) {
				File overlayFile = new File( saveFile, OVERLAY_IMAGE_FILE );
				if ( overlayFile.exists() ) {
					overlay = new SimpleImage( overlayFile, 128, 128, Image.SCALE_REPLICATE );
					logger.infoTr( LocaleConstants.MINIMAP_LOADED_OVERLAY, overlayFile.getName() );
				} else if ( ( overlayFile = new File( Cartographer.getInstance().getDataFolder(), OVERLAY_IMAGE_FILE ) ).exists() ) {
					overlay = new SimpleImage( overlayFile, 128, 128, Image.SCALE_REPLICATE );
					logger.infoTr( LocaleConstants.MINIMAP_LOADED_OVERLAY, overlayFile.getName() );
				}
			}

			if ( BACKGROUND_IMAGE_FILE != null && !BACKGROUND_IMAGE_FILE.isEmpty() ) {
				File backgroundFile = new File( saveFile, BACKGROUND_IMAGE_FILE );
				if ( backgroundFile.exists() ) {
					background = new SimpleImage( backgroundFile, 128, 128, Image.SCALE_REPLICATE );
					logger.infoTr( LocaleConstants.MINIMAP_LOADED_BACKGROUND, backgroundFile.getName() );
				} else if ( ( backgroundFile = new File( Cartographer.getInstance().getDataFolder(), BACKGROUND_IMAGE_FILE ) ).exists() ) {
					background = new SimpleImage( backgroundFile, 128, 128, Image.SCALE_REPLICATE );
					logger.infoTr( LocaleConstants.MINIMAP_LOADED_BACKGROUND, backgroundFile.getName() );
				}
			}

			if ( DISABLED_IMAGE_FILE != null && !DISABLED_IMAGE_FILE.isEmpty() ) {
				File disabledFile = new File( saveFile, DISABLED_IMAGE_FILE );
				if ( disabledFile.exists() ) {
					disabled = new SimpleImage( disabledFile, 128, 128, Image.SCALE_REPLICATE );
					logger.infoTr( LocaleConstants.MINIMAP_LOADED_DISABLED, disabledFile.getName() );
				} else if ( ( disabledFile = new File( Cartographer.getInstance().getDataFolder(), DISABLED_IMAGE_FILE ) ).exists() ) {
					disabled = new SimpleImage( disabledFile, 128, 128, Image.SCALE_REPLICATE );
					logger.infoTr( LocaleConstants.MINIMAP_LOADED_DISABLED, disabledFile.getName() );
				}


     */
    public com.google.cloud.security.privateca.v1.CertificateAuthority.UserDefinedAccessUrls.Builder
        getUserDefinedAccessUrlsBuilder() {
      bitField0_ |= 0x00020000;
      onChanged();
      return getUserDefinedAccessUrlsFieldBuilder().getBuilder();
    }

    /**
     *
     *
     *

     * Optional. User-defined URLs for CA certificate and CRLs. The service does
     * not publish content to these URLs. It is up to the user to mirror content
     * to these URLs.
     *

     *
     *
     * .google.cloud.security.privateca.v1.CertificateAuthority.UserDefinedAccessUrls user_defined_access_urls = 18 [(.google.api.field_behavior) = OPTIONAL];
     *
     */
    public com.google.cloud.security.privateca.v1.CertificateAuthority
            .UserDefinedAccessUrlsOrBuilder
        getUserDefinedAccessUrlsOrBuilder() {
      if (userDefinedAccessUrlsBuilder_ != null) {
        return userDefinedAccessUrlsBuilder_.getMessageOrBuilder();
      } else {
        return userDefinedAccessUrls_ == null
            ? com.google.cloud.security.privateca.v1.CertificateAuthority.UserDefinedAccessUrls
                .getDefaultInstance()
            : userDefinedAccessUrls_;
      }
    }

    /**
     *
     *
     *

     * Optional. User-defined URLs for CA certificate and CRLs. The service does
     * not publish content to these URLs. It is up to the user to mirror content
     * to these URLs.
     *

     *
     *
     * .google.cloud.security.privateca.v1.CertificateAuthority.UserDefinedAccessUrls user_defined_access_urls = 18 [(.google.api.field_behavior) = OPTIONAL];
     *
     */
    private com.google.protobuf.SingleFieldBuilderV3<
            com.google.cloud.security.privateca.v1.CertificateAuthority.UserDefinedAccessUrls,
            com.google.cloud.security.privateca.v1.CertificateAuthority.UserDefinedAccessUrls
                .Builder,
            com.google.cloud.security.privateca.v1.CertificateAuthority
                .UserDefinedAccessUrlsOrBuilder>
        getUserDefinedAccessUrlsFieldBuilder() {
      if (userDefinedAccessUrlsBuilder_ == null) {
        userDefinedAccessUrlsBuilder_ =
            new com.google.protobuf.SingleFieldBuilderV3<
                com.google.cloud.security.privateca.v1.CertificateAuthority.UserDefinedAccessUrls,
                com.google.cloud.security.privateca.v1.CertificateAuthority.UserDefinedAccessUrls
                    .Builder,
                com.google.cloud.security.privateca.v1.CertificateAuthority
                    .UserDefinedAccessUrlsOrBuilder>(
                getUserDefinedAccessUrls(), getParentForChildren(), isClean());
        userDefinedAccessUrls_ = null;
      }
      return userDefinedAccessUrlsBuilder_;
    }

    private boolean satisfiesPzs_;

    /**
     *
     *
     *

     * Output only. Reserved for future use.
     *

     *
     * bool satisfies_pzs = 19 [(.google.api.field_behavior) = OUTPUT_ONLY];
     *
     * @return The satisfiesPzs.
     */
    @java.lang.Override
    public boolean getSatisfiesPzs() {
      return satisfiesPzs_;
    }

    /**
     *
     *
     *

     * Output only. Reserved for future use.
     *

     *
     * bool satisfies_pzs = 19 [(.google.api.field_behavior) = OUTPUT_ONLY];


e of kotlin is the same as java 8,
    // so the code below is copied from java.js
    const KOTLIN_NUMBER_MODE = NUMERIC;
    const KOTLIN_NESTED_COMMENT = hljs.COMMENT(
      '/\\*', '\\*/',
      { contains: [ hljs.C_BLOCK_COMMENT_MODE ] }
    );
    const KOTLIN_PAREN_TYPE = { variants: [
      {
        className: 'type',
        begin: hljs.UNDERSCORE_IDENT_RE
      },
      {
        begin: /\(/,
        end: /\)/,
        contains: [] // defined later
      }
    ] };
    const KOTLIN_PAREN_TYPE2 = KOTLIN_PAREN_TYPE;
    KOTLIN_PAREN_TYPE2.variants[1].contains = [ KOTLIN_PAREN_TYPE ];
    KOTLIN_PAREN_TYPE.variants[1].contains = [ KOTLIN_PAREN_TYPE2 ];

    return {
      name: 'Kotlin',
      aliases: [
        'kt',
        'kts'
      ],
      keywords: KEYWORDS,
      contains: [
        hljs.COMMENT(
          '/\\*\\*',
          '\\*/',
          {
            relevance: 0,
            contains: [
              {
                className: 'doctag',
                begin: '@[A-Za-z]+'
              }
            ]
          }
        ),
        hljs.C_LINE_COMMENT_MODE,
        KOTLIN_NESTED_COMMENT,
        KEYWORDS_WITH_LABEL,
        LABEL,
        ANNOTATION_USE_SITE,
        ANNOTATION,
        {
          className: 'function',
          beginKeywords: 'fun',
          end: '[(]|$',
          returnBegin: true,
          excludeEnd: true,
          keywords: KEYWORDS,
          relevance: 5,
          contains: [
            {
              begin: hljs.UNDERSCORE_IDENT_RE + '\\s*\\(',
              returnBegin: true,
              relevance: 0,
              contains: [ hljs.UNDERSCORE_TITLE_MODE ]
            },
            {
              className: 'type',
              begin: /</,
              end: />/,
              keywords: 'reified',
              relevance: 0
            },
            {
              className: 'params',
              begin: /\(/,
              end: /\)/,
              endsParent: true,
              keywords: KEYWORDS,
              relevance: 0,
              contains: [
                {
                  begin: /:/,
                  end: /[=,\/]/,
                  endsWithParent: true,
                  contains: [
                    KOTLIN_PAREN_TYPE,
                    hljs.C_LINE_COMMENT_MODE,
                    KOTLIN_NESTED_COMMENT
                  ],
                  relevance: 0
                },
                hljs.C_LINE_COMMENT_MODE,
                KOTLIN_NESTED_COMMENT,
                ANNOTATION_USE_SITE,
                ANNOTATION,
                STRING,
                hljs.C_NUMBER_MODE
              ]
            },
            KOTLIN_NESTED_COMMENT
          ]
        },
        {
          begin: [
            /class|interface|trait/,
            /\s+/,
            hljs.UNDERSCORE_IDENT_RE
          ],
          beginScope: {
            3: "title.class"
          },
          keywords: 'class interface trait',
          end: /[:\{(]|$/,
          excludeEnd: true,
          illegal: 'extends implements',
          contains: [
            { beginKeywords: 'public protected internal private constructor' },
            hljs.UNDERSCORE_TITLE_MODE,
            {
              className: 'type',
              begin: /</,
              end: />/,
              excludeBegin: true,


kip file size greater than 100k
          if fsize > 100 * 1024 then
            ret = false

          -- skip fugitive buffer
          elseif bufname:match("^fugitive://") then
            ret = false
          end

          return ret
        end,
      },
      -- make `drop` and `tab drop` to become preferred
      func_map = {
        drop = "o",
        openc = "O",
        split = "<C-s>",
        tabdrop = "<C-t>",
        -- set to empty string to disable
        tabc = "",
        ptogglemode = "z,",
      },
      filter = {
        fzf = {
          action_for = { ["ctrl-s"] = "split", ["ctrl-t"] = "tab drop" },
          extra_opts = { "--bind", "ctrl-o:toggle-all", "--prompt", "> " },
        },
      },
    })
  end,
}


 the child class's
 * enable/disable methods when the user manually turns the option on or off.
 */
export class Option {
  opt: OrderOption
  node: HTMLElement
  tmpl: Record<string, PageElement>
  on: boolean

  constructor (opt: OrderOption, symbol: string, report: OptionsReporters) {
    this.opt = opt
    const node = this.node = orderOptTmpl.cloneNode(true) as HTMLElement
    const tmpl = this.tmpl = Doc.parseTemplate(node)

    tmpl.optName.textContent = opt.displayname
    tmpl.tooltip.dataset.tooltip = opt.description

    // const isBaseChain = (isSwapOption && order.sell) || (!isSwapOption && !order.sell)
    // const symbol = isBaseChain ? this.baseSymbol() : this.quoteSymbol()
    if (symbol) tmpl.chainIcon.src = Doc.logoPath(symbol)
    else Doc.hide(tmpl.chainIcon)

    this.on = false
    Doc.bind(node, 'click', () => {
      if (this.on) return
      this.on = true
      node.classList.add('selected')
      report.enable()
    })
    Doc.bind(tmpl.toggle, 'click', e => {
      if (!this.on) return
      e.stopPropagation()
      this.on = false
      node.classList.remove('selected')
      report.disable()
    })
  }
}

/*
 * BooleanOption is a simple on/off option with a short summary of it's effects.
 * BooleanOrderOption is the handler for a *BooleanConfig from client/asset.
 */
export class BooleanOption extends Option {
  control: HTMLElement
  changed: () => void
  dict: Record<string, any>

  constructor (opt: OrderOption, symbol: string, dict: Record<string, any>, changed: () => void) {
    super(opt, symbol, {
      enable: () => this.enable(),
      disable: () => this.disable()
    })
    this.dict = dict
    this.changed = () => changed()
    if (opt.boolean === undefined) throw Error('not a boolean opt')
    const cfg = opt.boolean
    const control = this.control = booleanOptTmpl.cloneNode(true) as HTMLElement
    // Append to parent's options div.
    this.tmpl.controls.appendChild(control)
    const tmpl = Doc.parseTemplate(control)
    tmpl.reason.textContent = cfg.reason
    this.on = typeof dict[opt.key] !== 'undefined' ? dict[opt.key] : opt.default
    if (this.on) this.node.classList.add('selected')
  }

  store (): void {
    if (this.on === this.opt.default) delete this.dict[this.opt.key]
    else this.dict[this.opt.key] = this.on
    this.changed()
  }

  enable (): void {
    this.store()
  }

  disable (): void {
    this.store()
  }
}

/*
 * XYRangeOption is an order option that contains an XYRangeHandler. The logic
 * for handling the slider to is defined in XYRangeHandler so that the slider
 * can be used without being contained in an order option.
 */
export class XYRangeOption extends Option {
  handler: XYRangeHandler
  x: number
  changed: () => void
  dict: Record<string, any>

  constructor (opt: OrderOption, symbol: string, dict: Record<string, any>, changed: () => void) {
    super(opt, symbol, {
      enable: () => this.enable(),
      disable: () => this.disable()
    })
    this.dict = dict
    this.changed = changed
    if (opt.xyRange === undefined) throw Error('not an xy rang


ive) of the translation component of the
   * exponential map parameterization
   * @return a pair of [start, end] indices into the tangent space vector
   */
  inline static std::pair<size_t, size_t> translationInterval() {
    return std::make_pair(3, 5);
  }

  /**
   * Return the start and end indices (inclusive) of the rotation component of the
   * exponential map parameterization
   * @return a pair of [start, end] indices into the tangent space vector
   */
  static std::pair<size_t, size_t> rotationInterval() {
    return std::make_pair(0, 2);
  }

  /// Output stream operator
  GTSAM_EXPORT
  friend std::ostream &operator<<(std::ostream &os, const Pose3& p);

 private:
  /** Serialization function */
  friend class boost::serialization::access;
  template<class Archive>
  void serialize(Archive & ar, const unsigned int /*version*/) {
    ar & BOOST_SERIALIZATION_NVP(R_);
    ar & BOOST_SERIALIZATION_NVP(t_);
  }
  /// @}

};
// Pose3 class

/**
 * wedge for Pose3:
 * @param xi 6-dim twist (omega,v) where
 *  omega = 3D angular velocity
 *  v = 3D velocity
 * @return xihat, 4*4 element of Lie algebra that can be exponentiated
 */
template<>
inline Matrix wedge<Pose3>(const Vector& xi) {
  return Pose3::wedge(xi(0), xi(1), xi(2), xi(3), xi(4), xi(5));
}

/**
 * Calculate pose between a vector of 3D point correspondences (b_point, a_point)
 * where a_point = Pose3::transform_from(b_point) = t + R*b_point
 * @deprecated: use Pose3::Align with point pairs ordered the opposite way
 */
GTSAM_EXPORT boost::optional<Pose3> align(const std::vector<Point3Pair>& baPointPairs);

// For MATLAB wrapper
typedef std::vector<Pose3> Pose3Vector;

template <>
struct traits<Pose3> : public internal::LieGroup<Pose3> {};

template <>
struct traits<const Pose3> : public internal::LieGroup<Pose3> {};

// bearing and range traits, used in RangeFactor
template <>
struct Bearing<Pose3, Point3> : HasBearing<Pose3, Point3, Unit3> {};

template <typename T>
struct Range<Pose3, T> : HasRange<Pose3, T, double> {};

}  // namespace gtsam


nternalDTO, User>(dto.User);
            AdditionalProperties = dto.AdditionalProperties;

            return this;
        }

        Message ILoadableFrom<MessageResponseInternalDTO, Message>.LoadFromDto(MessageResponseInternalDTO dto)
        {
            Attachments = Attachments.TryLoadFromDtoCollection(dto.Attachments);
            BeforeMessageSendFailed = dto.BeforeMessageSendFailed;
            //Channel?
            Cid = dto.Cid;
            Command = dto.Command;
            CreatedAt = dto.CreatedAt;
            DeletedAt = dto.DeletedAt;
            Html = dto.Html;
            I18n = dto.I18n;
            Id = dto.Id;
            ImageLabels = dto.ImageLabels;
            LatestReactions = LatestReactions.TryLoadFromDtoCollection(dto.LatestReactions);
            MentionedUsers = MentionedUsers.TryLoadFromDtoCollection(dto.MentionedUsers);
            Mml = dto.Mml;
            OwnReactions = OwnReactions.TryLoadFromDtoCollection(dto.OwnReactions);
            ParentId = dto.ParentId;
            PinExpires = dto.PinExpires;
            Pinned = dto.Pinned;
            PinnedAt = dto.PinnedAt;
            PinnedBy = PinnedBy.TryLoadFromDto<UserResponseInternalDTO, User>(dto.PinnedBy);
            QuotedMessage = QuotedMessage.TryLoadFromDto<MessageInternalDTO, Message>(dto.QuotedMessage);
            QuotedMessageId = dto.QuotedMessageId;
            ReactionCounts = dto.ReactionCounts;
            ReactionScores = dto.ReactionScores;
            ReplyCount = dto.ReplyCount;
            Shadowed = dto.Shadowed;
            ShowInChannel = dto.ShowInChannel;
            Silent = dto.Silent;
            Text = dto.Text;
            ThreadParticipants = ThreadParticipants.TryLoadFromDtoCollection(dto.ThreadParticipants);
            Type = Type.TryLoadFromDto(dto.Type);
            UpdatedAt = dto.UpdatedAt;
            User = User.TryLoadFromDto<UserResponseInternalDTO, User>(dto.User);
            AdditionalProperties = dto.AdditionalProperties;

            return this;
        }
    }
}


ler-Rodrigues formula.
    ///
    /// ## Example
    ///
    /// ```
    /// # use cglinalg::{
    /// #     Quaternion,
    /// #     Matrix4x4,
    /// #     Magnitude,
    /// # };
    /// # use approx::{
    /// #     relative_eq,
    /// # };
    /// #
    /// let quaternion = Quaternion::new(1_f64, 1_f64, 1_f64, 1_f64) / 2_f64;
    ///
    /// assert_eq!(quaternion.magnitude_squared(), 1_f64);
    ///
    /// let scale = 2_f64;
    /// let expected = Matrix4x4::new(
    ///     1_f64 - scale * (1_f64 / 2_f64), scale * (1_f64 / 2_f64),         scale * 0_f64,                   0_f64,
    ///     scale * 0_f64,                   1_f64 - scale * (1_f64 / 2_f64), scale * (1_f64 / 2_f64),         0_f64,
    ///     scale * (1_f64 / 2_f64),         scale * 0_f64,                   1_f64 - scale * (1_f64 / 2_f64), 0_f64,
    ///     0_f64,                           0_f64,                           0_f64,                           1_f64
    /// );
    /// let result = quaternion.to_matrix4x4();
    ///
    /// assert_eq!(result, expected);
    /// ```
    #[rustfmt::skip]
    #[inline]
    pub fn to_matrix4x4(&self) -> Matrix4x4<S> {
        let qs = self.s;
        let qx = self.v.x;
        let qy = self.v.y;
        let qz = self.v.z;
        let zero = S::zero();
        let one = S::one();
        let two = one + one;
        let s = two / self.magnitude_squared();

        let c0r0 = one - s * qy * qy - s * qz * qz;
        let c0r1 = s * qx * qy + s * qs * qz;
        let c0r2 = s * qx * qz - s * qs * qy;
        let c0r3 = zero;

        let c1r0 = s * qx * qy - s * qs * qz;
        let c1r1 = one - s * qx * qx - s * qz * qz;
        let c1r2 = s * qy * qz + s * qs * qx;
        let c1r3 = zero;

        let c2r0 = s * qx * qz + s * qs * qy;
        let c2r1 = s * qy * qz - s * qs * qx;
        let c2r2 = one - s * qx * qx - s * qy * qy;
        let c2r3 = zero;

        let c3r0 = zero;
        let c3r1 = zero;
        let c3r2 = zero;
        let c3r3 = one;

        Matrix4x4::new(
            c0r0, c0r1, c0r2, c0r3,
            c1r0, c1r1, c1r2, c1r3,
            c2r0, c2r1, c2r2, c2r3,
            c3r0, c3r1, c3r2, c3r3
        )
    }

    /// Convert a quaternion to its equivalent affine 4x4 matrix form using
    /// preallocated storage.
    ///
    /// The following example shows the result of converting an arbitrary
    /// quaternion to its affine matrix form using the Euler-Rodrigues formula.
    ///
    /// ## Example
    ///
    /// ```
    /// # use cglinalg::{
    /// #     Quaternion,
    /// #


   id: 146
  }, {
    'en-gb': 'Panama',
    official_en_name: 'Republic of Panama',
    'zh-cn': 'å·´æ‹¿é©¬',
    native_names: 'PanamÃ¡, Panama',
    'ru-ru': 'ÐŸÐ°Ð½Ð°Ð¼Ð°',
    'en-us': 'Panama',
    'pt-br': 'Panamá',
    'de-de': 'Panama',
    cid: '153',
    'fr-fr': 'Panama',
    country_code: 'PAN',
    'es-es': 'PanamÃ¡',
    id: 147
  }, {
    'en-gb': 'Papua New Guinea',
    official_en_name: 'Independent State of Papua New Guinea',
    'zh-cn': 'å·´å¸ƒäºšæ–°å‡ å†…äºš',
    native_names: 'Papua Niu Gini, Papua New Guinea, Papua Niugini',
    'ru-ru': 'ÐŸÐ°Ð¿ÑƒÐ° â€” ÐÐ¾Ð²Ð°Ñ Ð“Ð²Ð¸Ð½ÐµÑ',
    'en-us': 'Papua New Guinea',
    'pt-br': 'Papua Nova Guiné',
    'de-de': 'Papua-Neuguinea',
    cid: '154',
    'fr-fr': 'Papouasie-Nouvelle-GuinÃ©e',
    country_code: 'PNG',
    'es-es': 'PapÃºa Nueva Guinea',
    id: 148
  }, {
    'en-gb': 'Paraguay',
    official_en_name: 'Republic of Paraguay',
    'zh-cn': 'å·´æ‹‰åœ',
    native_names: 'ParaguÃ¡i, Paraguay',
    'ru-ru': 'ÐŸÐ°Ñ€Ð°Ð³Ð²Ð°Ð¹',
    'en-us': 'Paraguay',
    'pt-br': 'Paraguai',
    'de-de': 'Paraguay',
    cid: '155',
    'fr-fr': 'Paraguay',
    country_code: 'PRY',
    'es-es': 'Paraguay',
    id: 149
  }, {
    'en-gb': 'Peru',
    official_en_name: 'Republic of Peru',
    'zh-cn': 'ç§˜é²',
    native_names: 'Piruw, Peru, PerÃº',
    'ru-ru': 'ÐŸÐµÑ€Ñƒ',
    'en-us': 'Peru',
    'pt-br': 'Perú',
    'de-de': 'Peru',
    cid: '156',
    'fr-fr': 'PÃ©rou',
    country_code: 'PER',
    'es-es': 'PerÃº',
    id: 150
  }, {
    'en-gb': 'Philippines',
    official_en_name: 'Republic of the Philippines',
    'zh-cn': 'è²å¾‹å®¾',
    native_names: 'Pilipinas, Philippines',
    'ru-ru': 'Ð¤Ð¸Ð»Ð¸Ð¿Ð¿Ð¸Ð½Ñ‹',
    'en-us': 'Philippines',
    'pt-br': 'Filipinas',
    'de-de': 'Philippinen',
    cid: '157',
    'fr-fr': 'Philippines',
    country_code: 'PHL',
    'es-es': 'Filipinas',
    id: 151
  }, {
    'en-gb': 'Pitcairn Islands',
    official_en_name: 'Pitcairn Group of Islands',
    'zh-cn': 'çš®ç‰¹å‡¯æ©ç¾¤å²›',
    native_names: 'P


ript asks for it:

```console
root@kali:/media/sf_CTFs/tamu/Snakes_over_cheese# python reversing2.pyc
Clock.exe
>: SuperSecretKey
flag{decompile}
```

# Hello World
Misc, 339 points

## Description:

> My first program!

The source code of a cpp file was attached.

## Solution:

Upon first inspection, the source code seems very innocent:

```c++
#include <iostream>
using namespace std;

int main()
{
	cout << "Hello, Worlds!\n";
	return 0;
}
```

However, the source code itself starts at line #148 of the file, and up to that line are empty lines. Or are they? A closer inspection shows that lines 1-145 contain spaces and tabs.

A visualization of this can be achieved using the following short script:

```python
with open ("hello_world.cpp") as f:
    contents = f.read()
    print contents.replace(" ", "\\s").replace("\t", "\\t")
```

Output:
```
\s\s\s\t\t\s\s\t\t\t
\s\s\s\t\t\s\t\s\s\t
\s\s\s\t\t\s\s\t\t\t
\s\s\s\t\t\s\s\t\s\t
\s\s\s\t\t\s\t\t\s\t
\s\s\s\t\t\t\t\s\t\t
\s\s\s\t\t\s\s\s\s
\s\s\s\t\t\s\t\s\s\s
\s\s\s\t\s\t\t\t\t\t
\s\s\s\t\t\s\t\t\s\t
\s\s\s\t\t\t\t\s\s\t
\s\s\s\t\s\t\t\t\t\t
\s\s\s\t\t\t\s\t\t\t
\s\s\s\t\t\s\t\s\s\s
\s\s\s\t\t\s\t\s\s
\s\s\s\t\t\t\s\t\s\s
\s\s\s\t\s\t\t\t\t\t
\s\s\s\t\t\t\s\s\t\t
\s\s\s\t\t\t\s\s\s\s
\s\s\s\t\t\s\t\s\s
\s\s\s\t\t\s\s\s\t\t
\s\s\s\t\t\s\s\s\t
\s\s\s\t\t\s\t\t\t\s
\s\s\s\t\t\s\s\t\t\t
\s\s\s\t\s\t\t\t\t\t
\s\s\s\t\t\t\t\s\s\t
\s\s\s\t\t\s\s\s\s
\s\s\s\t\t\t\s\t\s\t
\s\s\s\t\s\t\t\t\t\t
\s\s\s\t\t\s\t\s\s\s
\s\s\s\t\t\s\t\s\s
\s\s\s\t\t\t\s\t\t\s
\s\s\s\t\t\s\s\t\t
\s\s\s\t\t\t\t\t\s\t
\s\s\s\t\s\s\s\s\t
\s\s\s\t\t\s\s\t\s\t
\s\s\s\t\t\s\s\s\t\t
\s\s\s\t\t\s\s\s\s\t
\s\s\s\t\t\t\s\s\s\s
\s\s\s\t\t\t\s\s\t\t
\s\s\s\t\t\s\s\t\s\t
\s\s\s\t\t\t\s\t\s\s
\s\s\s\t\t\s\t\s\s\t
\s\s\s\t\t\s\t\s\s\s
\s\s\s\t\t\t\s\t\t\t
\s\s\s\t\s\s\s\s\s
\s\s\s\t\t\s\s\t\t\s
\s\s\s\t\t\s\t\t\t\t
\s\s


o2,this.t1,this.t2,this.t3,this.t4)
            is Simple.AnnotationCmd -> this.mentionedVariables.toTreapSet()
            is Simple.SummaryCmd -> this.summ.variables.toTreapSet()
            is EVM.AssigningCmd.AssignLibraryAddressCmd -> treapSetOf()
            is CVL.ArrayLengthRead -> treapSetOf(this.rhs)
            is CVL.StringLastWord -> treapSetOf(this.rhs)
            is CVL.CopyBlockchainState -> treapSetOf()
            is CVL.ReadElement -> treapSetOf(this.base, this.physicalIndex)
            is CVL.SetArrayLength -> treapSetOf(this.len)
            is CVL.SetBlockchainState -> treapSetOf(this.stateVar)
            is CVL.WriteElement -> treapSetOf(this.physicalIndex, this.value)
            is CVL.AssignVMParam -> treapSetOf()
            is CVL.AssignBytesBlob -> treapSetOf(this.rhs)
            is CVL.CompareStorage -> treapSetOf(this.storage1, this.storage2)
            is CVL.ArrayCopy -> this.dst.getReferencedSyms() + this.src.getReferencedSyms()
            is CVL.LocalAlloc -> treapSetOf(this.arr)
            is CVL.CompareBytes1Array -> treapSetOf(this.left, this.right)
            is Move.BorrowFieldCmd -> treapSetOf(this.srcRef)
            is Move.BorrowLocCmd -> treapSetOf(this.loc)
            is Move.EqCmd -> treapSetOf(this.a, this.b)
            is Move.GhostArrayBorrowCmd -> treapSetOf(this.index, this.arrayRef)
            is Move.HashCmd -> treapSetOf(this.loc)
            is Move.PackStructCmd -> this.srcs.toTreapSet()
            is Move.ReadRefCmd -> treapSetOf(this.ref)
            is Move.UnpackStructCmd -> treapSetOf(this.src)
            is Move.VecBorrowCmd -> treapSetOf(this.index, this.srcRef)
            is Move.VecLenCmd -> treapSetOf(this.ref)
            is Move.VecPackCmd -> this.srcs.toTreapSet()
            is Move.VecPopBackCmd -> treapSetOf(this.ref)
            is Move.VecPushBackCmd -> treapSetOf(this.ref, this.src)
            is Move.VecUnpackCmd -> treapSetOf(this.src)
            is Move.WriteRefCmd -> treapSetOf(this.ref, this.src)
        }
        return rhsSymbols.filterIsInstance<TACSymbol.Var>()
    }

    fun getFreeVarsOfRhsExtended() = when(this) {
            is Simple.AssigningCmd.AssignExpCmd -> rhs.getFreeVarsExtended()
            is Simple.AssigningCmd.WordLoad -> getFreeVarsOfRhs() +
                (loc as? TACSymbol.Var)?.meta?.get(TACMeta.ACCESS_PATHS)?.support.orEmpty()
            is Simple.WordStore -> getFreeVarsOfRhs() +
                (loc as? TACSymbol.Var)?.meta?.get(TACMeta.ACCESS_PATHS)?.support.orEmpty()
            else -> getFreeVarsOfRhs()
        }

    /**
     * Note this is different from [getFreeVarsOfRhs]:
     *  - also returns constants, not only variables
     *  - the "*Store*" commands, (like [TACCmd.Simple.WordStore]) cases don't return the "base" as part of the rhs
     */
    fun getRhs(): TreapSet<TACSymbol> {
        return when (this) {
            is Simple.LabelCmd -> treapSetOf()
            Simple.NopCmd -> treapSetOf()
            is Simple.AssigningCmd.AssignExpCmd -> this.rhs.subsFull.toSymSet()
            is Simple.AssumeExpCmd -> this.cond.subsFull.toSymSet()


Add a block element from a leaf parser. This
makes sure any extra composite block markup (such as blockquote
markers) inside the block are also added to the syntax tree.

  elt(type: string, from: number, to: number, children?: readonly Element[]) → Element
elt(tree: Tree, at: number) → Element

Create an Element object to represent some syntax
node.

    interface
    BlockParser

Block parsers handle block-level structure. There are three
general types of block parsers:

Composite block parsers, which handle things like lists and
blockquotes. These define a parse method
that starts a composite block
and returns null when it recognizes its syntax.

Eager leaf block parsers, used for things like code or HTML
blocks. These can unambiguously recognize their content from its
first line. They define a parse method
that, if it recognizes the construct,
moves the current line forward to the
line beyond the end of the block,
add a syntax node for the block, and
return true.

Leaf block parsers that observe a paragraph-like construct as it
comes in, and optionally decide to handle it at some point. This
is used for "setext" (underlined) headings and link references.


	nop					#   out of pipe.
	nop
	nop
	mtc0	t0, MACH_COP_0_STATUS_REG	# Restore status reg.
	nop					# Insure cache unisolated.
	nop
	nop
	nop
	j	ra				# return and run cached
	nop
	.set	reorder
END(MachFlushDCache)
#else
/*----------------------------------------------------------------------------
 *
 * MachFlushDCache --
 *
 *	void MachFlushDCache(addr, len)
 *		vm_offset_t addr, len;
 *
 *	Flush data cache for range of addr to addr + len - 1.
 *	The address can be any valid address so long as no TLB misses occur.
 *	(Be sure to use cached K0SEG kernel addresses)
 * Results:
 *	None.
 *
 * Side effects:
 *	The contents of the cache is flushed.
 *
 *----------------------------------------------------------------------------
 */
LEAF(MachFlushDCache)
	.set	noreorder
	mfc0	t0, MACH_COP_0_STATUS_REG	# Save SR
	mtc0	zero, MACH_COP_0_STATUS_REG	# Disable interrupts.

	la	v1, 1f
	or	v1, MACH_UNCACHED_MEMORY_ADDR	# Run uncached.
	j	v1
	nop
1:
	bc0t	1b				# make sure stores are complete
	li	v1, MACH_SR_ISOL_CACHES
	mtc0	v1, MACH_COP_0_STATUS_REG
	nop
	addu	a1, a1, a0			# compute ending address
1:
	addu	a0, a0, 4
	bne	a0, a1, 1b
	sb	zero, -4(a0)

	mtc0	t0, MACH_COP_0_STATUS_REG	# enable interrupts
	j	ra				# return and run cached
	nop
	.set	reorder
END(MachFlushDCache)
#endif /* NOTDEF */

#ifdef KADB
/*
 * Read a long and return it.
 * Note: addresses can be unaligned!
 *
 * long
L* kdbpeek(addr)
L*	caddt_t addr;
L* {
L*	return (*(long *)addr);
L* }
 */
#ifdef NOTDEF
LEAF(kdbpeek)
	li	v0, KADBERR
	sw	v0, UADDR+U_PCB_ONFAULT
	and	v0, a0, 3		# unaligned address?
	bne	v0, zero, 1f
	lw	v0, (a0)		# aligned access
	b	2f
1:
	LWHI	v0, 0(a0)		# get next 4 bytes (unaligned)
	LWLO	v0, 3(a0)
2:
	sw	zero, UADDR+U_PCB_ONFAULT
	j	ra			# made it w/o errors
kadberr:
	li	v0, 1			# trap sends us here
	sw	v0, kdbmkfault
	j	ra
END(kdbpeek)
#endif /* NOTDEF */

/*
 * Write a long to 'addr'.
 * Note: addresses can be unaligned!
 *
L* void
L* kdbpoke(addr, value)
L*	caddt_t addr;
L*	long value;
L* {
L*	*(long *)addr = value;
L* }
 */
#ifdef NOTDEF
LEAF(kdbpoke)
	li	v0, KADBERR
	sw	v0, UADDR+U_PCB_ONFAULT
	and	v0, a0, 3		# unaligned address?
	bne	v0, zero, 1f
	sw	a1, (a0)		# aligned access
	b	2f
1:
	SWHI	a1, 0(a0)		# store next 4 bytes (unaligned)
	SWLO	a1, 3(a0)
	and	a0, a0, ~3		# align address for cache flush
2:
	sw	zero, UADDR+U_PCB_ONFAULT
	li	a


ce_balance, alice_ref_balance);

        let bob_balance = bank.get_balance(&bob_keypair.pubkey());
        assert_eq!(bob_balance, starting_balance - alice_ref_balance);

        tvu.close().expect("close");
        exit.store(true, Ordering::Relaxed);
        dr_l.0.join().expect("join");
        dr_2.0.join().expect("join");
        dr_1.0.join().expect("join");
        t_receiver.join().expect("join");
        t_responder.join().expect("join");
        DB::destroy(&Options::default(), &db_ledger_path)
            .expect("Expected successful database destuction");
        let _ignored = remove_dir_all(&db_ledger_path);
    }
}
#[macro_use]
extern crate criterion;

extern crate delaunator;
extern crate rand;

use criterion::{AxisScale, Criterion, ParameterizedBenchmark, PlotConfiguration};
use delaunator::{triangulate, Point};
use rand::{Rng, SeedableRng, XorShiftRng};
use std::iter::repeat_with;

const COUNTS: &[usize] = &[100, 1000, 10_000, 100_000];

fn bench(c: &mut Criterion) {
    let mut rng = XorShiftRng::from_seed([0; 16]);

    let all_points: Vec<_> = repeat_with(|| rng.gen())
        .map(|(x, y)| Point { x, y })
        .take(*COUNTS.last().unwrap())
        .collect();

    let bench = ParameterizedBenchmark::new(
        "triangulate",
        move |b, &&count| {
            let points = &all_points[..count];
            b.iter(move || triangulate(points))
        },
        COUNTS,
    );

    c.bench(
        "triangulate",
        bench
            .sample_size(20) // override to a small sample size, otherwise it takes too long
            .plot_config(PlotConfiguration::default().summary_scale(AxisScale::Logarithmic)),
    );
}

criterion_group!(benches, bench);
criterion_main!(benches);
<reponame>ducktec/esp32c3<gh_stars>0
#[doc = "Reader of register INTERRUPT_CORE0_CPU_INT_PRI_20"]
pub type R = crate::R<u32, super::INTERRUPT_CORE0_CPU_INT_PRI_20>;
#[doc = "Writer for register INTERRUPT_CORE0_CPU_INT_PRI_20"]
pub type W = crate::W<u32, super::INTERRUPT_CORE0_CPU_INT_PRI_20>;
#[doc = "Register INTERRUPT_CORE0_CPU_INT_PRI_20 `reset()`'s with value 0"]
impl crate::ResetValue for super::INTERRUPT_CORE0_CPU_INT_PRI_20 {
    type Type = u32;
    #[inline(always)]
    fn reset_value() -> Self::Type {
        0
    }
}
#[doc = "Reader of field `INTERRUPT_CORE0_CPU_PRI_20_MAP`"]
pub type INTERRUPT_CORE0_CPU_PRI_20_MAP_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `INTERRUPT_CORE0_CPU_PRI_20_MAP`"]
pub struct INTERRUPT_CORE0_CPU_PRI_20_MAP_W<'a> {
    w: &'a mut W,
}
impl<'a> INTERRUPT_CORE0_CPU_PRI_20_MAP_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !0x0f) | ((value as u32) & 0x0f);
        self.w
    }
}
impl R {
    #[doc = "Bits 0:3"]
    #[inline(always)]
    pub fn interrupt_core0_cpu_pri_20_map(&self) -> INTERRUPT_CORE0_CPU_PRI_20_MAP_R {
        INTERRUPT_CORE0_CPU_PRI_20_MAP_R::new((self.bits & 0x0f) as u8)


8074aef0',1,'glm::GLM_ALIGNED_TYPEDEF(fmat3x2, aligned_fmat3x2, 16)'],['../a00364.html#ga27b13f465abc8a40705698145e222c3f',1,'glm::GLM_ALIGNED_TYPEDEF(fmat3x3, aligned_fmat3x3, 16)'],['../a00364.html#ga2608d19cc275830a6f8c0b6405625a4f',1,'glm::GLM_ALIGNED_TYPEDEF(fmat3x4, aligned_fmat3x4, 16)'],['../a00364.html#ga93f09768241358a287c4cca538f1f7e7',1,'glm::GLM_ALIGNED_TYPEDEF(fmat4x2, aligned_fmat4x2, 16)'],['../a00364.html#ga7c117e3ecca089e10247b1d41d88aff9',1,'glm::GLM_ALIGNED_TYPEDEF(fmat4x3, aligned_fmat4x3, 16)'],['../a00364.html#ga07c75cd04ba42dc37fa3e105f89455c5',1,'glm::GLM_ALIGNED_TYPEDEF(fmat4x4, aligned_fmat4x4, 16)'],['../a00364.html#ga65ff0d690a34a4d7f46f9b2eb51525ee',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2, 16)'],['../a00364.html#gadd8ddbe2bf65ccede865ba2f510176dc',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3, 16)'],['../a00364.html#gaf18dbff14bf13d3ff540c517659ec045',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat4x4, aligned_f32mat4, 16)'],['../a00364.html#ga66339f6139bf7ff19e245beb33f61cc8',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat2x2, aligned_f32mat2x2, 16)'],['../a00364.html#ga1558a48b3934011b52612809f443e46d',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat2x3, aligned_f32mat2x3, 16)'],['../a00364.html#gaa52e5732daa62851627021ad551c7680',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat2x4, aligned_f32mat2x4, 16)'],['../a00364.html#gac09663c42566bcb58d23c6781ac4e85a',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat3x2, aligned_f32mat3x2, 16)'],['../a00364.html#ga3f510999e59e1b309113e1d561162b29',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat3x3, aligned_f32mat3x3, 16)'],['../a00364.html#ga2c9c94f0c89cd71ce56551db6cf4aaec',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat3x4, aligned_f32mat3x4, 16)'],['../a00364.html#ga99ce8274c750fbfdf0e70c95946a2875',1,'glm::GLM_ALIGNED_TYPEDEF(f32mat4x2, aligned_f32mat4x2, 16)'],['../a00364.html#ga9476ef66790239df53dbe66f


 String = "", stream: PrintStream = System.out) = stream.print("""$name:
        $this""")

    @JvmOverloads
    fun println(name: String = "", stream: PrintStream = System.out) = stream.println("""$name:
        $this""")

    override fun toString() = """
        $v00 $v10 $v20
        $v01 $v11 $v21
        $v02 $v12 $v22"""

//    override fun toString() =
//            "| ${this[0][ 0]}][ ${this[1][ 0]}][ ${this[2][ 0]} |\n" +
//                    "| ${this[0][ 1]}][ ${this[1][ 1]}][ ${this[2][ 1]} |\n" +
//                    "| ${this[0][ 2]}][ ${this[1][ 2]}][ ${this[2][ 2]} |"
}package glm_.mat4x2

/**
 * Created by GBarbieri on 26.04.2017.
 */

import glm_.ToBuffer
import glm_.vec2.Vec2t
import java.io.PrintStream

abstract class Mat4x2t<T : Number> : ToBuffer {

    abstract var a0: T
    abstract var a1: T

    abstract var b0: T
    abstract var b1: T

    abstract var c0: T
    abstract var c1: T

    abstract var d0: T
    abstract var d1: T

    operator fun component1() = a0
    operator fun component2() = a1

    operator fun component3() = b0
    operator fun component4() = b1

    operator fun component5() = c0
    operator fun component6() = c1

    operator fun component7() = d0
    operator fun component8() = d1

    // -- Accesses --

    abstract operator fun get(index: Int): Vec2t<out Number>
    abstract operator fun get(column: Int, row: Int): T

    abstract operator fun set(index: Int, value: Vec2t<out Number>)
    abstract operator fun set(column: Int, row: Int, value: T)

    // component alias

    var v00
        @JvmName("v00") get() = a0
        @JvmName("v00") set(value) {
            a0 = value
        }
    var v01
        @JvmName("v01") get() = a1
        @JvmName("v01") set(value) {
            a1 = value
        }

    var v10
        @JvmName("v10") get() = b0
        @JvmName("v10") set(value) {
            b0 = value
        }
    var v11
        @JvmName("v11") get() = b1
        @JvmName("v11") set(value) {
            b1 = value
        }

    var v20
        @JvmName("v20") get() = c0
        @JvmName("v20") set(value) {
            c0 = value
        }
    var v21
        @JvmName("v21") get() = c1
        @JvmName("v21") set(value) {
            c1 = value
        }

    var v30
        @JvmName("v30") get() = d0
        @JvmName("v30") set(value) {
            d0 = value
        }
    var v31
        @JvmName("v31") get() = d1
        @JvmName("v31") set(value) {
            d1 = value
        }

    companion object {
        const val length = 4 * 2
    }

    @JvmOverloads
    fun print(name: String = "", stream: PrintStream = System.out) = stream.print("""$name:
        $this""")

    @JvmOverloads
    fun println(name: String = "", stream: PrintStream = System.out) = stream.println("""$name:
        $this""")

    override fun toString() = """
        $v00 $v10 $v20 $v30
        $v01 $v11 $v21 $v31"""

//


>13-15F

16-20F

Sacred Tree Extension

1-20F

21-23F

24-29F

30-39F

40-59F

60-64F

65-80F

81-89F

90-99F

Monsters

Behemoths

Items

Weapon

Shield

Bracelet

Projectile

Food

Grass

Scroll

Staff

Pot

Incense

# Strategy

General Advice (First Clear & Sacred Tree Extension)

 Trapper Status

Shiren's color palette changes to a purple one while he has Trapper status.
All hidden traps are revealed, and traps can be picked up, thrown, or set on the ground.
Monsters can be ensnared by traps, and traps never activate when Shiren walks on top of them.
Once set, traps can't be picked up again, and the status is lost while the bracelet is unequipped.

Shiren earns 10% of the regular amount of experience points when a monster steps on a trap,
and also earns x2.0 experience points when a monster is defeated by a trap that deals damage.
However, traps like Rotting Trap that instantly defeat a monster do not grant experience points.

 Trapping Floating Type Monsters

Floating types normally can't be ensnared by traps since they float above the trap on the ground.
However, you can still lure them onto a trap → shoot arrows until one misses to activate the trap,
resulting in the Floating type monster getting caught in the trap located underneath them.

Floating Type Monsters:

|Monster|Floor|
|-|-|
|Pumphantasm|4-5F|
|Hell Reaper|7-9F|
|Flamepuff|18-20F|
|Soul Reaper|40F, 54-60F, 64-70F, 75-79F, 85-89F, 95-99F|
|Pumplich|49-53F, 60-63


olor: #fff;
    border: 1px solid #9d9d9d;
    -mozilla-box-shadow: 2px 2px 3px #ccc;
    -webkit-box-shadow: 2px 2px 3px #d4d4d4;
    box-shadow: 2px 2px 3px #e5e5e5;
}

body.with-sidebar dl.zend_form {
    width: auto;
}

.zend_form dt {
    margin-top: 8px;
    padding: 0;
    position: relative;
    font-weight: bold;
    color: #696969;
}

.zend_form dt:first-child {
    margin-top: 0;
}

.zend_form dd {
    margin: 4px 0 0;
    padding: 0;
}

.zend_form dd .description{ font-size: 11px; }

.zend_form dd input[type=text], .zend_form dd input[type=password] {
    display: block;
    width: 80%;
    color: #333;

    background-color: #FFFFFF;
    border: 1px solid #9D9D9D;
    font-family: Arial,Helvetica,sans-serif;
    font-size: 12px;
    height: 23px;
    margin: 0;
    padding: 0;
    text-indent: 3px;
    -moz-box-shadow: inset 0px 2px 2px rgba(0, 0, 0, 0.1);
    -webkit-box-shadow: inset 0px 2px 2px rgba(0, 0, 0, 0.1);
    box-shadow: inset 0px 2px 2px rgba(0, 0, 0, 0.1);
}
.zend_form dd textarea {
    display: block;
    color: #333;
    background-color: #FFFFFF;
    border: 1px solid #9D9D9D;
    font-family: Arial,Helvetica,sans-serif;
    font-size: 12px;
    margin: 0;
    padding: 0;
    text-indent: 3px;
    -moz-box-shadow: inset 0px 2px 2px rgba(0, 0, 0, 0.1);
    -webkit-box-shadow: inset 0px 2px 2px rgba(0, 0, 0, 0.1);
    box-shadow: inset 0px 2px 2px rgba(0, 0, 0, 0.1);
}
.zend_form dd input[type=password] {
    width: 50%;
    background-color: #F8F8F8;
}

.zend_form dd input[type=file] {
    width: 80%;
}

.zend_form dd input[type=text]:focus, .zend_form dd input[type=password]:focus, .zend_form dd textarea:focus {
    border: 1px solid #00b5f1;
}

.zend_form dd input.small
{
    width: 40px;
}

.zend_form dd select {
    width: 50%;
    margin: 0;
    padding: 3px 5px;
    border: 1px solid #9d9d9d;
}

.zend_form dd ul.errors {
    margin: 3px 0;
    padding: 0 8px;
}

.zend_form dd ul.errors li {
    font-size: 1.1em;
    color: #cc0000;
}

.zend_form fieldset {
    border: 1px solid #ccc;
}

.zend_form fieldset.closed {
    border-left-color: #fff;
    border-bottom-color: #fff;
    border-right-color: #fff;
}

.zend_form fieldset legend .ui-icon {
    float: left;
}

.zend_form dd input[type=submit] {
    margin: 0;
    padding: 3px 12px 4px;
    color: #fff;
    background-color: #007fb3;
    background: -moz-linear-gradient(top, #2390bd 0, #007fb3 100%);
    background


	TYPE::Capacity => Cache::with_capacity(value),
		TYPE::Size => Cache::with_size(value * data_size),
	};

	populate(&mut cache, value, data_size, KEY_PREFIX);

	let format_range = format!("{:?}", &range);
	let range_len = range.len() as u32;

	let rev = range.to_owned().rev();
	let rev_len = rev.len() as u32;

	let start = Instant::now();

	for idx in range {
		if cache.get(format!("{}{}", KEY_PREFIX, idx)).is_some() {}
	}

	let duration_until = Instant::now().duration_since(start);

	println!(
		"{:10}   {:10}   {:10}   {:10}   {:32}",
		value,
		data_size,
		format!("{:?}", duration_until),
		format!("{:?}", duration_until.div(range_len)),
		format_range
	);

	//

	let mut cache = match t {
		TYPE::Capacity => Cache::with_capacity(value),
		TYPE::Size => Cache::with_size(value * data_size),
	};

	populate(&mut cache, value, data_size, KEY_PREFIX);

	let format_range = format!("{:?}", &rev);

	let start = Instant::now();

	for idx in rev {
		if cache.get(format!("{}{}", KEY_PREFIX, idx)).is_some() {}
	}

	let duration_until = Instant::now().duration_since(start);

	println!(
		"{:10}   {:10}   {:10}   {:10}   {:32}",
		value,
		data_size,
		format!("{:?}", duration_until),
		format!("{:?}", duration_until.div(rev_len)),
		format_range
	);
}

fn main() {
	println!("# TYPE: CAPACITY");
	println!(
		"{:10}   {:10}   {:10}   {:10}   {:32}",
		"ITEMS", "SIZE", "SUM", "AVERAGE", "RANGE"
	);

	perf_add_read(TYPE::Capacity, 64, 256 * 1024, 0..63);
	perf_add_read(TYPE::Capacity, 64, 256 * 1024, 26..36);

	println!();

	perf_add_read(TYPE::Capacity, 64, 1024 * 1024, 0..63);
	perf_add_read(TYPE::Capacity, 64, 1024 * 1024, 26..36);

	println!();

	perf_add_read(TYPE::Capacity, 64, 2 * 1024 * 1024, 0..63);
	perf_add_read(TYPE::Capacity, 64, 2 * 1024 * 1024, 26..36);

	println!();

	perf_add_read(TYPE::Capacity, 64, 4 * 1024 * 1024, 0..63);
	perf_add_read(TYPE::Capacity, 64, 4 * 1024 * 1024, 26..36);

	println!();

	perf_add_read(TYPE::Capacity, 64, 8 * 1024 * 1024, 0..63);
	perf_add_read(TYPE::Capacity, 64, 8 * 1024 * 1024, 26..36);

	///////////////////////////////////////////////////////////

	println!();
	println!();

	println!("# TYPE: SIZE");
	println!(
		"{:10}   {:10}   {:10}   {:10}   {:32}",
		"ITEMS", "SIZE", "SUM", "AVERAGE", "RANGE"
	);

	perf_add_read(TYPE::Size, 64, 256 * 1024, 0..63);
	perf_add_read(TYPE::Size, 64, 256 * 1024, 26..36);

	println!();

	perf_add_read(TYPE::Size, 64, 1024 * 1024, 0..63);
	perf_add_read(TYPE::Size, 64, 1024 * 1024, 26..36);

	println!();

	perf_add_read(TYPE::Size, 64, 2 * 1024 * 1024, 0..63);
	perf_add_read(TYPE::Size, 64, 2 * 1024 * 1024, 26..36);

	println!();

	perf_add_read(TYPE::Size, 64, 4 * 1024 * 1024, 0..63);
	perf_add_read(TYPE::Size, 64, 4 *


s-48-21.5-48-48 21.49-48 48-48 48 21.5 48 48z'/%3E%3C/svg%3E")}.EasyMDEContainer .editor-toolbar .ordered-list:before{-webkit-mask-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 512 512'%3E%3Cpath d='M55.1 56.04c0-13.26 11.64-24 24-24h32c14.2 0 24 10.74 24 24V176h16c14.2 0 24 10.8 24 24 0 13.3-9.8 24-24 24h-80c-12.36 0-24-10.7-24-24 0-13.2 11.64-24 24-24h16V80.04h-8c-12.36 0-24-10.75-24-24zm63.6 285.16c-6.6-7.4-18.3-6.9-24.05 1.2l-11.12 15.5c-7.7 10.8-22.69 13.3-33.48 5.6-10.79-7.7-13.28-22.7-5.58-33.4l11.12-15.6c23.74-33.3 72.31-35.7 99.21-4.9 21.3 23.5 20.8 60.9-1.1 84.7L118.8 432H152c13.3 0 24 10.7 24 24s-10.7 24-24 24H64c-9.53 0-18.16-5.6-21.98-14.4-3.83-8.7-2.12-18.9 4.34-25.9l72.04-78c5.3-5.8 5.4-14.6.3-20.5zM512 64c17.7 0 32 14.33 32 32 0 17.7-14.3 32-32 32H256c-17.7 0-32-14.3-32-32 0-17.67 14.3-32 32-32h256zm0 160c17.7 0 32 14.3 32 32s-14.3 32-32 32H256c-17.7 0-32-14.3-32-32s14.3-32 32-32h256zm0 160c17.7 0 32 14.3 32 32s-14.3 32-32 32H256c-17.7 0-32-14.3-32-32s14.3-32 32-32h256z'/%3E%3C/svg%3E");mask-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 512 512'%3E%3Cpath d='M55.1 56.04c0-13.26 11.64-24 24-24h32c14.2 0 24 10.74 24 24V176h16c14.2 0 24 10.8 24 24 0 13.3-9.8 24-24 24h-80c-12.36 0-24-10.7-24-24 0-13.2 11.64-24 24-24h16V80.04h-8c-12.36 0-24-10.75-24-24zm63.6 285.16c-6.6-7.4-18.3-6.9-24.05 1.2l-11.12 15.5c-7.7 10.8-22.69 13.3-33.48 5.6-10.79-7.7-13.28-22.7-5.58-33.4l11.12-15.6c23.74-33.3 72.31-35.7 99.21-4.9 21.3 23.5 20.8 60.9-1.1 84.7L118.8 432H152c13.3 0 24 10.7 24 24s-10.7 24-24 24H64c-9.53 0-18.16-5.6-21.98-14.4-3.83-8.7-2.12-18.9 4.34-25.9l72.04-78c5.3-5.8 5.4-14.6.3-20.5


r type;
	char answer;
	unsigned short id_num2;
	unsigned short id_num1;
	short sin_family;
	short sin_port;
	short sin_addr2;
	short sin_addr1;
};

void
swapresponse(rsp)
	CTL_RESPONSE *rsp;
{
	struct ctl_response_sun swaprsp;

	if (rsp->addr.sin_family != AF_INET) {
		bcopy(rsp, &swaprsp, sizeof(struct ctl_response_sun));
		if (swaprsp.sin_family == swapshort(AF_INET)) {
			rsp->type = swaprsp.type;
			rsp->answer = swaprsp.answer;
			rsp->id_num = swapshort(swaprsp.id_num1)
			    | (swapshort(swaprsp.id_num2) << 16);
			rsp->addr.sin_family = swapshort(swaprsp.sin_family);
 			rsp->addr.sin_port = swaprsp.sin_port;
			rsp->addr.sin_addr.s_addr =
			    swaprsp.sin_addr2 | (swaprsp.sin_addr1 << 16);
		}
	}
}
#endif


ackList.getTrackById')
  @DocsEditable()
  @Experimental() // untriaged
  VideoTrack getTrackById(String id) native;

  @DomName('VideoTrackList.onchange')
  @DocsEditable()
  @Experimental() // untriaged
  Stream<Event> get onChange => changeEvent.forTarget(this);
}
// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// WARNING: Do not edit - generated code.

@DomName('VoidCallback')
// http://www.w3.org/TR/file-system-api/#the-voidcallback-interface
@Experimental()
typedef void VoidCallback();
// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

@DocsEditable()
@DomName('VTTCue')
@Experimental() // untriaged
@Native("VTTCue")
class VttCue extends TextTrackCue {
  // To suppress missing implicit constructor warnings.
  factory VttCue._() { throw new UnsupportedError("Not supported"); }

  @DomName('VTTCue.VTTCue')
  @DocsEditable()
  factory VttCue(num startTime, num endTime, String text) {
    return VttCue._create_1(startTime, endTime, text);
  }
  static VttCue _create_1(startTime, endTime, text) => JS('VttCue', 'new VTTCue(#,#,#)', startTime, endTime, text);

  @DomName('VTTCue.align')
  @DocsEditable()
  @Experimental() // untriaged
  String align;

  @DomName('VTTCue.line')
  @DocsEditable()
  @Experimental() // untriaged
  int line;

  @DomName('VTTCue.position')
  @DocsEditable()
  @Experimental() // untriaged
  int position;

  @DomName('VTTCue.regionId')
  @DocsEditable()
  @Experimental() // untriaged
  String regionId;

  @DomName('VTTCue.size')
  @DocsEditable()
  @Experimental() // untriaged
  int size;

  @DomName('VTTCue.snapToLines')
  @DocsEditable()
  @Experimental() // untriaged
  bool snapToLines;

  @DomName('VTTCue.text')
  @DocsEditable()
  @Experimental() // untriaged
  String text;

  @DomName('VTTCue.vertical')
  @DocsEditable()
  @Experimental() // untriaged
  String vertical;

  @JSName('getCueAsHTML')
  @DomName('VTTCue.getCueAsHTML')
  @DocsEditable()
  @Experimental() // untriaged
  DocumentFragment getCueAsHtml() native;
}
// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

@DocsEditable()
@DomName('VTTRegion')
@Experimental() // untriaged
@Native("VTTRegion")
class VttRegion extends Interceptor {
  // To suppress missing implicit constructor warnings.
  factory VttRegion._() { throw new UnsupportedError("Not supported"); }

  @DomName('VTTRegion.VTTRegion')
  @DocsEditable()
  factory VttRegion() {
    return VttRegion._create_1();
  }
  static VttRegion _create_1() => JS('VttRegion', 'new VTTRegion()');

  @DomName('VTTRegion.height')
  @DocsEditable()
  @Experimental() // untriaged
  int height;

  @DomName('VTTRegion.id')
  @DocsEditable()
  @Experimental() // untriaged
  String id;

  @DomName('VTTRegion.regionAnchorX')
  @DocsEditable


e_run(g));
  time('    parentDummyChains', () => parentDummyChains(g));
  time('    addBorderSegments', () => addBorderSegments(g));
  time('    order', () => order(g));
  time('    insertSelfEdges', () => insertSelfEdges(g));
  time('    adjustCoordinateSystem', () => adjust(g));
  time('    position', () => position(g));
  time('    positionSelfEdges', () => positionSelfEdges(g));
  time('    removeBorderNodes', () => removeBorderNodes(g));
  time('    normalize.undo', () => normalize_undo(g));
  time('    fixupEdgeLabelCoords', () => fixupEdgeLabelCoords(g));
  time('    undoCoordinateSystem', () => coordinate_system_undo(g));
  time('    translateGraph', () => translateGraph(g));
  time('    assignNodeIntersects', () => assignNodeIntersects(g));
  time('    reversePoints', () => reversePointsForReversedEdges(g));
  time('    acyclic.undo', () => undo(g));
}

/*
 * Copies final layout information from the layout graph back to the input
 * graph. This process only copies whitelisted attributes from the layout graph
 * to the input graph, so it serves as a good place to determine what
 * attributes can influence layout.
 */
function updateInputGraph(inputGraph, layoutGraph) {
  forEach/* default */.Z(inputGraph.nodes(), function (v) {
    var inputLabel = inputGraph.node(v);
    var layoutLabel = layoutGraph.node(v);

    if (inputLabel) {
      inputLabel.x = layoutLabel.x;
      inputLabel.y = layoutLabel.y;

      if (layoutGraph.children(v).length) {
        inputLabel.width = layoutLabel.width;
        inputLabel.height = layoutLabel.height;
      }
    }
  });

  forEach/* default */.Z(inputGraph.edges(), function (e) {
    var inputLabel = inputGraph.edge(e);
    var layoutLabel = layoutGraph.edge(e);

    inputLabel.points = layoutLabel.points;
    if (Object.prototype.hasOwnProperty.call(layoutLabel, 'x')) {
      inputLabel.x = layoutLabel.x;
      inputLabel.y = layoutLabel.y;
    }
  });

  inputGraph.graph().width = layoutGraph.graph().width;
  inputGraph.graph().height = layoutGraph.graph().height;
}

var graphNumAttrs = ['nodesep', 'edgesep', 'ranksep', 'marginx', 'marginy'];
var graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: 'tb' };
var graphAttrs = ['acyclicer', 'ranker', 'rankdir', 'align'];
var nodeNumAttrs = ['width', 'height'];
var nodeDefaults = { width: 0, height: 0 };
var edgeNumAttrs = ['minlen', 'weight', 'width', 'height', 'labeloffset'];
var edgeDefaults = {
  minlen: 1,
  weight: 1,
  width: 0,
  height: 0,
  labeloffset: 10,
  labelpos: 'r',
};
var edgeAttrs = ['labelpos'];

/*
 * Constructs a new graph from the input graph, which can be used for layout.
 * This process copies only whitelisted attributes from the input graph to the
 * layout graph. Thus this function serves as a good place to determine what
 * attributes can influence layout.
 */
function buildLayoutGraph(inputGraph) {
  var g = new graphlib/* Graph */.k({ multigraph: true, compound: true });
  var graph = canonicalize(inputGraph.graph());

  g.setGraph(
    merge/* default */.Z({}, graphDefaults, selectNumberAttr


*：Ceph是生活方式的选择，需要深入理解文档和硬件，社区支持至关重要。
   - **Frank Yang**：尝试Ceph，但需意识到生产环境中的长期承诺和投资。

#### 后续行动计划
- 改进Ceph的文档，特别是入门指南和硬件建议。
- 简化Ceph的使用流程，关注用户的工作流程和业务需求。
- 增强Ceph的安全性检查和错误预防机制。

#### 会议总结
会议涵盖了Ceph用户选择、价值、挑战和建议等多个方面，强调了Ceph的开源社区、灵活性和可靠性。同时，也指出了Ceph在文档、硬件选择和使用流程上的改进空间。会议最后，主持人感谢所有嘉宾的参与和贡献。---
title: "2019-12-16 :: Ceph Orchestration Meeting"
date: 2020-01-10
updated: 2020-01-11
tags:
categories:
- "视频总结"
subtitle: tech
---

### 会议纪要

#### 会议时间与参与人员
- **时间：** 会议开始于预定时间，但有几分钟延迟。
- **参与人员：** 会议由主持人主持，Brooke等团队成员参与。

#### 主要议题与讨论内容
1. **Ceph 1.2 版本发布计划**
   - Brooke 计划在未来几天内完成1.2版本的发布，目前正在进行最后的修复工作。
   - 讨论了关于自动删除OSD的代码变更，决定不再自动删除OSD，以避免数据丢失，改为用户手动操作。

2. **设计文档与未来规划**
   - 讨论了OSD移除的设计文档，目前正在等待进一步的反馈和时间来重新审视。
   - 提及了多站点RGW的设计进展，由Radia负责，可能对未来的对象存储CR有影响。

3. **Ceph Orchestrator 与 Dashboard 集成**
   - 讨论了将新的CR添加到对象存储CR中，以支持跨集群配置。
   - 计划在本周内由Elly开放设计PR，以便团队成员可以更积极地参与讨论和反馈。

4. **Ceph Manager 模块的测试与集成**
   - 讨论了Ceph Manager模块的测试问题，目前缺乏有效的QA和CI集成。
   - 提出了在Rook CI中集成Ceph Manager模块的建议，以便进行更有效的测试。

5. **其他技术细节与问题**
   - 讨论了Ceph Orchestrator的并行化问题，以及如何在多节点环境中进行有效的部署和管理。
   - 提及了Ganesha的集成问题，计划在未来进行更深入的探


r != nil {
		in, out := &in.Expander, &out.Expander
		*out = new(string)
		**out = **in
	}
	if in.MaxEmptyBulkDelete != nil {
		in, out := &in.MaxEmptyBulkDelete, &out.MaxEmptyBulkDelete
		*out = new(string)
		**out = **in
	}
	if in.MaxGracefulTerminationSec != nil {
		in, out := &in.MaxGracefulTerminationSec, &out.MaxGracefulTerminationSec
		*out = new(string)
		**out = **in
	}
	if in.MaxNodeProvisionTime != nil {
		in, out := &in.MaxNodeProvisionTime, &out.MaxNodeProvisionTime
		*out = new(string)
		**out = **in
	}
	if in.MaxTotalUnreadyPercentage != nil {
		in, out := &in.MaxTotalUnreadyPercentage, &out.MaxTotalUnreadyPercentage
		*out = new(string)
		**out = **in
	}
	if in.NewPodScaleUpDelay != nil {
		in, out := &in.NewPodScaleUpDelay, &out.NewPodScaleUpDelay
		*out = new(string)
		**out = **in
	}
	if in.OkTotalUnreadyCount != nil {
		in, out := &in.OkTotalUnreadyCount, &out.OkTotalUnreadyCount
		*out = new(string)
		**out = **in
	}
	if in.PropertyBag != nil {
		in, out := &in.PropertyBag, &out.PropertyBag
		*out = make(genruntime.PropertyBag, len(*in))
		for key, val := range *in {
			(*out)[key] = val
		}
	}
	if in.ScaleDownDelayAfterAdd != nil {
		in, out := &in.ScaleDownDelayAfterAdd, &out.ScaleDownDelayAfterAdd
		*out = new(string)
		**out = **in
	}
	if in.ScaleDownDelayAfterDelete != nil {
		in, out := &in.ScaleDownDelayAfterDelete, &out.ScaleDownDelayAfterDelete
		*out = new(string)
		**out = **in
	}
	if in.ScaleDownDelayAfterFailure != nil {
		in, out := &in.ScaleDownDelayAfterFailure, &out.ScaleDownDelayAfterFailure
		*out = new(string)
		**out = **in
	}
	if in.ScaleDownUnneededTime != nil {
		in, out := &in.ScaleDownUnneededTime, &out.ScaleDownUnneededTime
		*out = new(string)
		**out = **in
	}
	if in.ScaleDownUnreadyTime != nil {
		in, out := &in.ScaleDownUnreadyTime, &out.ScaleDownUnreadyTime
		*out = new(string)
		**out = **in
	}
	if in.ScaleDownUtilizationThreshold != nil {
		in, out := &in.ScaleDownUtilizationThreshold, &out.ScaleDownUtilizationThreshold
		*out = new(string)
		**out = **in
	}
	if in.ScanInterval != nil {
		in, out := &in.ScanInterval, &out.ScanInterval
		*out = new(string)
		**out = **in
	}
	if in.SkipNodesWithLocalStorage != nil {
		in, out := &in.SkipNodesWithLocalStorage, &out.SkipNodesWithLocalStorage
		*out = new(string)
		**out = **in
	}
	if in.SkipNodesWithSystemPods != nil {
		in, out := &in.SkipNodesWithSystemPods, &out.SkipNodesWithSystemPods
		*out = new(string)
		**out = **in
	}
}

// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ManagedClusterProperties_AutoScalerProfile_STATUS.
func (in *ManagedClusterProperties_AutoScalerProfile_STATUS) DeepCopy() *ManagedClusterProperties_AutoScalerProfile_STATUS {
	if in == nil {
		return nil
	}
	out :=


�。

引用类型的参数和返回值用作输出Pin，值类型的参数用作输入Pin。
可以用“ReturnValue”这个名字来指定使用返回值参数。

如果有多个输出Enum参数，会在函数的调用之后排成Sequecene来一一分别根据输出Enum的值来触发输出Exec。

## 测试代码：

```cpp
UENUM(BlueprintType)
enum class EMyExecPins : uint8
{
	First,
	Second,
	Third,
};

UENUM(BlueprintType)
namespace EMyExecPins2
{
	enum Type : int
	{
		Found,
		NotFound,
	};
}

UENUM(BlueprintType)
enum class EMyExecAnimalPins : uint8
{
	Cat,
	Dog,
};

public:
	UFUNCTION(BlueprintCallable, meta = (ExpandEnumAsExecs = "Pins"))
	static int32 MyEnumAsExec_Output(FString Name, EMyExecPins& Pins) { return 0; }

	UFUNCTION(BlueprintCallable, meta = (ExpandEnumAsExecs = "Pins"))
	static int32 MyEnumAsExec_Input(FString Name, TEnumAsByte<EMyExecPins2::Type> Pins) { return 0; }

	UFUNCTION(BlueprintCallable, meta = (ExpandEnumAsExecs = "ReturnValue"))
	static EMyExecPins MyEnumAsExec_Return(FString Name) { return EMyExecPins::First; }
public:
	UFUNCTION(BlueprintCallable, meta = (ExpandEnumAsExecs = "Pins"))
	static int32 MyBoolAsExec_Output(FString Name, bool& Pins) { return 0; }

	UFUNCTION(BlueprintCallable, meta = (ExpandEnumAsExecs = "Pins"))
	static int32 MyBoolAsExec_Input(FString Name, bool Pins) { return 0; }

	UFUNCTION(BlueprintCallable, meta = (ExpandEnumAsExecs = "ReturnValue"))
	static bool MyBoolAsExec_Return(FString Name) { return false; }
public:
	UFUNCTION(BlueprintCallable, meta = (ExpandEnumAsExecs = "InPins,OutAnimal|OutPins|ReturnValue"))
	static bool MyEnumAsExec_MultipleOut(FString Name, EMyExecPins InPins, EMyExecAnimalPins& OutAnimal, TEnumAsByte<EMyExecPins2::Type>& OutPins, FString& Result);
```

## 蓝图效果：

可以对照上述上述的函数原型和蓝图节点，可以发现ExpandEnumAsExecs执行3种参数类型。同时也验证了在同时拥有多个输出Enum参数的时候(代码里是OutAnimal|OutPins|ReturnValue)，会按顺序执行3次输出，就像用Sequence节点连接在了一起一样。

![Untitled](D:\github\UnrealSpecifiers\Doc\zh\Meta\Blueprint\Exec\ExpandEnumAsExecs\Untitled.png)

## 原理：

真正的创建Pin是在void UK2Node_CallFunction::CreateExecPinsForFunctionCall(const UFunction* Function)，然后这些新的ExecPin和配套的赋值输入参数值，以及根据输出参数执行不同输出ExecP


2cf7520">◆ am_hal_mspi_BE_polarity_e

          enum am_hal_mspi_BE_polarity_e

MSPI byte enable polarity.

Enumerator

AM_HAL_MSPI_BE_LOW_ENABLE

AM_HAL_MSPI_BE_HIGH_ENABLE

AM_HAL_MSPI_BE_POL_MAX

AM_HAL_MSPI_BE_LOW_ENABLE

AM_HAL_MSPI_BE_HIGH_ENABLE

AM_HAL_MSPI_BE_POL_MAX

<a id="ggab1c03d97ad14fed3f303100fd2cf7520a358765dcc85f7a843d5ac354a7c9773c" name="ggab1c03d97


/   }
@function color($map, $key) {
  @if map-has-key($map, $key) {
    @return map-get($map, $key);
  } @else {
    @warn "Error: There is no color #{$key} associated";
  }
}

/// Map deep get
/// @param {Map} $map - Map
/// @param {Arglist} $keys - Key chain
/// @return {*} - Desired value
@function map-deep-get($map, $keys...) {
  $value: $map;
  @each $key in $keys {
    $value: map-get($value, $key);
  }
  @return $value;
}

@function map-deep-merge($parent-map, $child-map) {
  $result: $parent-map;

  @each $key, $child in $child-map {
    $parent-has-key: map-has-key($result, $key);
    $parent-value: map-get($result, $key);
    $parent-type: type-of($parent-value);
    $child-type: type-of($child);
    $parent-is-map: $parent-type == map;
    $child-is-map: $child-type == map;

    @if (not $parent-has-key) or ($parent-type != $child-type) or (not ($parent-is-map and $child-is-map)) {
      $result: map-merge($result, ( $key: $child ));
    } @else {
      $result: map-merge($result, ( $key: map-deep-merge($parent-value, $child) ));
    }
  }

  @return $result
}body {
  font: 1em/1.5 BlinkMacSystemFont,-apple-system,"Segoe UI","Roboto","Oxygen","Ubuntu","Cantarell","Fira Sans","Droid Sans","Helvetica Neue","Helvetica","Arial",sans-serif;
  color: #222;
  font-weight: 400;
  padding: 20px 40px;
  background: linear-gradient(#efefef, #999) fixed;
}
.move {
  position: absolute;
  top: 100px;
  left: 100px;
  width: 140px;
  height: 80px;
  border-radius: 100%;
  color: #fff;
  background-color: #29e;
  cursor: pointer;
}
.container {
  position: absolute;
  left: 100px;
  width: 50px;
  height: 50px;
  border: 1px solid #333;
}
.inner {
  position: relative;
  top: 50%;
  transform: translateY(-50%);
  text-align: center;
}
.enter {
  background-color: #849a6f;
}
.partial-exit {
  background-color: #f40;
}
.fully-enter {
  background-color: #4E9A06;
}

.move2 {
  top


0) * (1385.0 + 3633 * t * t + 4095 * Math.Pow(t, 4) + 1575 * Math.Pow(t, 6));
         var latrad = footlat - laterm1 + laterm2 - laterm3 + laterm4;
         var lat = RadiansToDegrees(latrad);
         var seclat = 1 / Math.Cos(footlat);
         var loterm1 = x * seclat;
         var loterm2 = (Math.Pow(x, 3) / 6.0) * seclat * (psi + 2 * t * t);
         var loterm3 = (Math.Pow(x, 5) / 120.0) * seclat * (-4 * Math.Pow(psi, 3) * (1 - 6 * t * t) + psi * psi * (9 - 68 * t * t) + 72 * psi * t * t + 24 * Math.Pow(t, 4));
         var loterm4 = (Math.Pow(x, 7) / 5040.0) * seclat * (61.0 + 662 * t * t + 1320 * Math.Pow(t, 4) + 720 * Math.Pow(t, 6));
         var w = loterm1 - loterm2 + loterm3 - loterm4;
         var longrad = DegreesToRadians(getLCM(zone)) + w;
         var lon = RadiansToDegrees(longrad);

         return new double[] { lat, lon, latrad, longrad };
      }

      #endregion

      public override RectLatLng Bounds
      {
         get
         {
            return RectLatLng.FromLTRB(MinLongitude, MaxLatitude, MaxLongitude, MinLatitude);
         }
      }

      public override GSize TileSize
      {
         get
         {
            return new GSize(256, 256);
         }
      }

      public override double Axis
      {
         get
         {
            return 6378137;
         }
      }

      public override double Flattening
      {
         get
         {
            return (1.0 / 298.257223563);
         }
      }

      public override GPoint FromLatLngToPixel(double lat, double lng, int zoom)
      {
         GPoint ret = GPoint.Empty;

         lat = Clip(lat, MinLatitude, MaxLatitude);
         lng = Clip(lng, MinLongitude, MaxLongitude);

         var size = GetTileMatrixSizePixel(zoom);
         {
            var l = WGSToPP(lat, lng);
            ret.X = (long)l[0] >> (20 - zoom);
            ret.Y = size.Height - ((long)l[1] >> (20 - zoom));
         }
         return ret;
      }

      public override PointLatLng FromPixelToLatLng(long x, long y, int zoom)
      {
         PointLatLng ret = PointLatLng.Empty;

         var size = GetTileMatrixSizePixel(zoom);

         var oX = x << (20 - zoom);
         var oY = (size.Height - y) << (20 - zoom);
         {
            var l = PPToWGS(oX, oY);
            ret.Lat = Clip(l[0], MinLatitude, MaxLatitude);
            ret.Lng = Clip(l[1], MinLongitude, MaxLongitude);
         }
         return ret;
      }

      public override GSize GetTileMatrixSizeXY(int zoom)
      {
         return new GSize((long)Math.Pow(2, zoom), (long)Math.Pow(2, zoom));
      }

      public override GSize GetTileMatrixSizePixel


 * DESCRIPTION
 *         nsk/jdi/ReferenceType/visibleFields/visibfield002 test
 *         checks the visibleFields() method of ReferenceType interface
 *         of the com.sun.jdi package for not prepared class:
 *        the checked class is loaded but is not prepared.
 *        The ReferenceType.visibleFields() method is called for
 *        this class - ClassNotPreparedException should be thrown
 *        in this case.
 * COMMENTS
 * The test is updated as follows:
 * - statements for establishing ArgumentHandler, LogHandler and Binder are updated
 *   to comply with new version of the shared classes;
 * - a number of statements "out_stream.println" are replaced with
 * "print_log_on_verbose" and "print_log_anyway".
 * -------------------------------------------------------
 *  4477989 TEST_BUG: some nine ReferenceType tests use wrong assumption
 *
 * @library /vmTestbase
 *          /test/lib
 * @build nsk.jdi.ReferenceType.visibleFields.visibfield002
 *        nsk.jdi.ReferenceType.visibleFields.visibfield002a
 *
 * @comment compile loadclassXX to bin/loadclassXX
 * @run driver nsk.share.ExtraClassesBuilder
 *      loadclass
 *
 * @run driver
 *      nsk.jdi.ReferenceType.visibleFields.visibfield002
 *      -verbose
 *      -arch=${os.family}-${os.simpleArch}
 *      -waittime=5
 *      -debugee.vmkind=java
 *      -transport.address=dynamic
 *      -debugee.vmkeys="${test.vm.opts} ${test.java.opts}" ./bin
 */

/*
 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
 */
/*
 * 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 com.sun.org.apache.xalan.internal.res;

import java.util.ListResourceBundle;

/**
 * Set up error messages.
 * We build a two dimensional array of message keys and
 * message strings. In order to add a new message here,
 * you need to first add a String constant. And
 *  you need to enter key , value pair as part of contents
 * Array. You also need to update MAX_CODE for error strings
 * and MAX_WARNING for warnings ( Needed for only information
 * purpose )
 */
public class XSLTErrorResources_zh_CN extends ListResourceBundle
{

/*
 * This file contains error and warning messages related to Xalan Error
 * Handling.
 *
 *  General notes to translators:
 *
 *  1) Xalan (or more properly, Xalan-interpretive) and XSLTC are names of
 *     components.
 *     XSLT is an acronym for "XML Stylesheet Language: Transformations".
 *     XSLTC is an acronym for XSLT Compiler.
 *
 *  2) A stylesheet is a description of how to transform an input XML document
 *     into a resultant XML document (or HTML document or text).  The
 *     stylesheet itself is described in the for


file, where you stored the pickled data
    file = open('./data/confmaps_gt/train/2019_04_30_pbms002.pkl', 'rb')
    all_confmap = pickle.load(file)   # dump information to that file
    file.close()    # close the file
    # confidence map of first frame
    confmap = all_confmap[0][0][0:3]
    confmap = np.reshape(confmap, (1, 3, 1, 128, 128))

    data = np.load('template_files/train_test_data/2019_04_30/2019_04_30_pbms002/RA_NPY/0000/000000.npy')
    data_amp = data[:, :, 0] ** 2 + data[:, :, 1] ** 2

    data = np.transpose(data, (2, 0, 1))
    data = np.reshape(data, (1, 2, 1, 128, 128))

    data = torch.from_numpy(data)
    confmap = torch.from_numpy(confmap)

    # range translation 10 (move up 10 bins)
    data_shift_range, _, confmap_shift_range = transition_range(data, None, confmap, trans_range=10)
    # angle translation 25 (move right 25 degrees)
    data_shift_angle, _, confmap_shift_angle = transition_angle(data, None, confmap, trans_angle=25)
    # flip angle
    data_flip, _, confmap_flip = Flip(data, None, confmap)

    data_amp1 = data_shift_range[0, 0, 0, :, :] ** 2 + data_shift_range[0, 1, 0, :, :] ** 2
    data_amp2 = data_shift_angle[0, 0, 0, :, :] ** 2 + data_shift_angle[0, 1, 0, :, :] ** 2
    data_amp3 = data_flip[0, 0, 0, :, :] ** 2 + data_flip[0, 1, 0, :, :] ** 2

    # Create 1x3 sub plots
    gs = gridspec.GridSpec(1, 4)
    # visualize original image and augmentated images
    plt.figure(tight_layout=True)
    ax = plt.subplot(gs[0, 0])  # row 0, col 0
    plt.imshow(data_amp, vmax=0.01, origin='lower')
    ax.set_title("Original RA image")

    ax = plt.subplot(gs[0, 1])  # row 0, col 1
    plt.imshow(data_amp1, vmax=0.01, origin='lower')
    ax.set_title("Range-shift RA image")

    ax = plt.subplot(gs[0, 2])  # row 0, col 2
    plt.imshow(data_amp2, vmax=0.01, origin='lower')
    ax.set_title("Angle-shift RA image")

    ax = plt.subplot(gs[0, 3])  # row 0, col 3
    plt.imshow(data_amp3, vmax=0.01, origin='lower')
    ax.set_title("Angle-flip RA image")

    plt.show()


-color: var(--minimal_dark_blacker) !important;
	border-radius: var(--minimal_dark_corner) !important;
	box-shadow: none !important;
}

.BRmrC-jnwpXqye4oYB21C button.DialogButton {
    background-color: var(--minimal_dark_blacker) !important;
    color: var(--minimal_dark_color) !important;
}

._1FyBL6obxHQ2Z2CsaV2Gbz .DialogBody ._3ZhiKhciPyiGGxDFuGOYpc .pht3SaejGcAJEjNG8d6nd {
    background: var(--minimal_dark_blacker_alt) !important;
    border-radius: var(--minimal_dark_corner) !important;
}

._1FyBL6obxHQ2Z2CsaV2Gbz .DialogBody ._3ZhiKhciPyiGGxDFuGOYpc .pht3SaejGcAJEjNG8d6nd._2WvnwuFOagpMXn_aAuVaNJ:hover ._17z_pd5KtnIoB7X3ydiPR6 {
    opacity: 1 !important;
    stroke: var(--minimal_dark_color) !important;
    color: var(--minimal_dark_color) !important;
}

._1FyBL6obxHQ2Z2CsaV2Gbz .DialogBody ._3ZhiKhciPyiGGxDFuGOYpc .pht3SaejGcAJEjNG8d6nd:hover {
    background: var(--minimal_dark_blacker) !important;
}

._1FyBL6obxHQ2Z2CsaV2Gbz .DialogBody ._3lj3-GDYOlcoIFB3fFo1ko {
    background-color: var(--minimal_dark_blacker) !important;
    border-radius: var(--minimal_dark_corner) !important;
    border: 1px solid var(--minimal_dark_be_grey) !important;
}

._1ILFQY2sxyGFT_n-fifayy {
    background: var(--minimal_dark_blacker_alt) !important;
}

.__up-to-date-container svg path {
    fill: var(--minimal_dark_color) !important;
}

.__up-to-date-header {
    color: var(--minimal_dark_color) !important;
}

.WYgDg9NyCcMIVuMyZ_NBC._3VOR2AeYATx3qSE0I-Pm-5._6vZ6meNc3IOx5f_OdA1Ey.xp7A-08Y404Of3FBHqX32.Panel {
    width: 98px !important;
}

.SettingsDialogSubHeader {
    color: var(--minimal_dark_color) !important;
}

._28eIRmQ229ntDIyQXTn3Ub._32Lfwcdolc3ByZWItfR3ni.QE3sHW9puNTAjiRDY71Xy:active {
    background-color: var(--minimal_dark_blacker_alt) !important;
    box-shadow: inset 0px 1px 4px 1px rgb(0 0 0 / 60%) !important;
    transition: .25s ease-out !important;
}

._2bl0iQ9xigbq4Zd1NI6NZl::before {
    background: var(--minimal_dark_color) !important;
}

._2rjVTGz8aLvqOdz5v2gq5C {
    color: var(--minimal_dark_color) !important;
    text-transform: capitalize !important;
    font-size: smaller !important;
}

._2sssIwe0duyIrFvat2oXzH._3fe


func blockcopy(n, ns *gc.Node, osrc, odst, w int64) {
	var noddi gc.Node
	gc.Nodreg(&noddi, gc.Types[gc.Tptr], x86.REG_DI)
	var nodsi gc.Node
	gc.Nodreg(&nodsi, gc.Types[gc.Tptr], x86.REG_SI)

	var nodl gc.Node
	var nodr gc.Node
	if n.Ullman >= ns.Ullman {
		gc.Agenr(n, &nodr, &nodsi)
		if ns.Op == gc.ONAME {
			gc.Gvardef(ns)
		}
		gc.Agenr(ns, &nodl, &noddi)
	} else {
		if ns.Op == gc.ONAME {
			gc.Gvardef(ns)
		}
		gc.Agenr(ns, &nodl, &noddi)
		gc.Agenr(n, &nodr, &nodsi)
	}

	if nodl.Reg != x86.REG_DI {
		gmove(&nodl, &noddi)
	}
	if nodr.Reg != x86.REG_SI {
		gmove(&nodr, &nodsi)
	}
	gc.Regfree(&nodl)
	gc.Regfree(&nodr)

	c := w % 8 // bytes
	q := w / 8 // quads

	var oldcx gc.Node
	var cx gc.Node
	savex(x86.REG_CX, &cx, &oldcx, nil, gc.Types[gc.TINT64])

	// if we are copying forward on the stack and
	// the src and dst overlap, then reverse direction
	if osrc < odst && odst < osrc+w {
		// reverse direction
		gins(x86.ASTD, nil, nil) // set direction flag
		if c > 0 {
			gconreg(addptr, w-1, x86.REG_SI)
			gconreg(addptr, w-1, x86.REG_DI)

			gconreg(movptr, c, x86.REG_CX)
			gins(x86.AREP, nil, nil)   // repeat
			gins(x86.AMOVSB, nil, nil) // MOVB *(SI)-,*(DI)-
		}

		if q > 0 {
			if c > 0 {
				gconreg(addptr, -7, x86.REG_SI)
				gconreg(addptr, -7, x86.REG_DI)
			} else {
				gconreg(addptr, w-8, x86.REG_SI)
				gconreg(addptr, w-8, x86.REG_DI)
			}

			gconreg(movptr, q, x86.REG_CX)
			gins(x86.AREP, nil, nil)   // repeat
			gins(x86.AMOVSQ, nil, nil) // MOVQ *(SI)-,*(DI)-
		}

		// we leave with the flag clear
		gins(x86.ACLD, nil, nil)
	} else {
		// normal direction
		if q > 128 || (gc.Nacl && q >= 4) {
			gconreg(movptr, q, x86.REG_CX)
			gins(x86.AREP, nil, nil)   // repeat
			gins(x86.AMOVSQ, nil, nil) // MOVQ *(SI)+,*(DI)+
		} else if q >= 4 {
			p := gins(obj.ADUFFCOPY, nil, nil)
			p.To.Type = obj.TYPE_ADDR
			p.To.Sym = gc.Linksym(gc.Pkglookup("duffcopy", gc.Runtimepkg))

			// 14 and 128 = magic constants: see ../../runtime/asm_amd64.s
			p.To.Offset = 14 * (128 - q)
		} else if !gc.Nacl && c == 0 {
			// We don't need the MOVSQ side-effect of updating SI and DI,
			// and issuing a sequence of MOVQs directly is faster.
			no


 to grab the end values of a shape parameter. */
internal fun CornerBasedShape.end(): CornerBasedShape {
  return copy(topStart = CornerSize(0.0.dp), bottomStart = CornerSize(0.0.dp))
}

/**
 * Helper function for component shape tokens. Here is an example on how to use component color
 * tokens:
 * ``MaterialTheme.shapes.fromToken(FabPrimarySmallTokens.ContainerShape)``
 */
internal fun Shapes.fromToken(value: ShapeKeyTokens): Shape {
  return when (value) {
    ShapeKeyTokens.CornerExtraLarge -> extraLarge
    ShapeKeyTokens.CornerExtraLargeTop -> extraLarge.top()
    ShapeKeyTokens.CornerExtraSmall -> extraSmall
    ShapeKeyTokens.CornerExtraSmallTop -> extraSmall.top()
    ShapeKeyTokens.CornerFull -> CircleShape
    ShapeKeyTokens.CornerLarge -> large
    ShapeKeyTokens.CornerLargeEnd -> large.end()
    ShapeKeyTokens.CornerLargeTop -> large.top()
    ShapeKeyTokens.CornerMedium -> medium
    ShapeKeyTokens.CornerNone -> RectangleShape
    ShapeKeyTokens.CornerSmall -> small
  }
}

/** Converts a shape token key to the local shape provided by the theme */
@Composable
@ReadOnlyComposable
fun ShapeKeyTokens.toShape(): Shape {
  return MaterialTheme.shapes.fromToken(this)
}

/** CompositionLocal used to specify the default shapes for the surfaces. */
internal val LocalShapes = staticCompositionLocalOf { Shapes() }
/*
 * Copyright 2023 teogor (Teodor Grigor)
 *
 * 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
 *
 *     https://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 dev.teogor.ceres.ui.foundation

import android.content.Context
import android.media.AudioManager
import dev.teogor.ceres.core.foundation.HapticEffect
import dev.teogor.ceres.core.foundation.audioManagerUtils
import dev.teogor.ceres.core.foundation.vibratorUtils
import dev.teogor.ceres.core.startup.ApplicationContextProvider
import dev.teogor.ceres.ui.foundation.config.FeedbackConfig

fun (() -> Unit).withTouchFeedback(
  context: Context = ApplicationContextProvider.context,
  effectType: Int = AudioManager.FX_KEY_CLICK,
): () -> Unit = {
  if (!FeedbackConfig.disableAudioFeedback) {
    context.audioManagerUtils().playSoundEffect(effectType)
  }

  if (!FeedbackConfig.disableVibrationFeedback) {
    context.vibratorUtils().vibrate(
      milliseconds = FeedbackConfig.vibrationFeedbackIntensity,
      effect = HapticEffect.DEFAULT_AMPLITUDE,
    )
  }

  this()
}

fun applyTouchFeedback(
  context: Context = ApplicationContextProvider.context,
  effectType: Int = AudioManager.FX_KEY_CLICK,
) {
  if (!FeedbackConfig.disableAudioFeedback) {
    context.audioManagerUtils().playSoundEffect(effectType)
  }

  if (!FeedbackConfig.disableVibrationFeedback) {
    context.vibratorUtils().vibrate(
      milliseconds = FeedbackConfig.vibrationFeedbackIntensity,
      effect = HapticEffect.DEFAULT_AMPLITUDE,
    )
  }
}
/*
 * Copyright 2023 teogor (Teodor Grigor)
 *
 * Licensed u