text
stringlengths 1
1.05M
|
|---|
<reponame>dishbreak/aoc-common<gh_stars>0
package lib_test
import (
"testing"
"github.com/dishbreak/aoc-common/lib"
"github.com/stretchr/testify/assert"
)
func TestNeighbors(t *testing.T) {
p := lib.Point3D{}
expected := []lib.Point3D{
lib.Point3D{X: -1, Y: -1, Z: -1},
lib.Point3D{X: -1, Y: -1, Z: 0},
lib.Point3D{X: -1, Y: -1, Z: 1},
lib.Point3D{X: -1, Y: 0, Z: -1},
lib.Point3D{X: -1, Y: 0, Z: 0},
lib.Point3D{X: -1, Y: 0, Z: 1},
lib.Point3D{X: -1, Y: 1, Z: -1},
lib.Point3D{X: -1, Y: 1, Z: 0},
lib.Point3D{X: -1, Y: 1, Z: 1},
lib.Point3D{X: 0, Y: -1, Z: -1},
lib.Point3D{X: 0, Y: -1, Z: 0},
lib.Point3D{X: 0, Y: -1, Z: 1},
lib.Point3D{X: 0, Y: 0, Z: -1},
lib.Point3D{X: 0, Y: 0, Z: 1},
lib.Point3D{X: 0, Y: 1, Z: -1},
lib.Point3D{X: 0, Y: 1, Z: 0},
lib.Point3D{X: 0, Y: 1, Z: 1},
lib.Point3D{X: 1, Y: -1, Z: -1},
lib.Point3D{X: 1, Y: -1, Z: 0},
lib.Point3D{X: 1, Y: -1, Z: 1},
lib.Point3D{X: 1, Y: 0, Z: -1},
lib.Point3D{X: 1, Y: 0, Z: 0},
lib.Point3D{X: 1, Y: 0, Z: 1},
lib.Point3D{X: 1, Y: 1, Z: -1},
lib.Point3D{X: 1, Y: 1, Z: 0},
lib.Point3D{X: 1, Y: 1, Z: 1}}
assert.Equal(t, expected, p.Neighbors())
}
|
<filename>projects/prosoft-components-demo/src/app/select-demo/demos/select-with-other-load-trigger.component.ts
import { ChangeDetectionStrategy, ChangeDetectorRef, Component } from '@angular/core';
import { FormControl, FormGroup } from '@angular/forms';
import { DefaultPsSelectDataSource, PsSelectDataSource, PsSelectLoadTrigger } from '@prosoft/components/select';
import { of } from 'rxjs';
import { delay } from 'rxjs/operators';
@Component({
selector: 'app-select-with-other-load-trigger',
template: `
<h2>Custom load trigger with 1 second loading delay</h2>
<div>
<mat-radio-group [(ngModel)]="currentLoadTrigger" (change)="onTriggerChanged($event.value)">
<mat-radio-button value="initial">initial</mat-radio-button>
<mat-radio-button value="firstopen">first panel open</mat-radio-button>
<mat-radio-button value="everyopen">every panel open</mat-radio-button>
</mat-radio-group>
</div>
<span [formGroup]="form">
<mat-form-field style="display:inline-block">
<mat-label>select</mat-label>
<ps-select formControlName="select" [dataSource]="dataSource"></ps-select>
</mat-form-field>
</span>
value: {{ form.value.select | json }}<br />
current load trigger: {{ currentLoadTrigger }}<br />
load trigger count: {{ loadCount }}
<ul>
<li>Initially '??? (ID: idx)' should be selected and load trigger should be 'initial' with count 1</li>
<li>For load trigger 'first panel open' count should be 0, increase to 1 on first open. It should never go beyond 1</li>
<li>For load trigger 'every panel open' count should be 0 and increase by 1 on every open</li>
<li>When switching the load trigger, the selected value shouldn't vanish</li>
</ul>
`,
changeDetection: ChangeDetectionStrategy.OnPush,
})
export class SelectWithOtherLoadTriggerComponent {
public dataSource: PsSelectDataSource;
public currentLoadTrigger = 'initial';
public loadCount = 0;
public form = new FormGroup({
select: new FormControl('idx'),
});
constructor(private cd: ChangeDetectorRef) {
this.onTriggerChanged(this.currentLoadTrigger);
}
public onTriggerChanged(value: string) {
this.loadCount = 0;
if (value === 'initial') {
this.dataSource = this.createDataSource(PsSelectLoadTrigger.initial);
} else if (value === 'firstopen') {
this.dataSource = this.createDataSource(PsSelectLoadTrigger.firstPanelOpen);
} else {
this.dataSource = this.createDataSource(PsSelectLoadTrigger.everyPanelOpen);
}
this.cd.markForCheck();
}
private createDataSource(loadTrigger: PsSelectLoadTrigger) {
return new DefaultPsSelectDataSource<number>({
mode: 'id',
idKey: 'value',
labelKey: 'label',
items: () => {
this.loadCount++;
const rnd1 = Math.random();
const rnd2 = Math.random();
return of([
{
value: rnd1,
label: 'item ' + rnd1,
},
{
value: rnd2,
label: 'item ' + rnd2,
},
]).pipe(delay(1000));
},
loadTrigger: loadTrigger,
});
}
}
|
rm build -fr
rm dist -fr
#python3 -m nuitka --standalone --follow-imports --include-plugin-directory=/usr/local/lib/python3.7/dist-packages/telegram --include-plugin-directory=/usr/local/lib/python3.7/dist-packages/urllib3 --show-progress --show-scons main.py
#mkdir -p dist/main
#mv main.build build
#mv main.dist/* dist/main/
#rm main.dist -fr
pyinstaller main.py --noconfirm
|
#!/bin/bash
sudo ln -sf ~/kubot_ros1/tools/kubot_upstart/kubotenv /etc/kubotenv
sudo ln -sf ~/kubot_ros1/tools/kubot_upstart/kubot_start.sh /usr/bin/kubot_start
sudo ln -sf ~/kubot_ros1/tools/kubot_upstart/kubot_stop.sh /usr/bin/kubot_stop
sudo ln -sf ~/kubot_ros1/tools/kubot_upstart/kubot_restart.sh /usr/bin/kubot_restart
sudo cp ~/kubot_ros1/tools/kubot_upstart/kubot.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable kubot
sudo systemctl is-enabled kubot
# KUBOT_ROS1
|
(function(){
return {
version:1,
dependences:{
mve:1,
"front-lib":1
}
};
})()
|
<gh_stars>0
myApp.controller('PostCtrl',["$scope","$rootScope",'$location',function($scope,$rootScope,$location){
var accessToken =$rootScope.accessToken;
var response =$rootScope.response;
if (accessToken == null){
console.log('6');
window.location.href="https://angularfb-rohit.000webhostapp.com"; // redirecting
}
console.log(JSON.stringify(accessToken));
var profilePic ="https://graph.facebook.com/"+accessToken.userID+"/picture?type=square";
$scope.intro_msg ="welcome "+response.name;
$scope.Profile_img=profilePic;
//logout
$scope.FBLogout = function(){
FB.logout(function(response) {
window.location.href="https://angularfb-rohit.000webhostapp.com";
});
};
}])
|
<reponame>Fourdee/mayan-edms<filename>mayan/apps/documents/tasks.py
from __future__ import unicode_literals
import logging
from django.apps import apps
from django.contrib.auth import get_user_model
from django.db import OperationalError
from mayan.celery import app
from .literals import (
UPDATE_PAGE_COUNT_RETRY_DELAY, UPLOAD_NEW_VERSION_RETRY_DELAY
)
logger = logging.getLogger(__name__)
@app.task(ignore_result=True)
def task_clean_empty_duplicate_lists():
DuplicatedDocument = apps.get_model(
app_label='documents', model_name='DuplicatedDocument'
)
DuplicatedDocument.objects.clean_empty_duplicate_lists()
@app.task(ignore_result=True)
def task_check_delete_periods():
DocumentType = apps.get_model(
app_label='documents', model_name='DocumentType'
)
DocumentType.objects.check_delete_periods()
@app.task(ignore_result=True)
def task_check_trash_periods():
DocumentType = apps.get_model(
app_label='documents', model_name='DocumentType'
)
DocumentType.objects.check_trash_periods()
@app.task(ignore_result=True)
def task_clear_image_cache():
Document = apps.get_model(
app_label='documents', model_name='Document'
)
logger.info('Starting document cache invalidation')
Document.objects.invalidate_cache()
logger.info('Finished document cache invalidation')
@app.task(ignore_result=True)
def task_delete_document(deleted_document_id):
DeletedDocument = apps.get_model(
app_label='documents', model_name='DeletedDocument'
)
logger.debug('Executing')
deleted_document = DeletedDocument.objects.get(pk=deleted_document_id)
deleted_document.delete()
logger.debug('Finshed')
@app.task(ignore_result=True)
def task_delete_stubs():
Document = apps.get_model(
app_label='documents', model_name='Document'
)
logger.info('Executing')
Document.objects.delete_stubs()
logger.info('Finshed')
@app.task()
def task_generate_document_page_image(document_page_id, *args, **kwargs):
DocumentPage = apps.get_model(
app_label='documents', model_name='DocumentPage'
)
document_page = DocumentPage.objects.get(pk=document_page_id)
return document_page.generate_image(*args, **kwargs)
@app.task(ignore_result=True)
def task_scan_duplicates_all():
DuplicatedDocument = apps.get_model(
app_label='documents', model_name='DuplicatedDocument'
)
DuplicatedDocument.objects.scan()
@app.task(ignore_result=True)
def task_scan_duplicates_for(document_id):
Document = apps.get_model(
app_label='documents', model_name='Document'
)
DuplicatedDocument = apps.get_model(
app_label='documents', model_name='DuplicatedDocument'
)
document = Document.objects.get(pk=document_id)
DuplicatedDocument.objects.scan_for(document=document)
@app.task(bind=True, default_retry_delay=UPDATE_PAGE_COUNT_RETRY_DELAY, ignore_result=True)
def task_update_page_count(self, version_id):
DocumentVersion = apps.get_model(
app_label='documents', model_name='DocumentVersion'
)
document_version = DocumentVersion.objects.get(pk=version_id)
try:
document_version.update_page_count()
except OperationalError as exception:
logger.warning(
'Operational error during attempt to update page count for '
'document version: %s; %s. Retrying.', document_version,
exception
)
raise self.retry(exc=exception)
@app.task(bind=True, default_retry_delay=UPLOAD_NEW_VERSION_RETRY_DELAY, ignore_result=True)
def task_upload_new_version(self, document_id, shared_uploaded_file_id, user_id, comment=None):
SharedUploadedFile = apps.get_model(
app_label='common', model_name='SharedUploadedFile'
)
Document = apps.get_model(
app_label='documents', model_name='Document'
)
DocumentVersion = apps.get_model(
app_label='documents', model_name='DocumentVersion'
)
try:
document = Document.objects.get(pk=document_id)
shared_file = SharedUploadedFile.objects.get(
pk=shared_uploaded_file_id
)
if user_id:
user = get_user_model().objects.get(pk=user_id)
else:
user = None
except OperationalError as exception:
logger.warning(
'Operational error during attempt to retrieve shared data for '
'new document version for:%s; %s. Retrying.', document, exception
)
raise self.retry(exc=exception)
with shared_file.open() as file_object:
document_version = DocumentVersion(
document=document, comment=comment or '', file=file_object
)
try:
document_version.save(_user=user)
except Warning as warning:
# New document version are blocked
logger.info(
'Warning during attempt to create new document version for '
'document: %s; %s', document, warning
)
shared_file.delete()
except OperationalError as exception:
logger.warning(
'Operational error during attempt to create new document '
'version for document: %s; %s. Retrying.', document, exception
)
raise self.retry(exc=exception)
except Exception as exception:
# This except and else block emulate a finally:
logger.error(
'Unexpected error during attempt to create new document '
'version for document: %s; %s', document, exception
)
try:
shared_file.delete()
except OperationalError as exception:
logger.warning(
'Operational error during attempt to delete shared '
'file: %s; %s.', shared_file, exception
)
else:
try:
shared_file.delete()
except OperationalError as exception:
logger.warning(
'Operational error during attempt to delete shared '
'file: %s; %s.', shared_file, exception
)
|
<reponame>Nebulis/blog<filename>src/components/images/asia/malaysia/west-malaysia/langkawi-dream-hotel.tsx
import { useStaticQuery, graphql } from "gatsby"
import Img from "gatsby-image"
import React, { useEffect } from "react"
import { ExtraImageProps } from "../../../../../types/shared"
const alt = {
hotel: "Langkawi Dream Hotel Hotel",
food: "Langkawi Dream Hotel Food",
food2: "Langkawi Dream Hotel Food",
food3: "Langkawi Dream Hotel Food",
food4: "Langkawi Dream Hotel Food",
room: "Langkawi Dream Hotel Room",
room2: "Langkawi Dream Hotel Room",
room3: "Langkawi Dream Hotel Room",
room4: "Langkawi Dream Hotel Room",
room5: "Langkawi Dream Hotel Room",
room6: "Langkawi Dream Hotel Room",
spa: "Langkawi Dream Hotel Spa",
spa2: "Langkawi Dream Hotel Spa",
beach: "Langkawi Dream Hotel Beach",
beach2: "Langkawi Dream Hotel Beach",
beach3: "Langkawi Dream Hotel Beach",
beach4: "Langkawi Dream Hotel Beach",
beach5: "Langkawi Dream Hotel Beach",
beach6: "Langkawi Dream Hotel Beach",
beach7: "Langkawi Dream Hotel Beach",
beach8: "Langkawi Dream Hotel Beach",
beach9: "Langkawi Dream Hotel Beach",
island: "Langkawi Dream Hotel Island",
island2: "Langkawi Dream Hotel Island",
island3: "Langkawi Dream Hotel Island",
island4: "Langkawi Dream Hotel Island",
island5: "Langkawi Dream Hotel Island",
island6: "Langkawi Dream Hotel Island",
island7: "Langkawi Dream Hotel Island",
panorama: "Langkawi Dream Hotel Panorama",
cardFr1: "Langkawi Dream Hotel Pinterest card",
cardFr2: "Langkawi Dream Hotel Pinterest card",
cardEn1: "Langkawi Dream Hotel Pinterest card",
cardEn2: "Langkawi Dream Hotel Pinterest card",
}
export const LangkawiDreamHotelImages: React.FunctionComponent<ExtraImageProps & { image: keyof typeof alt }> = ({
className = "",
image,
fluidObject = {},
imgStyle = {},
onLoad,
}) => {
const data = useStaticQuery(graphql`
query {
hotel: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-hotel.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
food: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-food.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
food2: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-food2.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
food3: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-food3.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
food4: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-food4.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
room: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-room.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
room2: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-room2.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
room3: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-room3.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
room4: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-room4.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
room5: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-room5.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
room6: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-room6.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
spa: file(relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-spa.jpg" }) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
spa2: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-spa2.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
beach: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-beach.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
beach2: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-beach2.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
beach3: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-beach3.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
beach4: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-beach4.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
beach5: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-beach5.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
beach6: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-beach6.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
beach7: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-beach7.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
beach8: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-beach8.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
beach9: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-beach9.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
island: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-island.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
island2: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-island2.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
island3: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-island3.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
island4: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-island4.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
island5: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-island5.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
island6: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-island6.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
island7: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-island7.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 60, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
panorama: file(
relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/langkawi-dream-hotel-panorama.jpg" }
) {
childImageSharp {
fluid(maxWidth: 1200, quality: 80, srcSetBreakpoints: [600]) {
...GatsbyImageSharpFluid
}
}
}
cardFr1: file(relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/card-fr1.jpg" }) {
childImageSharp {
fluid(maxWidth: 1000, quality: 60, srcSetBreakpoints: [1000]) {
...GatsbyImageSharpFluid
}
}
}
cardFr2: file(relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/card-fr2.jpg" }) {
childImageSharp {
fluid(maxWidth: 1000, quality: 60, srcSetBreakpoints: [1000]) {
...GatsbyImageSharpFluid
}
}
}
cardEn1: file(relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/card-en1.jpg" }) {
childImageSharp {
fluid(maxWidth: 1000, quality: 60, srcSetBreakpoints: [1000]) {
...GatsbyImageSharpFluid
}
}
}
cardEn2: file(relativePath: { eq: "asia/malaysia/west-malaysia/langkawi-dream-hotel/card-en2.jpg" }) {
childImageSharp {
fluid(maxWidth: 1000, quality: 60, srcSetBreakpoints: [1000]) {
...GatsbyImageSharpFluid
}
}
}
}
`)
useEffect(() => {
if (onLoad) onLoad(data[image].childImageSharp.fluid.src)
}, [data, image, onLoad])
return (
<Img
fluid={{ ...data[image].childImageSharp.fluid, ...fluidObject }}
alt={alt[image]}
className={className}
imgStyle={imgStyle}
/>
)
}
|
<reponame>dvinubius/meta-multisig
export * from '../../ant';
|
<gh_stars>10-100
/**
* @author ooooo
* @date 2021/4/11 16:46
*/
#ifndef CPP_1686__SOLUTION1_H_
#define CPP_1686__SOLUTION1_H_
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
int stoneGameVI(vector<int> &aliceValues, vector<int> &bobValues) {
int n = aliceValues.size();
vector<int> nums(n);
for (int i = 0; i < n; i++) {
nums[i] = i;
}
sort(nums.begin(), nums.end(), [&](const int x, const int y) {
return aliceValues[x] + bobValues[x] > aliceValues[y] + bobValues[y];
});
int a = 0;
for (int i = 0; i < n; i += 2) {
a += aliceValues[nums[i]];
}
int b = 0;
for (int i = 1; i < n; i += 2) {
b += bobValues[nums[i]];
}
if (a > b) return 1;
if (a == b) return 0;
return -1;
}
};
#endif //CPP_1686__SOLUTION1_H_
|
#!/bin/bash
# Restart my_service when it crashes
while true
do
# Start the service
service my_service start
# Check the status of the service
if [ "$(service my_service status)" = "running" ]
then
# sleep for 5 minutes
sleep 300
else
# Restart the service
service my_service restart
fi
done
|
import json
tweets = [
{
'user': 'John',
'tweet': 'This is a tweet in English',
'language': 'en'
},
{
'user': 'Jane',
'tweet': 'Ceci est un tweet en français',
'language': 'fr'
},
{
'user': 'Bob',
'tweet': 'Esta es una publicación en español',
'language': 'es'
}
]
language = 'en'
filtered = [tweet for tweet in tweets if tweet['language'] == language]
print(json.dumps(filtered, indent=2))
|
#!/bin/bash
# version: 0.4.14.19
# This script performs a fresh install of the turret's Linux software.
# The turret software has only been tested on a Raspberry Pi 3B+ running
# Raspbian 9 Stretch, but it should work with other Debian based systems.
# See https://github.com/iboatwright/terror-turret/pi/README.md for more details.
starttime=$(date +%s)
DEFAULT_PROJECT_NAME="terror-turret"
DEFAULT_PASSWORD="Z"
OS_VERSION=${cat /etc/os-release | grep 'VERSION=' | awk -F'[(|)]' '{print $2}'}
BASE_PACKAGES="git python-pip"
UV4L_PACKAGES="uv4l uv4l-decoder uv4l-encoder uv4l-renderer "\
"uv4l-mjpegstream uv4l-server uv4l-webrtc"\
"uv4l-demos uv4l-uvc"
quiet=false
prompts=true
# if -q is passed as an argument, then perform a quiet install. No prompts,
# no prints. Output is redirected to /tmp/turret_install.log
[[ ! -z $1 ]] && [[ $1 -eq "-q" ]] && quiet=true && prompts=false
[[ $quiet ]] && exec &> /tmp/turret_install.log
# if -d is passed as an argument, then use default settings. No prompts.
[[ ! -z $1 ]] && [[ $1 -eq "-d" ]] && prompts="False"
# Colors that can be used in the output
OUTPUT_RED='\033[0;31m'
OUTPUT_GREEN='\033[0;32m'
OUTPUT_NO_COLOR='\033[039m'
# Prints the provided string red to indicate an error
error() {
printf "${OUTPUT_RED}"
printf "$@\n"
printf "${OUTPUT_NO_COLOR}"
}
# Just like error(), but exits with exit code 1
exiterror() {
error "$@"
endtime=$(date +%s)
runtime=$((endtime - starttime))
runtime_minutes=$((runtime/60))
error "FAILED after ${runtime} seconds (${runtime_minutes} minutes)."
exit 1
}
# Called when the script finished successfully - prints a message in green
success() {
printf "${OUTPUT_GREEN}"
printf "Setup completed successfully; cya!\n"
endtime=$(date +%s)
runtime=$((endtime - starttime))
runtime_minutes=$((runtime/60))
printf "SUCCESS after ${runtime} seconds (${runtime_minutes} minutes)."
printf "${OUTPUT_NO_COLOR}"
printf "\n Rebooting the Pi to make sure everything works as expected..."
printf "You have 5 seconds to cancel with Ctrl + C."
sleep 5
sudo reboot
exit 0
}
set_project_name() {
# NOTE: there is no validation or error checking, this could break things
echo -e "Please enter a project name or press Enter for default."
read -p "($DEFAULT_PROJECT_NAME) : " project_name
[[ -z "$project_name" ]] && project_name="$DEFAULT_PROJECT_NAME"
}
set_turret_password() {
# NOTE: there is no validation or error checking, this could break things
echo -e "Please enter a password for the android app or press Enter for default."
echo -n "($DEFAULT_PASSWORD) : "
read turret_password
[[ -z "$turret_password" ]] && turret_password="$DEFAULT_PASSWORD"
}
printf "\nNow setting up RPi 3B+ for use with Terror-Turret...\n\n"
sleep 1s
echo "Installing system updates..."
sudo apt update && sudo apt upgrade -y || exiterror "apt failed to update and upgrade."
echo "Installing git and pip if needed..."
sudo apt install $BASE_PACKAGES -y || exiterror "apt failed to install $BASE_PACKAGES."
echo "Installing needed Python packages..."
sudo pip3 install pyserial || exiterror "Unable to install pyserial!"
sudo pip3 install colorama || exiterror "Unable to install colorama!"
sudo pip3 install simplewebsocketserver || exiterror "Unable to install simplewebsocketserver!"
echo -e "\nInstalling UV4L..."
curl http://www.linux-projects.org/listing/uv4l_repo/lpkey.asc | apt-key add -
echo "deb http://www.linux-projects.org/listing/uv4l_repo/raspbian/stretch stretch main" | tee -a /etc/apt/sources.list
sudo apt install $UV4L_PACKAGES -y || exiterror
echo -e "Finished installing all needed packages.\n"
# ask user if they want to use a different project name
set_project_name
# ask user for a password for the turret manager
set_turret_password
# helper vars
TMP_DIR="/tmp/code/$DEFAULT_PROJECT_NAME/"
INSTALL_DIR="/usr/share/$project_name/"
DOC_DIR="/usr/share/doc/$project_name/"
CONFIG_DIR="/etc/$project_name"
echo -e "\n Cloning project code from github..."
mkdir /tmp/code || exiterror
git clone https://www.github.com/maillouxc/terror-turret.git $TMP_DIR || exiterror
# create needed project directories
sudo mkdir $INSTALL_DIR
sudo mkdir $DOC_DIR
sudo mkdir $CONFIG_DIR
# update project files with custom variables
sed -i 's/terror-turret/$project_name/g' $TMP_DIR/pi/turret.service
sed -i 's/terror-turret/$project_name/g' $TMP_DIR/pi/turret-manager.py
sed -i 's/terror-turret/$project_name/g' $TMP_DIR/pi/turret
sed -E -i 's/(password\x27\s*:\s*")(\w*)/\1${password}/g' $TMP_DIR/pi/turretManagerConfig.conf
# install turret documents
cp $TMP_DIR/LICENSE $DOC_DIR/LICENSE
cp $TMP_DIR/README.md $DOC_DIR/$project_name-about.md
cp $TMP_DIR/pi/README.md $DOC_DIR/$project_name-tls.md
# install control scripts
cp $TMP_DIR/pi/turret-manager.py $INSTALL_DIR/turret-manager.py
cp $TMP_DIR/pi/turretManagerConfig.py $INSTALL_DIR/turretManagerConfig.py
cp $TMP_DIR/pi/turret $INSTALL_DIR/turret
cp $TMP_DIR/pi/uv4l-config.conf $INSTALL_DIR/uv4l-config.conf
sudo cp $TMP_DIR/pi/turret.service /etc/systemd/system/turret.service
sudo mv /etc/uv4l/uv4l-uvc.conf /etc/uv4l/uv4l-uvc.conf.bak
cp $TMP_DIR/pi/shotgun_racking.wav $INSTALL_DIR/shotgun_racking.wav
# update needed permissions
chmod +x $INSTALL_DIR/turret
sudo chmod 644 /etc/systemd/system/$project_name.service
# symlink config files
sudo ln -s $INSTALL_DIR/turretManagerConfig.py $CONFIG_DIR/turretManagerConfig.py
sudo ln -s $INSTALL_DIR/turret /usr/local/bin/turret
sudo ln -s $INSTALL_DIR/uv4l-config.conf /etc/uv4l/uv4l-uvc.conf
sudo ln -s $INSTALL_DIR/shotgun_racking.wav $INSTALL_DIR/turret_ready.wav
# start the turret service
sudo systemctrl daemon-reload
sudo systemctrl enable turret.service
sudo systemctrl start turret.service
success
|
import { Title } from '@angular/platform-browser';
import { OverlayContainer } from '@angular/cdk/overlay';
import { Component, HostBinding, OnDestroy, OnInit } from '@angular/core';
import { ActivationEnd, Router } from '@angular/router';
import {MatSnackBar} from '@angular/material';
import { NIGHT_MODE_THEME, selectorSettings } from './settings';
@Component({
selector: 'barra',
templateUrl: './barra.component.html',
styleUrls: ['./barra.component.css'],
})
export class BarraComponent implements OnInit{
constructor(
public snackBar: MatSnackBar
) {}
ngOnInit(){}
openSnackBar() {
this.snackBar.openFromComponent(BarraComponent, {duration: 500,
});
this.snackBar.open('CURIOSO PRA CARALHO');
}
}
|
<filename>dist/ts/enums/error_type.d.ts
export declare enum ERROR_TYPE {
InvalidControllerName = "invalid_controller_name",
InvalidContentType = "invalid_content_type",
PortInUse = "port_in_use",
UndefinedViewEngine = "undefined_view_engine"
}
|
<filename>src/main/java/frc/robot/subsystems/DriveSubsystem.java
package frc.robot.subsystems;
import static frc.robot.RobotConstants.COUNTS_PER_REVOLUTION;
import static frc.robot.RobotConstants.WHEEL_DIAMETER_INCH;
import edu.wpi.first.wpilibj.Encoder;
import edu.wpi.first.wpilibj.Spark;
import edu.wpi.first.wpilibj.drive.DifferentialDrive;
import edu.wpi.first.wpilibj2.command.SubsystemBase;
public class DriveSubsystem extends SubsystemBase {
private final Spark leftMotor = new Spark(0);
private final Spark rightMotor = new Spark(1);
private final Encoder leftEncoder = new Encoder(4, 5);
private final Encoder rightEncoder = new Encoder(6, 7);
private final DifferentialDrive diffDrive = new DifferentialDrive(leftMotor, rightMotor);
public DriveSubsystem() {
leftEncoder.setDistancePerPulse((Math.PI * WHEEL_DIAMETER_INCH) / COUNTS_PER_REVOLUTION);
rightEncoder.setDistancePerPulse((Math.PI * WHEEL_DIAMETER_INCH) / COUNTS_PER_REVOLUTION);
resetEncoders();
}
public void arcadeDrive(double xSpeed, double zRotation) {
diffDrive.arcadeDrive(xSpeed, zRotation);
}
public void tankDrive(double leftSpeed, double rightSpeed) {
diffDrive.tankDrive(leftSpeed, rightSpeed);
}
public void resetEncoders() {
leftEncoder.reset();
rightEncoder.reset();
}
public double getLeftDistance() {
return leftEncoder.getDistance();
}
public double getRightDistance() {
return rightEncoder.getDistance();
}
public double getAverageDistance() {
return (getLeftDistance() + getRightDistance()) / 2.0;
}
}
|
#!/bin/bash
printf "\nWill run the docker.\n"
sudo docker run -d -p 7000:7000 localhost:5000/javalin:1.0.0-SNAPSHOT
printf "\nDONE\n"
|
<gh_stars>0
/**
* @license
* Copyright 2017 The FOAM Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
foam.CLASS({
package: 'foam.box',
name: 'NamedBox',
extends: 'foam.box.ProxyBox',
requires: [
'foam.box.LookupBox',
],
axioms: [
foam.pattern.Multiton.create({ property: 'name' })
],
properties: [
{
class: 'String',
name: 'name'
},
{
name: 'delegate',
transient: true,
factory: function() {
// RetryBox(LookupBox(name, NamedBox(subName)))
// TODO Add retry box
return this.LookupBox.create({
name: this.getBaseName(),
parentBox: this.getParentBox()
});
},
swiftFactory: function() {/*
return self.LookupBox_create([
"name": self.getBaseName(),
"parentBox": self.getParentBox()
])
*/}
}
],
methods: [
{
name: 'getParentBox',
returns: 'foam.box.Box',
code: function() {
return this.cls_.create({
name: this.name.substring(0, this.name.lastIndexOf('/'))
}, this);
},
swiftCode: function() {/*
var name = ""
if let index = self.name.range(of: "/", options: .backwards)?.lowerBound {
name = String(self.name[..<index])
}
return ownClassInfo().create(args: [
"name": name
], x: __subContext__) as! Box
*/},
},
{
name: 'getBaseName',
returns: 'String',
code: function getBaseName() {
return this.name.substring(this.name.lastIndexOf('/') + 1);
},
swiftCode: function getBaseName() {/*
if let index = name.range(of: "/", options: .backwards)?.lowerBound {
return String(name[name.index(after: index)..<name.endIndex])
}
return ""
*/},
},
]
});
|
echo "launching testrpc with deterministic addresses and preset accounts with balances (for unit tests)"
n 8.9.1
testrpc \
--gasLimit 0x47D5DE \
--network-id 999 \
-m "hello build tongue rack parade express shine salute glare rate spice stock" \
--account="0x133be114715e5fe528a1b8adf36792160601a2d63ab59d1fd454275b31328791,20000000000000000000000" \
--account="0xd252a0a6fc3c546606e3060a43143003a4b1f46a7bacf39376d89a6370d1ecdc,20000000000000000000000" \
--account="0x2ac035f3127e3826c5efa74fe23358ce5a004239ec773aa6a22b8600a1e31da8,20000000000000000000000" \
--account="0x9b8dac9393c4c1a4beeea52de3bda166c54da6de9cbb081270bc4c67d9084e24,20000000000000000000000" \
--account="0x89f45e9b485cbc5d1b6b5360644e13b99a9cb4c9f43e37f9c5d284448a316406,20000000000000000000000" \
--account="0x1d189fb58083e2b9a4f548a3d1a223aea76b794c8cf0db036bbdfa69524aef6c,20000000000000000000000" \
--account="0xcdc7576cb67bde700ca3159cd263492cc128cbac9d138bbca6b14a59d4c413aa,20000000000000000000000" \
--account="0x9f64ed9f836c461b00edec44c444815c08c043c0392cd2760ea85a523ff79370,20000000000000000000000" \
--account="0x87ef4ac3c3a25c97b68ca9131f58a0311acbf0ce832add26473116d309b21374,20000000000000000000000" \
--account="0x8e03212d28a96275789e9e2d16b0696752a6270f56c424b75510ad8e86b8e4ec,20000000000000000000000" \
--account="0x0648111a21cc6c380cfcb71ab0a7c221608637b180714fbe7bed0101c5973401,20000000000000000000000" \
--account="0x3648eb69d657c7e7000b6aa143442c6ecfeb72dad08f9462e4ce688c60958644,20000000000000000000000" \
--account="0xd50ac4abc9ddd62dd290077e6dd1240785db1f56b4a029ce0fd0d82d59086870,20000000000000000000000" \
--account="0xc260917de5604d98bbe8900673f2bfe86bab495443bcda330207b4e9cebb0470,20000000000000000000000" \
--account="0x9484aa6d2ed11cf29756635f3ca63e449adc1dcd008f269a04050094cbce9853,20000000000000000000000" \
--account="0xf3b1ce3a00d2ebf853d53a4d1a526d6f97270438a83a8f32e9d3b3489ff1b470,20000000000000000000000" \
--account="0xb33c01e24e67a46b48de8c4541fbbd7e3f09744f7c87b9f73e9dd9b4bfe006c4,20000000000000000000000" \
--account="0x83acf381fe3b31423ad57ae4c5f07e8b958e7307a0e5c507566e837fcdc6a33c,20000000000000000000000" \
--account="0xc7ba7978f55ff8237ac556af593645c076c05cfbbdc8aa04a426235ddd9477dd,20000000000000000000000" \
--account="0xb166b62cf42debd7f621aa01168cfa1b098365983b09d020fab64185bcd29d02,20000000000000000000000" \
--account="0x5a0c7ebc7839bcee1796bcf34e2a00bc863cff6c5a758a5416a239646eae3554,20000000000000000000000" \
--account="0x9255f719a1281e8540d34246f05f94d450927b468216221fc61e156eb5f81c98,20000000000000000000000"
|
export interface Dictionary {
[key: string]: Dictionary | any
}
|
import tornado.ioloop
class TimerManager:
def __init__(self):
self.timers = []
def init_timers(self, callback_func, interval_ms):
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_callback(callback_func) # Call the function immediately
res = tornado.ioloop.PeriodicCallback(callback_func, interval_ms)
res.start()
self.timers.append(res) # Store the timer for future reference
def sample_callback():
print("Sample callback function called")
# Usage
if __name__ == "__main__":
timer_manager = TimerManager()
timer_manager.init_timers(sample_callback, 5000) # Call sample_callback every 5 seconds
tornado.ioloop.IOLoop.current().start()
|
def remove_repeated_chars(string):
seen = set()
result = ""
for char in string:
if char not in seen:
seen.add(char)
result += char
return result
result = remove_repeated_chars("aaabbcc")
print(result)
|
#include <iostream>
void towerOfHanoi(int n, char from_rod,
char to_rod, char aux_rod)
{
if (n == 1)
{
std::cout << "Move disk 1 from rod " << from_rod <<
" to rod " << to_rod<<std::endl;
return;
}
towerOfHanoi(n-1, from_rod, aux_rod, to_rod);
std::cout << "Move disk " << n << " from rod " << from_rod <<
" to rod " << to_rod << std::endl;
towerOfHanoi(n-1, aux_rod, to_rod, from_rod);
}
int main()
{
int n = 3; // Number of disks
towerOfHanoi(n, 'A', 'C', 'B'); // A, B and C are names of rods
return 0;
}
|
#!/bin/sh
set -e
set -u
set -o pipefail
function on_error {
echo "$(realpath -mq "${0}"):$1: error: Unexpected failure"
}
trap 'on_error $LINENO' ERR
if [ -z ${FRAMEWORKS_FOLDER_PATH+x} ]; then
# If FRAMEWORKS_FOLDER_PATH is not set, then there's nowhere for us to copy
# frameworks to, so exit 0 (signalling the script phase was successful).
exit 0
fi
echo "mkdir -p ${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
mkdir -p "${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
COCOAPODS_PARALLEL_CODE_SIGN="${COCOAPODS_PARALLEL_CODE_SIGN:-false}"
SWIFT_STDLIB_PATH="${DT_TOOLCHAIN_DIR}/usr/lib/swift/${PLATFORM_NAME}"
# Used as a return value for each invocation of `strip_invalid_archs` function.
STRIP_BINARY_RETVAL=0
# This protects against multiple targets copying the same framework dependency at the same time. The solution
# was originally proposed here: https://lists.samba.org/archive/rsync/2008-February/020158.html
RSYNC_PROTECT_TMP_FILES=(--filter "P .*.??????")
# Copies and strips a vendored framework
install_framework()
{
if [ -r "${BUILT_PRODUCTS_DIR}/$1" ]; then
local source="${BUILT_PRODUCTS_DIR}/$1"
elif [ -r "${BUILT_PRODUCTS_DIR}/$(basename "$1")" ]; then
local source="${BUILT_PRODUCTS_DIR}/$(basename "$1")"
elif [ -r "$1" ]; then
local source="$1"
fi
local destination="${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
if [ -L "${source}" ]; then
echo "Symlinked..."
source="$(readlink "${source}")"
fi
# Use filter instead of exclude so missing patterns don't throw errors.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${source}\" \"${destination}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${destination}"
local basename
basename="$(basename -s .framework "$1")"
binary="${destination}/${basename}.framework/${basename}"
if ! [ -r "$binary" ]; then
binary="${destination}/${basename}"
elif [ -L "${binary}" ]; then
echo "Destination binary is symlinked..."
dirname="$(dirname "${binary}")"
binary="${dirname}/$(readlink "${binary}")"
fi
# Strip invalid architectures so "fat" simulator / device frameworks work on device
if [[ "$(file "$binary")" == *"dynamically linked shared library"* ]]; then
strip_invalid_archs "$binary"
fi
# Resign the code if required by the build settings to avoid unstable apps
code_sign_if_enabled "${destination}/$(basename "$1")"
# Embed linked Swift runtime libraries. No longer necessary as of Xcode 7.
if [ "${XCODE_VERSION_MAJOR}" -lt 7 ]; then
local swift_runtime_libs
swift_runtime_libs=$(xcrun otool -LX "$binary" | grep --color=never @rpath/libswift | sed -E s/@rpath\\/\(.+dylib\).*/\\1/g | uniq -u)
for lib in $swift_runtime_libs; do
echo "rsync -auv \"${SWIFT_STDLIB_PATH}/${lib}\" \"${destination}\""
rsync -auv "${SWIFT_STDLIB_PATH}/${lib}" "${destination}"
code_sign_if_enabled "${destination}/${lib}"
done
fi
}
# Copies and strips a vendored dSYM
install_dsym() {
local source="$1"
if [ -r "$source" ]; then
# Copy the dSYM into a the targets temp dir.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${source}\" \"${DERIVED_FILES_DIR}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${DERIVED_FILES_DIR}"
local basename
basename="$(basename -s .framework.dSYM "$source")"
binary="${DERIVED_FILES_DIR}/${basename}.framework.dSYM/Contents/Resources/DWARF/${basename}"
# Strip invalid architectures so "fat" simulator / device frameworks work on device
if [[ "$(file "$binary")" == *"Mach-O "*"dSYM companion"* ]]; then
strip_invalid_archs "$binary"
fi
if [[ $STRIP_BINARY_RETVAL == 1 ]]; then
# Move the stripped file into its final destination.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${DERIVED_FILES_DIR}/${basename}.framework.dSYM\" \"${DWARF_DSYM_FOLDER_PATH}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${DERIVED_FILES_DIR}/${basename}.framework.dSYM" "${DWARF_DSYM_FOLDER_PATH}"
else
# The dSYM was not stripped at all, in this case touch a fake folder so the input/output paths from Xcode do not reexecute this script because the file is missing.
touch "${DWARF_DSYM_FOLDER_PATH}/${basename}.framework.dSYM"
fi
fi
}
# Copies the bcsymbolmap files of a vendored framework
install_bcsymbolmap() {
local bcsymbolmap_path="$1"
local destination="${BUILT_PRODUCTS_DIR}"
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${bcsymbolmap_path}" "${destination}""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${bcsymbolmap_path}" "${destination}"
}
# Signs a framework with the provided identity
code_sign_if_enabled() {
if [ -n "${EXPANDED_CODE_SIGN_IDENTITY:-}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
# Use the current code_sign_identity
echo "Code Signing $1 with Identity ${EXPANDED_CODE_SIGN_IDENTITY_NAME}"
local code_sign_cmd="/usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS:-} --preserve-metadata=identifier,entitlements '$1'"
if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
code_sign_cmd="$code_sign_cmd &"
fi
echo "$code_sign_cmd"
eval "$code_sign_cmd"
fi
}
# Strip invalid architectures
strip_invalid_archs() {
binary="$1"
# Get architectures for current target binary
binary_archs="$(lipo -info "$binary" | rev | cut -d ':' -f1 | awk '{$1=$1;print}' | rev)"
# Intersect them with the architectures we are building for
intersected_archs="$(echo ${ARCHS[@]} ${binary_archs[@]} | tr ' ' '\n' | sort | uniq -d)"
# If there are no archs supported by this binary then warn the user
if [[ -z "$intersected_archs" ]]; then
echo "warning: [CP] Vendored binary '$binary' contains architectures ($binary_archs) none of which match the current build architectures ($ARCHS)."
STRIP_BINARY_RETVAL=0
return
fi
stripped=""
for arch in $binary_archs; do
if ! [[ "${ARCHS}" == *"$arch"* ]]; then
# Strip non-valid architectures in-place
lipo -remove "$arch" -output "$binary" "$binary"
stripped="$stripped $arch"
fi
done
if [[ "$stripped" ]]; then
echo "Stripped $binary of architectures:$stripped"
fi
STRIP_BINARY_RETVAL=1
}
if [[ "$CONFIGURATION" == "Debug" ]]; then
install_framework "${BUILT_PRODUCTS_DIR}/CalendarMenu/CalendarMenu.framework"
fi
if [[ "$CONFIGURATION" == "Release" ]]; then
install_framework "${BUILT_PRODUCTS_DIR}/CalendarMenu/CalendarMenu.framework"
fi
if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
wait
fi
|
<filename>src/digits.c
#include "digits.h"
#define POINTS_LIST_MAX_LENGTH 10
#define DIGITS_LENGTH 10
static const float DIGIT_HALF_WIDTH = 0.4f; // determ. by the DIGITS points
static const float DIGIT_LINE_SPREAD_FACTOR = 0.3f;
struct points {
SDL_FPoint list[POINTS_LIST_MAX_LENGTH];
int list_length;
};
static const struct points DIGITS[DIGITS_LENGTH] = {
// 0
{{{-0.4f, 1.0f},
{0.4f, 1.0f},
{0.4f, 1.0f},
{0.4f, -1.0f},
{0.4f, -1.0f},
{-0.4f, -1.0f},
{-0.4f, 1.0f},
{-0.4f, -1.0f}},
8},
// 1
{{{0.4f, 1.0f}, {0.4f, -1.0f}}, 2},
// 2
{{{-0.4f, 1.0f},
{0.4f, 1.0f},
{0.4f, 1.0f},
{0.4f, 0.1f},
{0.4f, 0.1f},
{-0.4f, 0.1f},
{-0.4f, 0.1f},
{-0.4f, -1.0f},
{-0.4f, -1.0f},
{0.4f, -1.0f}},
10},
// 3
{{{0.4f, 1.0f},
{0.4f, -1.0f},
{-0.4f, 1.0f},
{0.4f, 1.0f},
{-0.4f, 0.1f},
{0.4f, 0.1f},
{-0.4f, -1.0f},
{0.4f, -1.0f}},
8},
// 4
{{{0.4f, 1.0f},
{0.4f, -1.0f},
{-0.4f, 1.0f},
{-0.4f, 0.1f},
{0.4f, 1.0f},
{0.4f, 0.1f},
{0.4f, 0.1f},
{-0.4f, 0.1f}},
8},
// 5
{{{-0.4f, 1.0f},
{0.4f, 1.0f},
{-0.4f, 1.0f},
{-0.4f, 0.1f},
{-0.4f, 0.1f},
{0.4f, 0.1f},
{0.4f, 0.1f},
{0.4f, -1.0f},
{-0.4f, -1.0f},
{0.4f, -1.0f}},
10},
// 6
{{{-0.4f, 1.0f},
{-0.4f, -1.0f},
{-0.4f, 0.1f},
{0.4f, 0.1f},
{0.4f, 0.1f},
{0.4f, -1.0f},
{0.4f, -1.0f},
{-0.4f, -1.0f}},
8},
// 7
{{{0.4f, 1.0f}, {0.4f, -1.0f}, {-0.4f, 1.0f}, {0.4f, 1.0f}}, 4},
// 8
{{{0.4f, 1.0f},
{0.4f, -1.0f},
{-0.4f, 1.0f},
{-0.4f, -1.0f},
{-0.4f, 1.0f},
{0.4f, 1.0f},
{-0.4f, -1.0f},
{0.4f, -1.0f},
{-0.4f, 0.1f},
{0.4f, 0.1f}},
10},
// 9
{{{0.4f, 1.0f},
{0.4f, -1.0f},
{-0.4f, 0.1f},
{0.4f, 0.1f},
{-0.4f, 0.1f},
{-0.4f, 1.0f},
{-0.4f, 1.0f},
{0.4f, 1.0f}},
8},
};
static float rendered_digit_width(int height) {
return height * ((DIGIT_LINE_SPREAD_FACTOR / 2.0f) + DIGIT_HALF_WIDTH);
}
// The top-left corner of the digit will be equal to given position.
static void render_digit(struct renderer_wrapper renderer, SDL_FPoint position,
int height, int digit) {
float scale_factor = height / 2.0f;
float line_spread = scale_factor * DIGIT_LINE_SPREAD_FACTOR;
struct points points = DIGITS[digit % DIGITS_LENGTH];
for (int i = 0; i < points.list_length; i += 2) {
SDL_FPoint p1 = points.list[i];
SDL_FPoint p2 = points.list[(i + 1) % points.list_length];
p1.x *= scale_factor;
p2.x *= scale_factor;
p1.x += position.x + (scale_factor * DIGIT_HALF_WIDTH);
p2.x += position.x + (scale_factor * DIGIT_HALF_WIDTH);
p1.y *= -scale_factor + (line_spread / 2.0f);
p2.y *= -scale_factor + (line_spread / 2.0f);
p1.y += position.y + scale_factor - (line_spread / 2.0f);
p2.y += position.y + scale_factor - (line_spread / 2.0f);
SDL_FRect rect = {
.x = p1.x,
.y = p1.y,
.w = line_spread + (p2.x - p1.x),
.h = line_spread + (p2.y - p1.y),
};
rect = renderer_wrapper_scale_frect(renderer, rect);
SDL_RenderFillRectF(renderer.renderer, &rect);
}
}
// The top-right corner of the rendered digits will be equal to given position.
void render_digits(struct renderer_wrapper renderer, SDL_FPoint position,
int height, int number) {
float width = rendered_digit_width(height);
do {
int digit = number % 10;
position.x -= width;
render_digit(renderer, position, height, digit);
position.x -= width; // gap
} while ((number /= 10) != 0);
}
|
define(["require", "exports", '../../Observable', '../../operator/mergeMapTo'], function (require, exports, Observable_1, mergeMapTo_1) {
"use strict";
Observable_1.Observable.prototype.flatMapTo = mergeMapTo_1.mergeMapTo;
Observable_1.Observable.prototype.mergeMapTo = mergeMapTo_1.mergeMapTo;
});
//# sourceMappingURL=mergeMapTo.js.map
|
import argparse
def main():
parser = argparse.ArgumentParser(description='Exporter Configuration')
parser.add_argument('--port', type=int, default=9221, help='Port on which the exporter is listening')
parser.add_argument('--address', default='', help='Address to which the exporter will bind')
args = parser.parse_args()
print(f'Port: {args.port}')
print(f'Address: {args.address}')
if __name__ == "__main__":
main()
|
#!/bin/bash
set -e
display_usage() {
echo -e "Usage: geodesicHexPatch.sh <case> <refinement>\n"
}
if [ $# -le 1 ]
then
display_usage
exit 1
fi
case=$1
refinement=$2
cd $case
gengrid_hex.$refinement
|
<reponame>lgarciaaco/cos-fleetshard
package org.bf2.cos.fleetshard.operator.support;
public class ValidationException extends Exception {
private final String type;
private final String status;
private final String reason;
private final String message;
public ValidationException(String type, String reason, String message) {
this(type, "False", reason, message);
}
public ValidationException(String type, String status, String reason, String message) {
this.type = type;
this.status = status;
this.reason = reason;
this.message = message;
}
public String getType() {
return type;
}
public String getStatus() {
return status;
}
public String getReason() {
return reason;
}
@Override
public String getMessage() {
return message;
}
}
|
<filename>src/auth/index.js<gh_stars>0
const auth = {};
export default auth;
|
import {jsx} from "@emotion/core";
import {FC} from "react";
import {useTheme} from "../services/useTheme";
import {Card} from "./Cards";
export const AnswerCard: FC<{
revealed: boolean;
halfRevealed?: boolean;
children: string;
title?: string;
onClick?: () => void;
onRemove?: () => void;
}> = ({revealed, halfRevealed = false, children, ...rest}) => {
const theme = useTheme();
return (
<Card
revealed={revealed}
halfRevealed={halfRevealed}
css={{
backgroundColor: theme.palette.themeSecondary,
}}
{...rest}>
{children}
</Card>
);
};
|
# (c) Copyright 2009 - 2010 Xilinx, Inc. All rights reserved.
#
# This file contains confidential and proprietary information
# of Xilinx, Inc. and is protected under U.S. and
# international copyright and other intellectual property
# laws.
#
# DISCLAIMER
# This disclaimer is not a license and does not grant any
# rights to the materials distributed herewith. Except as
# otherwise provided in a valid license issued to you by
# Xilinx, and to the maximum extent permitted by applicable
# law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND
# WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
# AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
# BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
# INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
# (2) Xilinx shall not be liable (whether in contract or tort,
# including negligence, or under any other theory of
# liability) for any loss or damage of any kind or nature
# related to, arising under or in connection with these
# materials, including for any direct, or any indirect,
# special, incidental, or consequential loss or damage
# (including loss of data, profits, goodwill, or any type of
# loss or damage suffered as a result of any action brought
# by a third party) even if such damage or loss was
# reasonably foreseeable or Xilinx had been advised of the
# possibility of the same.
#
# CRITICAL APPLICATIONS
# Xilinx products are not designed or intended to be fail-
# safe, or for use in any application requiring fail-safe
# performance, such as life-support or safety devices or
# systems, Class III medical devices, nuclear facilities,
# applications related to the deployment of airbags, or any
# other applications that could lead to death, personal
# injury, or severe property or environmental damage
# (individually and collectively, "Critical
# Applications"). Customer assumes the sole risk and
# liability of any use of Xilinx products in Critical
# Applications, subject only to applicable laws and
# regulations governing limitations on product liability.
#
# THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
# PART OF THIS FILE AT ALL TIMES.
#--------------------------------------------------------------------------------
#!/bin/sh
cp ../../../RAM_B_new.mif .
rm -rf simv* csrc DVEfiles AN.DB
echo "Compiling Core Verilog UNISIM/Behavioral model"
vlogan +v2k ../../../RAM_B_new.v
vhdlan ../../example_design/RAM_B_new_exdes.vhd
echo "Compiling Test Bench Files"
vhdlan ../bmg_tb_pkg.vhd
vhdlan ../random.vhd
vhdlan ../data_gen.vhd
vhdlan ../addr_gen.vhd
vhdlan ../checker.vhd
vhdlan ../bmg_stim_gen.vhd
vhdlan ../RAM_B_new_synth.vhd
vhdlan ../RAM_B_new_tb.vhd
echo "Elaborating Design"
vlogan +v2k $XILINX/verilog/src/glbl.v
vcs +vcs+lic+wait -debug RAM_B_new_tb glbl
echo "Simulating Design"
./simv -ucli -i ucli_commands.key
dve -session vcs_session.tcl
|
import React,{ useEffect, useState } from 'react'
import Card from "react-bootstrap/Card";
import Input from '../../Input/Input'
function InvoiceForm({ submitInvoice }) {
const [invoice,setInvoice] = useState({
distributorName:'',
billNumber:'',
billDate:'',
companyName:'',
discount:'',
total:''
})
const handleChange = (e) => {
setInvoice({
...invoice,
[e.target.name]: e.target.value
})
}
const style = {
width:'70%',
margin:'auto',
marginTop:'2%',
color:'black',
fontFamily:'Source Sans Pro',
fontSize:'16px',
}
useEffect(()=>{
console.log(invoice)
},[invoice])
return (
<div className='invoice-form'>
<div className='invoice-title'>
<h1>Invoice</h1>
</div>
<div className='invoice-content'>
<Input
type="text"
className="invoice-input"
placeholder='Distributor Name'
name={'distributorName'}
onChange={handleChange}
style={style}>
</Input>
<Input
type="text"
name={'billNumber'}
className="invoice-input"
placeholder='Bill Number'
onChange={handleChange}
style={style}>
</Input>
<Input
type='text'
nammes={'billDate'}
className="invoice-input"
placeholder='Bill Date'
style={style}
onChange={ (e) => {
setInvoice({
...invoice,
billDate:e.target.value
})
} }
onMouseOver={(e)=>{
e.currentTarget.type='date'
}}
onMouseOut={(e)=>{
e.currentTarget.type='text'
e.currentTarget.placeholder='Bill Date'
}}
/>
<Input
type="text"
name={'companyName'}
className="invoice-input"
placeholder='Company Name'
onChange={handleChange}
style={style}>
</Input>
<Input
type="number"
name={'discount'}
className="invoice-input"
placeholder='Discount'
onChange={handleChange}
style={style}>
</Input>
<Input
type="number"
name={'total'}
className="invoice-input"
placeholder='Total'
onChange={handleChange}
style={style}>
</Input>
</div>
</div>
)
}
export default InvoiceForm
|
<reponame>grspectre/simple_python_games
from tkinter import *
from tkinter import ttk
from collections import OrderedDict
class AppData:
__value = 0
@staticmethod
def init():
AppData.__value = 0
@staticmethod
def get_value():
value = AppData.__value
if value == 0:
AppData.__value = 1
else:
AppData.__value = 0
return value
class TkTicTacToe:
__width__ = 3
__height__ = 3
def __init__(self):
"""
Конструктор. Инициализируем TK, создаём кнопки и игровое поле.
"""
self.game_ended = False
self.root = Tk()
self.frame = ttk.Frame(self.root, padding=10)
self.frame.grid()
self.subframe_text = ttk.Frame(self.frame, padding=10)
self.subframe_text.grid(column=0, row=0)
self.subframe_field = ttk.Frame(self.frame, padding=10)
self.subframe_field.grid(column=0, row=1)
ttk.Button(self.subframe_text, text="Новая игра", command=self.init_game).grid(column=0, row=0)
ttk.Button(self.subframe_text, text="Выход", command=self.root.destroy).grid(column=1, row=0)
self.elements = []
for idx1 in range(self.__width__):
row = []
for idx2 in range(self.__height__):
pos = (idx1, idx2)
element = FieldElement(self.subframe_field, pos)
element.grid(row=idx1, column=idx2)
element.bind('<Button-1>', self.click)
row.append(element)
self.elements.append(row)
self.root.mainloop()
def init_game(self):
"""
Инициализируем новую игру.
:return:
"""
for idx1 in range(self.__width__):
for idx2 in range(self.__height__):
self.elements[idx1][idx2].init()
self.game_ended = False
AppData.init()
def end_game(self, positions):
"""
Завершаем игру, показываем выигрышную комбинацию.
:param positions: Координаты выигрышной комбинации.
:return:
"""
for idx1 in range(self.__width__):
for idx2 in range(self.__height__):
self.elements[idx1][idx2].end_game(positions)
def click(self, event):
"""
Обработчик клика на элементе поля.
:param event: MousePress
:return:
"""
if event.widget.get_value() is not None or self.game_ended:
return
value = AppData.get_value()
event.widget.set_value(value)
self.check_field(event.widget.get_position())
def check_field(self, position):
"""
Проверяем выигрышные комбинации от последней выбранной позиции.
:param position: tuple
:return:
"""
field = []
for x, element_row in enumerate(self.elements):
row = []
for y, element in enumerate(element_row):
row.append(element.get_value())
field.append(row)
positions = check_field(field, (self.__width__, self.__height__), position)
if positions is not None:
self.end_game(positions)
self.game_ended = True
class FieldElement(ttk.Label):
def __init__(self, parent, position):
"""
Конструктор. Инициализация элемента игрового поля.
:param parent: Элемент интерфейса, в котором находится.
:param position: Позиция на игровом поле.
"""
self.game_position = position
self.game_value = None
super().__init__(parent, text='-', cursor='hand2', padding=10)
def set_value(self, value):
"""
Установить значение элемента. O или 1.
:param value: int
:return:
"""
if value not in (0, 1):
raise ValueError('Value must be 0 or 1')
self.game_value = value
if self.game_value == 1:
self.configure(text='X')
if self.game_value == 0:
self.configure(text='O')
self.configure(cursor='arrow')
def get_value(self):
"""
Возвращает значение поля.
:return: int|None
"""
return self.game_value
def get_position(self):
"""
Возвращает позицию элемента на игровом поле.
:return: tuple
"""
return self.game_position
def init(self):
"""
Инициализация поля для новой игры.
:return:
"""
self.configure(cursor='hand2', foreground='black', text='-')
self.game_value = None
def end_game(self, positions):
"""
Завершение игры. Если элемент находится в выигрышной комбинации, то
выделить.
:param positions:
:return:
"""
self.configure(cursor='arrow')
if self.game_position in positions:
self.configure(foreground='green')
def check_field(field, field_dimensions, last_step, win_line_height=3):
"""
Функция нахождения выигрышной комбинации
:param field: list Игровое поле
:param field_dimensions: tuple Размер поля
:param last_step: tuple Координаты последнего хода
:param win_line_height: Сколько одинаковых элементов в выигрышной комбинации
:return: list|None
"""
multipliers = (((1, 0), (-1, 0)), ((0, 1), (0, -1)), ((1, 1), (-1, -1)), ((1, -1), (-1, 1)))
value = field[last_step[0]][last_step[1]]
last_x, last_y = last_step
output = {}
# Алгоритм простой: берём текущий сделанный ход и проверяем, нет ли
# выигрышной комбинации на поле по четырём направлениям: две прямые и
# две диагонали.
for idx in range(win_line_height):
for idx_line, coordinates in enumerate(multipliers):
for coordinate in coordinates:
x, y = coordinate
cur_x = last_x + x * idx
cur_y = last_y + y * idx
width, height = field_dimensions
if cur_x < 0 or cur_y < 0 or cur_x >= width or cur_y >= height:
continue
if idx_line not in output:
output[idx_line] = OrderedDict()
current_value = field[cur_x][cur_y]
output[idx_line][(cur_x, cur_y)] = current_value
# Сортируем по ключу, чтобы шло по порядку, и ищем первое вхождение
# выигрышной серии.
for _, items in output.items():
ordered_dict = {key: items[key] for key in sorted(items)}
wining_coordinates = []
for coordinate, dict_value in ordered_dict.items():
if dict_value is not None and dict_value == value:
wining_coordinates.append(coordinate)
else:
wining_coordinates = []
if len(wining_coordinates) == win_line_height:
return wining_coordinates
# Иначе возвращаем None
return None
def main():
TkTicTacToe()
if __name__ == '__main__':
main()
|
from itertools import product
def generate_hyperparameter_combinations(hyperparameters):
combinations = []
for model, params in hyperparameters.items():
keys = list(params.keys())
values = [params[key] for key in keys]
for combination in product(*values):
combination_dict = {'model': model}
for i in range(len(keys)):
combination_dict[keys[i]] = combination[i]
combinations.append(combination_dict)
return combinations
|
const router = require('express').Router()
const Title = require('../db/models/titles')
router.get('/', async function(req, res, next) {
try {
let titles = await Title.findAll()
res.json(titles)
} catch (err) {
next(err)
}
})
module.exports = router
|
#!/bin/bash -e
arch=armhf
if [ "$1" == "arm64" ]; then
arch=arm64
fi
rm -rf tmp-bundle-$arch || exit 1
mkdir tmp-bundle-$arch || exit 2
cd tmp-bundle-$arch
xargs -n 3 -P 8 bash -c '../unpack-plugin.sh "$0" "$1" "$2"' < ../plugin-list-$arch-buster.txt
mkdir bundle || exit 3
for dir in download_dir/*/; do
cd "$dir"
files="$(ls -I metadata.xml -I *.tar.gz)"
for file in $files; do
cp -r -p $file ../../bundle/
done
cd ../..
done
cd bundle
tar -czvf ../opencpn-plugins-bundle-$arch.tar.gz .
cd ..
cd ..
|
package pulse.input.listeners;
import pulse.input.InterpolationDataset.StandartType;
/**
* A listener associated with the {@code InterpolationDataset} static repository
* of interpolations.
*
*/
public interface ExternalDatasetListener {
/**
* Triggered when a data {@code type} has been loaded.
*
* @param type a type of the dataset, for which an interpolation is created.
*/
public void onDataLoaded(StandartType type);
}
|
#!/bin/bash
rqt_plot /self_balancer/single_pid/pitch/input /self_balancer/single_pid/pitch/output /teeterbot/right_wheel_speed
|
package uk.gov.ons.ctp.integration.contactcentresvc.event;
import static uk.gov.ons.ctp.common.log.ScopedStructuredArguments.kv;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Stream;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import uk.gov.ons.ctp.common.domain.Channel;
import uk.gov.ons.ctp.common.domain.Source;
import uk.gov.ons.ctp.common.event.EventPublishException;
import uk.gov.ons.ctp.common.event.EventPublisher;
import uk.gov.ons.ctp.common.event.TopicType;
import uk.gov.ons.ctp.integration.contactcentresvc.config.AppConfig;
import uk.gov.ons.ctp.integration.contactcentresvc.config.PublisherRetryConfig;
import uk.gov.ons.ctp.integration.contactcentresvc.model.EventToSend;
import uk.gov.ons.ctp.integration.contactcentresvc.repository.db.EventToSendRepository;
@Slf4j
@Component
public class EventToSendProcessor {
private final EventToSendRepository eventToSendRepository;
private final PublishRetrier retrier;
@Value("${scheduler.chunk-size}")
private int chunkSize;
public EventToSendProcessor(EventToSendRepository repo, PublishRetrier retrier) {
this.eventToSendRepository = repo;
this.retrier = retrier;
}
@Transactional(propagation = Propagation.REQUIRES_NEW) // Start a new transaction for every chunk
public int processChunk() {
AtomicInteger numProcessed = new AtomicInteger();
try (Stream<EventToSend> events = eventToSendRepository.findEventsToSend(chunkSize)) {
List<EventToSend> eventsSent = new ArrayList<>();
events.forEach(
event -> {
numProcessed.incrementAndGet();
try {
UUID messageId = retrier.publish(event);
eventsSent.add(event);
log.info("Event published", kv("messageId", messageId));
} catch (Exception e) {
log.error("Could not send event. Will retry indefinitely", kv("event", event), e);
}
});
eventToSendRepository.deleteAllInBatch(eventsSent);
}
return numProcessed.get();
}
/**
* We need another class for the retryable annotation, since calling a retryable annotated within
* the same class does not honour the annotations.
*/
@Slf4j
@Component
static class PublishRetrier {
private EventPublisher eventPublisher;
private PublisherRetryConfig retryConfig;
public PublishRetrier(EventPublisher eventPublisher, AppConfig appConfig) {
this.eventPublisher = eventPublisher;
this.retryConfig = appConfig.getMessaging().getRetry();
log.info("Publish-retry configuration: {}", this.retryConfig);
}
@Retryable(
label = "publishEvent",
include = EventPublishException.class,
backoff =
@Backoff(
delayExpression = "#{@appConfig.getMessaging().getRetry().getInitial()}",
multiplierExpression = "#{@appConfig.getMessaging().getRetry().getMultiplier()}",
maxDelayExpression = "#{@appConfig.getMessaging().getRetry().getMax()}"),
maxAttemptsExpression = "#{@appConfig.getMessaging().getRetry().getMaxAttempts()}",
listeners = "publishRetryListener")
public UUID publish(EventToSend event) {
TopicType type = TopicType.valueOf(event.getType());
UUID messageId =
eventPublisher.sendEvent(type, Source.CONTACT_CENTRE_API, Channel.CC, event.getPayload());
return messageId;
}
}
}
|
#ifdef ___LINKER_INFO
; File: "_utils.c", produced by Gambit v4.9.3
(
409003
(C)
"_utils"
(("_utils"))
(
"_utils"
)
(
"test"
)
(
"_utils#"
"c#append-lists"
"c#compiler-abort"
"c#compiler-internal-error"
"c#every?"
"c#gnode-depvars"
"c#gnode-find-depvars"
"c#gnode-var"
"c#gnodes-remove"
"c#keep"
"c#list->str"
"c#list->varset"
"c#list->vect"
"c#list-length"
"c#make-stretchable-vector"
"c#ptset-adjoin"
"c#ptset-empty"
"c#ptset-empty-set"
"c#remove-cycle"
"c#remove-no-depvars"
"c#reverse-append!"
"c#sort-list"
"c#stretch-vector"
"c#stretchable-vector-ref"
"c#stretchable-vector-set!"
"c#throw-to-exception-handler"
"c#varset-<"
"c#varset-difference"
"c#varset-empty"
"c#varset-equal?"
"c#varset-member?"
"c#varset-reverse-append!"
"c#varset-singleton"
"c#varset-size"
"c#varset-union"
"c#varset-union-multi"
"c#vect->list"
"c#warnings-requested?"
"last-pair"
)
(
"c#bits-and"
"c#bits-or"
"c#bits-shl"
"c#bits-shr"
"c#compiler-error"
"c#compiler-limitation-error"
"c#compiler-user-error"
"c#compiler-user-warning"
"c#for-each-index"
"c#list->ptset"
"c#list->queue"
"c#make-counter"
"c#make-gnode"
"c#make-ordered-table"
"c#map-index"
"c#n-ary"
"c#object-pos-in-list"
"c#ordered-table->list"
"c#ordered-table-enter"
"c#ordered-table-index"
"c#ordered-table-length"
"c#ordered-table-lookup"
"c#pair-up"
"c#pos-in-list"
"c#ptset->list"
"c#ptset-empty?"
"c#ptset-every?"
"c#ptset-member?"
"c#ptset-remove"
"c#ptset-size"
"c#queue->list"
"c#queue-empty"
"c#queue-empty?"
"c#queue-get!"
"c#queue-put!"
"c#read-line*"
"c#remq"
"c#str->list"
"c#stretchable-vector->list"
"c#stretchable-vector-copy"
"c#stretchable-vector-for-each"
"c#stretchable-vector-length"
"c#string-pos-in-list"
"c#topological-sort"
"c#transitive-closure"
"c#varset->list"
"c#varset-adjoin"
"c#varset-empty?"
"c#varset-intersection"
"c#varset-intersects?"
"c#varset-remove"
"c#varset-unwrap"
"c#varset-wrap"
"c#with-exception-handling"
"drop"
"take"
)
(
"##call-with-current-continuation"
"##newline0"
"##read-char1"
"+"
"apply"
"c#fatal-err"
"c#locat-show"
"display"
"equal?"
"make-string"
"make-table"
"make-vector"
"reverse"
"string=?"
"table-ref"
"table-set!"
"write"
)
()
)
#else
#define ___VERSION 409003
#define ___MODULE_NAME "_utils"
#define ___LINKER_ID ___LNK___utils
#define ___MH_PROC ___H___utils
#define ___SCRIPT_LINE 0
#define ___SYMCOUNT 1
#define ___KEYCOUNT 1
#define ___GLOCOUNT 112
#define ___SUPCOUNT 95
#define ___SUBCOUNT 20
#define ___LBLCOUNT 581
#define ___OFDCOUNT 9
#define ___MODDESCR ___REF_SUB(19)
#include "gambit.h"
___NEED_SYM(___S___utils)
___NEED_KEY(___K_test)
___NEED_GLO(___G__23__23_call_2d_with_2d_current_2d_continuation)
___NEED_GLO(___G__23__23_newline0)
___NEED_GLO(___G__23__23_read_2d_char1)
___NEED_GLO(___G__2b_)
___NEED_GLO(___G___utils_23_)
___NEED_GLO(___G_apply)
___NEED_GLO(___G_c_23_append_2d_lists)
___NEED_GLO(___G_c_23_bits_2d_and)
___NEED_GLO(___G_c_23_bits_2d_or)
___NEED_GLO(___G_c_23_bits_2d_shl)
___NEED_GLO(___G_c_23_bits_2d_shr)
___NEED_GLO(___G_c_23_compiler_2d_abort)
___NEED_GLO(___G_c_23_compiler_2d_error)
___NEED_GLO(___G_c_23_compiler_2d_internal_2d_error)
___NEED_GLO(___G_c_23_compiler_2d_limitation_2d_error)
___NEED_GLO(___G_c_23_compiler_2d_user_2d_error)
___NEED_GLO(___G_c_23_compiler_2d_user_2d_warning)
___NEED_GLO(___G_c_23_every_3f_)
___NEED_GLO(___G_c_23_fatal_2d_err)
___NEED_GLO(___G_c_23_for_2d_each_2d_index)
___NEED_GLO(___G_c_23_gnode_2d_depvars)
___NEED_GLO(___G_c_23_gnode_2d_find_2d_depvars)
___NEED_GLO(___G_c_23_gnode_2d_var)
___NEED_GLO(___G_c_23_gnodes_2d_remove)
___NEED_GLO(___G_c_23_keep)
___NEED_GLO(___G_c_23_list_2d__3e_ptset)
___NEED_GLO(___G_c_23_list_2d__3e_queue)
___NEED_GLO(___G_c_23_list_2d__3e_str)
___NEED_GLO(___G_c_23_list_2d__3e_varset)
___NEED_GLO(___G_c_23_list_2d__3e_vect)
___NEED_GLO(___G_c_23_list_2d_length)
___NEED_GLO(___G_c_23_locat_2d_show)
___NEED_GLO(___G_c_23_make_2d_counter)
___NEED_GLO(___G_c_23_make_2d_gnode)
___NEED_GLO(___G_c_23_make_2d_ordered_2d_table)
___NEED_GLO(___G_c_23_make_2d_stretchable_2d_vector)
___NEED_GLO(___G_c_23_map_2d_index)
___NEED_GLO(___G_c_23_n_2d_ary)
___NEED_GLO(___G_c_23_object_2d_pos_2d_in_2d_list)
___NEED_GLO(___G_c_23_ordered_2d_table_2d__3e_list)
___NEED_GLO(___G_c_23_ordered_2d_table_2d_enter)
___NEED_GLO(___G_c_23_ordered_2d_table_2d_index)
___NEED_GLO(___G_c_23_ordered_2d_table_2d_length)
___NEED_GLO(___G_c_23_ordered_2d_table_2d_lookup)
___NEED_GLO(___G_c_23_pair_2d_up)
___NEED_GLO(___G_c_23_pos_2d_in_2d_list)
___NEED_GLO(___G_c_23_ptset_2d__3e_list)
___NEED_GLO(___G_c_23_ptset_2d_adjoin)
___NEED_GLO(___G_c_23_ptset_2d_empty)
___NEED_GLO(___G_c_23_ptset_2d_empty_2d_set)
___NEED_GLO(___G_c_23_ptset_2d_empty_3f_)
___NEED_GLO(___G_c_23_ptset_2d_every_3f_)
___NEED_GLO(___G_c_23_ptset_2d_member_3f_)
___NEED_GLO(___G_c_23_ptset_2d_remove)
___NEED_GLO(___G_c_23_ptset_2d_size)
___NEED_GLO(___G_c_23_queue_2d__3e_list)
___NEED_GLO(___G_c_23_queue_2d_empty)
___NEED_GLO(___G_c_23_queue_2d_empty_3f_)
___NEED_GLO(___G_c_23_queue_2d_get_21_)
___NEED_GLO(___G_c_23_queue_2d_put_21_)
___NEED_GLO(___G_c_23_read_2d_line_2a_)
___NEED_GLO(___G_c_23_remove_2d_cycle)
___NEED_GLO(___G_c_23_remove_2d_no_2d_depvars)
___NEED_GLO(___G_c_23_remq)
___NEED_GLO(___G_c_23_reverse_2d_append_21_)
___NEED_GLO(___G_c_23_sort_2d_list)
___NEED_GLO(___G_c_23_str_2d__3e_list)
___NEED_GLO(___G_c_23_stretch_2d_vector)
___NEED_GLO(___G_c_23_stretchable_2d_vector_2d__3e_list)
___NEED_GLO(___G_c_23_stretchable_2d_vector_2d_copy)
___NEED_GLO(___G_c_23_stretchable_2d_vector_2d_for_2d_each)
___NEED_GLO(___G_c_23_stretchable_2d_vector_2d_length)
___NEED_GLO(___G_c_23_stretchable_2d_vector_2d_ref)
___NEED_GLO(___G_c_23_stretchable_2d_vector_2d_set_21_)
___NEED_GLO(___G_c_23_string_2d_pos_2d_in_2d_list)
___NEED_GLO(___G_c_23_throw_2d_to_2d_exception_2d_handler)
___NEED_GLO(___G_c_23_topological_2d_sort)
___NEED_GLO(___G_c_23_transitive_2d_closure)
___NEED_GLO(___G_c_23_varset_2d__3c_)
___NEED_GLO(___G_c_23_varset_2d__3e_list)
___NEED_GLO(___G_c_23_varset_2d_adjoin)
___NEED_GLO(___G_c_23_varset_2d_difference)
___NEED_GLO(___G_c_23_varset_2d_empty)
___NEED_GLO(___G_c_23_varset_2d_empty_3f_)
___NEED_GLO(___G_c_23_varset_2d_equal_3f_)
___NEED_GLO(___G_c_23_varset_2d_intersection)
___NEED_GLO(___G_c_23_varset_2d_intersects_3f_)
___NEED_GLO(___G_c_23_varset_2d_member_3f_)
___NEED_GLO(___G_c_23_varset_2d_remove)
___NEED_GLO(___G_c_23_varset_2d_reverse_2d_append_21_)
___NEED_GLO(___G_c_23_varset_2d_singleton)
___NEED_GLO(___G_c_23_varset_2d_size)
___NEED_GLO(___G_c_23_varset_2d_union)
___NEED_GLO(___G_c_23_varset_2d_union_2d_multi)
___NEED_GLO(___G_c_23_varset_2d_unwrap)
___NEED_GLO(___G_c_23_varset_2d_wrap)
___NEED_GLO(___G_c_23_vect_2d__3e_list)
___NEED_GLO(___G_c_23_warnings_2d_requested_3f_)
___NEED_GLO(___G_c_23_with_2d_exception_2d_handling)
___NEED_GLO(___G_display)
___NEED_GLO(___G_drop)
___NEED_GLO(___G_equal_3f_)
___NEED_GLO(___G_last_2d_pair)
___NEED_GLO(___G_make_2d_string)
___NEED_GLO(___G_make_2d_table)
___NEED_GLO(___G_make_2d_vector)
___NEED_GLO(___G_reverse)
___NEED_GLO(___G_string_3d__3f_)
___NEED_GLO(___G_table_2d_ref)
___NEED_GLO(___G_table_2d_set_21_)
___NEED_GLO(___G_take)
___NEED_GLO(___G_write)
___BEGIN_SYM
___DEF_SYM(0,___S___utils,"_utils")
___END_SYM
#define ___SYM___utils ___SYM(0,___S___utils)
___BEGIN_KEY
___DEF_KEY(0,___K_test,"test")
___END_KEY
#define ___KEY_test ___KEY(0,___K_test)
___BEGIN_GLO
___DEF_GLO(0,"_utils#")
___DEF_GLO(1,"c#append-lists")
___DEF_GLO(2,"c#bits-and")
___DEF_GLO(3,"c#bits-or")
___DEF_GLO(4,"c#bits-shl")
___DEF_GLO(5,"c#bits-shr")
___DEF_GLO(6,"c#compiler-abort")
___DEF_GLO(7,"c#compiler-error")
___DEF_GLO(8,"c#compiler-internal-error")
___DEF_GLO(9,"c#compiler-limitation-error")
___DEF_GLO(10,"c#compiler-user-error")
___DEF_GLO(11,"c#compiler-user-warning")
___DEF_GLO(12,"c#every?")
___DEF_GLO(13,"c#for-each-index")
___DEF_GLO(14,"c#gnode-depvars")
___DEF_GLO(15,"c#gnode-find-depvars")
___DEF_GLO(16,"c#gnode-var")
___DEF_GLO(17,"c#gnodes-remove")
___DEF_GLO(18,"c#keep")
___DEF_GLO(19,"c#list->ptset")
___DEF_GLO(20,"c#list->queue")
___DEF_GLO(21,"c#list->str")
___DEF_GLO(22,"c#list->varset")
___DEF_GLO(23,"c#list->vect")
___DEF_GLO(24,"c#list-length")
___DEF_GLO(25,"c#make-counter")
___DEF_GLO(26,"c#make-gnode")
___DEF_GLO(27,"c#make-ordered-table")
___DEF_GLO(28,"c#make-stretchable-vector")
___DEF_GLO(29,"c#map-index")
___DEF_GLO(30,"c#n-ary")
___DEF_GLO(31,"c#object-pos-in-list")
___DEF_GLO(32,"c#ordered-table->list")
___DEF_GLO(33,"c#ordered-table-enter")
___DEF_GLO(34,"c#ordered-table-index")
___DEF_GLO(35,"c#ordered-table-length")
___DEF_GLO(36,"c#ordered-table-lookup")
___DEF_GLO(37,"c#pair-up")
___DEF_GLO(38,"c#pos-in-list")
___DEF_GLO(39,"c#ptset->list")
___DEF_GLO(40,"c#ptset-adjoin")
___DEF_GLO(41,"c#ptset-empty")
___DEF_GLO(42,"c#ptset-empty-set")
___DEF_GLO(43,"c#ptset-empty?")
___DEF_GLO(44,"c#ptset-every?")
___DEF_GLO(45,"c#ptset-member?")
___DEF_GLO(46,"c#ptset-remove")
___DEF_GLO(47,"c#ptset-size")
___DEF_GLO(48,"c#queue->list")
___DEF_GLO(49,"c#queue-empty")
___DEF_GLO(50,"c#queue-empty?")
___DEF_GLO(51,"c#queue-get!")
___DEF_GLO(52,"c#queue-put!")
___DEF_GLO(53,"c#read-line*")
___DEF_GLO(54,"c#remove-cycle")
___DEF_GLO(55,"c#remove-no-depvars")
___DEF_GLO(56,"c#remq")
___DEF_GLO(57,"c#reverse-append!")
___DEF_GLO(58,"c#sort-list")
___DEF_GLO(59,"c#str->list")
___DEF_GLO(60,"c#stretch-vector")
___DEF_GLO(61,"c#stretchable-vector->list")
___DEF_GLO(62,"c#stretchable-vector-copy")
___DEF_GLO(63,"c#stretchable-vector-for-each")
___DEF_GLO(64,"c#stretchable-vector-length")
___DEF_GLO(65,"c#stretchable-vector-ref")
___DEF_GLO(66,"c#stretchable-vector-set!")
___DEF_GLO(67,"c#string-pos-in-list")
___DEF_GLO(68,"c#throw-to-exception-handler")
___DEF_GLO(69,"c#topological-sort")
___DEF_GLO(70,"c#transitive-closure")
___DEF_GLO(71,"c#varset-<")
___DEF_GLO(72,"c#varset->list")
___DEF_GLO(73,"c#varset-adjoin")
___DEF_GLO(74,"c#varset-difference")
___DEF_GLO(75,"c#varset-empty")
___DEF_GLO(76,"c#varset-empty?")
___DEF_GLO(77,"c#varset-equal?")
___DEF_GLO(78,"c#varset-intersection")
___DEF_GLO(79,"c#varset-intersects?")
___DEF_GLO(80,"c#varset-member?")
___DEF_GLO(81,"c#varset-remove")
___DEF_GLO(82,"c#varset-reverse-append!")
___DEF_GLO(83,"c#varset-singleton")
___DEF_GLO(84,"c#varset-size")
___DEF_GLO(85,"c#varset-union")
___DEF_GLO(86,"c#varset-union-multi")
___DEF_GLO(87,"c#varset-unwrap")
___DEF_GLO(88,"c#varset-wrap")
___DEF_GLO(89,"c#vect->list")
___DEF_GLO(90,"c#warnings-requested?")
___DEF_GLO(91,"c#with-exception-handling")
___DEF_GLO(92,"drop")
___DEF_GLO(93,"last-pair")
___DEF_GLO(94,"take")
___DEF_GLO(95,"##call-with-current-continuation")
___DEF_GLO(96,"##newline0")
___DEF_GLO(97,"##read-char1")
___DEF_GLO(98,"+")
___DEF_GLO(99,"apply")
___DEF_GLO(100,"c#fatal-err")
___DEF_GLO(101,"c#locat-show")
___DEF_GLO(102,"display")
___DEF_GLO(103,"equal?")
___DEF_GLO(104,"make-string")
___DEF_GLO(105,"make-table")
___DEF_GLO(106,"make-vector")
___DEF_GLO(107,"reverse")
___DEF_GLO(108,"string=?")
___DEF_GLO(109,"table-ref")
___DEF_GLO(110,"table-set!")
___DEF_GLO(111,"write")
___END_GLO
#define ___GLO___utils_23_ ___GLO(0,___G___utils_23_)
#define ___PRM___utils_23_ ___PRM(0,___G___utils_23_)
#define ___GLO_c_23_append_2d_lists ___GLO(1,___G_c_23_append_2d_lists)
#define ___PRM_c_23_append_2d_lists ___PRM(1,___G_c_23_append_2d_lists)
#define ___GLO_c_23_bits_2d_and ___GLO(2,___G_c_23_bits_2d_and)
#define ___PRM_c_23_bits_2d_and ___PRM(2,___G_c_23_bits_2d_and)
#define ___GLO_c_23_bits_2d_or ___GLO(3,___G_c_23_bits_2d_or)
#define ___PRM_c_23_bits_2d_or ___PRM(3,___G_c_23_bits_2d_or)
#define ___GLO_c_23_bits_2d_shl ___GLO(4,___G_c_23_bits_2d_shl)
#define ___PRM_c_23_bits_2d_shl ___PRM(4,___G_c_23_bits_2d_shl)
#define ___GLO_c_23_bits_2d_shr ___GLO(5,___G_c_23_bits_2d_shr)
#define ___PRM_c_23_bits_2d_shr ___PRM(5,___G_c_23_bits_2d_shr)
#define ___GLO_c_23_compiler_2d_abort ___GLO(6,___G_c_23_compiler_2d_abort)
#define ___PRM_c_23_compiler_2d_abort ___PRM(6,___G_c_23_compiler_2d_abort)
#define ___GLO_c_23_compiler_2d_error ___GLO(7,___G_c_23_compiler_2d_error)
#define ___PRM_c_23_compiler_2d_error ___PRM(7,___G_c_23_compiler_2d_error)
#define ___GLO_c_23_compiler_2d_internal_2d_error ___GLO(8,___G_c_23_compiler_2d_internal_2d_error)
#define ___PRM_c_23_compiler_2d_internal_2d_error ___PRM(8,___G_c_23_compiler_2d_internal_2d_error)
#define ___GLO_c_23_compiler_2d_limitation_2d_error ___GLO(9,___G_c_23_compiler_2d_limitation_2d_error)
#define ___PRM_c_23_compiler_2d_limitation_2d_error ___PRM(9,___G_c_23_compiler_2d_limitation_2d_error)
#define ___GLO_c_23_compiler_2d_user_2d_error ___GLO(10,___G_c_23_compiler_2d_user_2d_error)
#define ___PRM_c_23_compiler_2d_user_2d_error ___PRM(10,___G_c_23_compiler_2d_user_2d_error)
#define ___GLO_c_23_compiler_2d_user_2d_warning ___GLO(11,___G_c_23_compiler_2d_user_2d_warning)
#define ___PRM_c_23_compiler_2d_user_2d_warning ___PRM(11,___G_c_23_compiler_2d_user_2d_warning)
#define ___GLO_c_23_every_3f_ ___GLO(12,___G_c_23_every_3f_)
#define ___PRM_c_23_every_3f_ ___PRM(12,___G_c_23_every_3f_)
#define ___GLO_c_23_for_2d_each_2d_index ___GLO(13,___G_c_23_for_2d_each_2d_index)
#define ___PRM_c_23_for_2d_each_2d_index ___PRM(13,___G_c_23_for_2d_each_2d_index)
#define ___GLO_c_23_gnode_2d_depvars ___GLO(14,___G_c_23_gnode_2d_depvars)
#define ___PRM_c_23_gnode_2d_depvars ___PRM(14,___G_c_23_gnode_2d_depvars)
#define ___GLO_c_23_gnode_2d_find_2d_depvars ___GLO(15,___G_c_23_gnode_2d_find_2d_depvars)
#define ___PRM_c_23_gnode_2d_find_2d_depvars ___PRM(15,___G_c_23_gnode_2d_find_2d_depvars)
#define ___GLO_c_23_gnode_2d_var ___GLO(16,___G_c_23_gnode_2d_var)
#define ___PRM_c_23_gnode_2d_var ___PRM(16,___G_c_23_gnode_2d_var)
#define ___GLO_c_23_gnodes_2d_remove ___GLO(17,___G_c_23_gnodes_2d_remove)
#define ___PRM_c_23_gnodes_2d_remove ___PRM(17,___G_c_23_gnodes_2d_remove)
#define ___GLO_c_23_keep ___GLO(18,___G_c_23_keep)
#define ___PRM_c_23_keep ___PRM(18,___G_c_23_keep)
#define ___GLO_c_23_list_2d__3e_ptset ___GLO(19,___G_c_23_list_2d__3e_ptset)
#define ___PRM_c_23_list_2d__3e_ptset ___PRM(19,___G_c_23_list_2d__3e_ptset)
#define ___GLO_c_23_list_2d__3e_queue ___GLO(20,___G_c_23_list_2d__3e_queue)
#define ___PRM_c_23_list_2d__3e_queue ___PRM(20,___G_c_23_list_2d__3e_queue)
#define ___GLO_c_23_list_2d__3e_str ___GLO(21,___G_c_23_list_2d__3e_str)
#define ___PRM_c_23_list_2d__3e_str ___PRM(21,___G_c_23_list_2d__3e_str)
#define ___GLO_c_23_list_2d__3e_varset ___GLO(22,___G_c_23_list_2d__3e_varset)
#define ___PRM_c_23_list_2d__3e_varset ___PRM(22,___G_c_23_list_2d__3e_varset)
#define ___GLO_c_23_list_2d__3e_vect ___GLO(23,___G_c_23_list_2d__3e_vect)
#define ___PRM_c_23_list_2d__3e_vect ___PRM(23,___G_c_23_list_2d__3e_vect)
#define ___GLO_c_23_list_2d_length ___GLO(24,___G_c_23_list_2d_length)
#define ___PRM_c_23_list_2d_length ___PRM(24,___G_c_23_list_2d_length)
#define ___GLO_c_23_make_2d_counter ___GLO(25,___G_c_23_make_2d_counter)
#define ___PRM_c_23_make_2d_counter ___PRM(25,___G_c_23_make_2d_counter)
#define ___GLO_c_23_make_2d_gnode ___GLO(26,___G_c_23_make_2d_gnode)
#define ___PRM_c_23_make_2d_gnode ___PRM(26,___G_c_23_make_2d_gnode)
#define ___GLO_c_23_make_2d_ordered_2d_table ___GLO(27,___G_c_23_make_2d_ordered_2d_table)
#define ___PRM_c_23_make_2d_ordered_2d_table ___PRM(27,___G_c_23_make_2d_ordered_2d_table)
#define ___GLO_c_23_make_2d_stretchable_2d_vector ___GLO(28,___G_c_23_make_2d_stretchable_2d_vector)
#define ___PRM_c_23_make_2d_stretchable_2d_vector ___PRM(28,___G_c_23_make_2d_stretchable_2d_vector)
#define ___GLO_c_23_map_2d_index ___GLO(29,___G_c_23_map_2d_index)
#define ___PRM_c_23_map_2d_index ___PRM(29,___G_c_23_map_2d_index)
#define ___GLO_c_23_n_2d_ary ___GLO(30,___G_c_23_n_2d_ary)
#define ___PRM_c_23_n_2d_ary ___PRM(30,___G_c_23_n_2d_ary)
#define ___GLO_c_23_object_2d_pos_2d_in_2d_list ___GLO(31,___G_c_23_object_2d_pos_2d_in_2d_list)
#define ___PRM_c_23_object_2d_pos_2d_in_2d_list ___PRM(31,___G_c_23_object_2d_pos_2d_in_2d_list)
#define ___GLO_c_23_ordered_2d_table_2d__3e_list ___GLO(32,___G_c_23_ordered_2d_table_2d__3e_list)
#define ___PRM_c_23_ordered_2d_table_2d__3e_list ___PRM(32,___G_c_23_ordered_2d_table_2d__3e_list)
#define ___GLO_c_23_ordered_2d_table_2d_enter ___GLO(33,___G_c_23_ordered_2d_table_2d_enter)
#define ___PRM_c_23_ordered_2d_table_2d_enter ___PRM(33,___G_c_23_ordered_2d_table_2d_enter)
#define ___GLO_c_23_ordered_2d_table_2d_index ___GLO(34,___G_c_23_ordered_2d_table_2d_index)
#define ___PRM_c_23_ordered_2d_table_2d_index ___PRM(34,___G_c_23_ordered_2d_table_2d_index)
#define ___GLO_c_23_ordered_2d_table_2d_length ___GLO(35,___G_c_23_ordered_2d_table_2d_length)
#define ___PRM_c_23_ordered_2d_table_2d_length ___PRM(35,___G_c_23_ordered_2d_table_2d_length)
#define ___GLO_c_23_ordered_2d_table_2d_lookup ___GLO(36,___G_c_23_ordered_2d_table_2d_lookup)
#define ___PRM_c_23_ordered_2d_table_2d_lookup ___PRM(36,___G_c_23_ordered_2d_table_2d_lookup)
#define ___GLO_c_23_pair_2d_up ___GLO(37,___G_c_23_pair_2d_up)
#define ___PRM_c_23_pair_2d_up ___PRM(37,___G_c_23_pair_2d_up)
#define ___GLO_c_23_pos_2d_in_2d_list ___GLO(38,___G_c_23_pos_2d_in_2d_list)
#define ___PRM_c_23_pos_2d_in_2d_list ___PRM(38,___G_c_23_pos_2d_in_2d_list)
#define ___GLO_c_23_ptset_2d__3e_list ___GLO(39,___G_c_23_ptset_2d__3e_list)
#define ___PRM_c_23_ptset_2d__3e_list ___PRM(39,___G_c_23_ptset_2d__3e_list)
#define ___GLO_c_23_ptset_2d_adjoin ___GLO(40,___G_c_23_ptset_2d_adjoin)
#define ___PRM_c_23_ptset_2d_adjoin ___PRM(40,___G_c_23_ptset_2d_adjoin)
#define ___GLO_c_23_ptset_2d_empty ___GLO(41,___G_c_23_ptset_2d_empty)
#define ___PRM_c_23_ptset_2d_empty ___PRM(41,___G_c_23_ptset_2d_empty)
#define ___GLO_c_23_ptset_2d_empty_2d_set ___GLO(42,___G_c_23_ptset_2d_empty_2d_set)
#define ___PRM_c_23_ptset_2d_empty_2d_set ___PRM(42,___G_c_23_ptset_2d_empty_2d_set)
#define ___GLO_c_23_ptset_2d_empty_3f_ ___GLO(43,___G_c_23_ptset_2d_empty_3f_)
#define ___PRM_c_23_ptset_2d_empty_3f_ ___PRM(43,___G_c_23_ptset_2d_empty_3f_)
#define ___GLO_c_23_ptset_2d_every_3f_ ___GLO(44,___G_c_23_ptset_2d_every_3f_)
#define ___PRM_c_23_ptset_2d_every_3f_ ___PRM(44,___G_c_23_ptset_2d_every_3f_)
#define ___GLO_c_23_ptset_2d_member_3f_ ___GLO(45,___G_c_23_ptset_2d_member_3f_)
#define ___PRM_c_23_ptset_2d_member_3f_ ___PRM(45,___G_c_23_ptset_2d_member_3f_)
#define ___GLO_c_23_ptset_2d_remove ___GLO(46,___G_c_23_ptset_2d_remove)
#define ___PRM_c_23_ptset_2d_remove ___PRM(46,___G_c_23_ptset_2d_remove)
#define ___GLO_c_23_ptset_2d_size ___GLO(47,___G_c_23_ptset_2d_size)
#define ___PRM_c_23_ptset_2d_size ___PRM(47,___G_c_23_ptset_2d_size)
#define ___GLO_c_23_queue_2d__3e_list ___GLO(48,___G_c_23_queue_2d__3e_list)
#define ___PRM_c_23_queue_2d__3e_list ___PRM(48,___G_c_23_queue_2d__3e_list)
#define ___GLO_c_23_queue_2d_empty ___GLO(49,___G_c_23_queue_2d_empty)
#define ___PRM_c_23_queue_2d_empty ___PRM(49,___G_c_23_queue_2d_empty)
#define ___GLO_c_23_queue_2d_empty_3f_ ___GLO(50,___G_c_23_queue_2d_empty_3f_)
#define ___PRM_c_23_queue_2d_empty_3f_ ___PRM(50,___G_c_23_queue_2d_empty_3f_)
#define ___GLO_c_23_queue_2d_get_21_ ___GLO(51,___G_c_23_queue_2d_get_21_)
#define ___PRM_c_23_queue_2d_get_21_ ___PRM(51,___G_c_23_queue_2d_get_21_)
#define ___GLO_c_23_queue_2d_put_21_ ___GLO(52,___G_c_23_queue_2d_put_21_)
#define ___PRM_c_23_queue_2d_put_21_ ___PRM(52,___G_c_23_queue_2d_put_21_)
#define ___GLO_c_23_read_2d_line_2a_ ___GLO(53,___G_c_23_read_2d_line_2a_)
#define ___PRM_c_23_read_2d_line_2a_ ___PRM(53,___G_c_23_read_2d_line_2a_)
#define ___GLO_c_23_remove_2d_cycle ___GLO(54,___G_c_23_remove_2d_cycle)
#define ___PRM_c_23_remove_2d_cycle ___PRM(54,___G_c_23_remove_2d_cycle)
#define ___GLO_c_23_remove_2d_no_2d_depvars ___GLO(55,___G_c_23_remove_2d_no_2d_depvars)
#define ___PRM_c_23_remove_2d_no_2d_depvars ___PRM(55,___G_c_23_remove_2d_no_2d_depvars)
#define ___GLO_c_23_remq ___GLO(56,___G_c_23_remq)
#define ___PRM_c_23_remq ___PRM(56,___G_c_23_remq)
#define ___GLO_c_23_reverse_2d_append_21_ ___GLO(57,___G_c_23_reverse_2d_append_21_)
#define ___PRM_c_23_reverse_2d_append_21_ ___PRM(57,___G_c_23_reverse_2d_append_21_)
#define ___GLO_c_23_sort_2d_list ___GLO(58,___G_c_23_sort_2d_list)
#define ___PRM_c_23_sort_2d_list ___PRM(58,___G_c_23_sort_2d_list)
#define ___GLO_c_23_str_2d__3e_list ___GLO(59,___G_c_23_str_2d__3e_list)
#define ___PRM_c_23_str_2d__3e_list ___PRM(59,___G_c_23_str_2d__3e_list)
#define ___GLO_c_23_stretch_2d_vector ___GLO(60,___G_c_23_stretch_2d_vector)
#define ___PRM_c_23_stretch_2d_vector ___PRM(60,___G_c_23_stretch_2d_vector)
#define ___GLO_c_23_stretchable_2d_vector_2d__3e_list ___GLO(61,___G_c_23_stretchable_2d_vector_2d__3e_list)
#define ___PRM_c_23_stretchable_2d_vector_2d__3e_list ___PRM(61,___G_c_23_stretchable_2d_vector_2d__3e_list)
#define ___GLO_c_23_stretchable_2d_vector_2d_copy ___GLO(62,___G_c_23_stretchable_2d_vector_2d_copy)
#define ___PRM_c_23_stretchable_2d_vector_2d_copy ___PRM(62,___G_c_23_stretchable_2d_vector_2d_copy)
#define ___GLO_c_23_stretchable_2d_vector_2d_for_2d_each ___GLO(63,___G_c_23_stretchable_2d_vector_2d_for_2d_each)
#define ___PRM_c_23_stretchable_2d_vector_2d_for_2d_each ___PRM(63,___G_c_23_stretchable_2d_vector_2d_for_2d_each)
#define ___GLO_c_23_stretchable_2d_vector_2d_length ___GLO(64,___G_c_23_stretchable_2d_vector_2d_length)
#define ___PRM_c_23_stretchable_2d_vector_2d_length ___PRM(64,___G_c_23_stretchable_2d_vector_2d_length)
#define ___GLO_c_23_stretchable_2d_vector_2d_ref ___GLO(65,___G_c_23_stretchable_2d_vector_2d_ref)
#define ___PRM_c_23_stretchable_2d_vector_2d_ref ___PRM(65,___G_c_23_stretchable_2d_vector_2d_ref)
#define ___GLO_c_23_stretchable_2d_vector_2d_set_21_ ___GLO(66,___G_c_23_stretchable_2d_vector_2d_set_21_)
#define ___PRM_c_23_stretchable_2d_vector_2d_set_21_ ___PRM(66,___G_c_23_stretchable_2d_vector_2d_set_21_)
#define ___GLO_c_23_string_2d_pos_2d_in_2d_list ___GLO(67,___G_c_23_string_2d_pos_2d_in_2d_list)
#define ___PRM_c_23_string_2d_pos_2d_in_2d_list ___PRM(67,___G_c_23_string_2d_pos_2d_in_2d_list)
#define ___GLO_c_23_throw_2d_to_2d_exception_2d_handler ___GLO(68,___G_c_23_throw_2d_to_2d_exception_2d_handler)
#define ___PRM_c_23_throw_2d_to_2d_exception_2d_handler ___PRM(68,___G_c_23_throw_2d_to_2d_exception_2d_handler)
#define ___GLO_c_23_topological_2d_sort ___GLO(69,___G_c_23_topological_2d_sort)
#define ___PRM_c_23_topological_2d_sort ___PRM(69,___G_c_23_topological_2d_sort)
#define ___GLO_c_23_transitive_2d_closure ___GLO(70,___G_c_23_transitive_2d_closure)
#define ___PRM_c_23_transitive_2d_closure ___PRM(70,___G_c_23_transitive_2d_closure)
#define ___GLO_c_23_varset_2d__3c_ ___GLO(71,___G_c_23_varset_2d__3c_)
#define ___PRM_c_23_varset_2d__3c_ ___PRM(71,___G_c_23_varset_2d__3c_)
#define ___GLO_c_23_varset_2d__3e_list ___GLO(72,___G_c_23_varset_2d__3e_list)
#define ___PRM_c_23_varset_2d__3e_list ___PRM(72,___G_c_23_varset_2d__3e_list)
#define ___GLO_c_23_varset_2d_adjoin ___GLO(73,___G_c_23_varset_2d_adjoin)
#define ___PRM_c_23_varset_2d_adjoin ___PRM(73,___G_c_23_varset_2d_adjoin)
#define ___GLO_c_23_varset_2d_difference ___GLO(74,___G_c_23_varset_2d_difference)
#define ___PRM_c_23_varset_2d_difference ___PRM(74,___G_c_23_varset_2d_difference)
#define ___GLO_c_23_varset_2d_empty ___GLO(75,___G_c_23_varset_2d_empty)
#define ___PRM_c_23_varset_2d_empty ___PRM(75,___G_c_23_varset_2d_empty)
#define ___GLO_c_23_varset_2d_empty_3f_ ___GLO(76,___G_c_23_varset_2d_empty_3f_)
#define ___PRM_c_23_varset_2d_empty_3f_ ___PRM(76,___G_c_23_varset_2d_empty_3f_)
#define ___GLO_c_23_varset_2d_equal_3f_ ___GLO(77,___G_c_23_varset_2d_equal_3f_)
#define ___PRM_c_23_varset_2d_equal_3f_ ___PRM(77,___G_c_23_varset_2d_equal_3f_)
#define ___GLO_c_23_varset_2d_intersection ___GLO(78,___G_c_23_varset_2d_intersection)
#define ___PRM_c_23_varset_2d_intersection ___PRM(78,___G_c_23_varset_2d_intersection)
#define ___GLO_c_23_varset_2d_intersects_3f_ ___GLO(79,___G_c_23_varset_2d_intersects_3f_)
#define ___PRM_c_23_varset_2d_intersects_3f_ ___PRM(79,___G_c_23_varset_2d_intersects_3f_)
#define ___GLO_c_23_varset_2d_member_3f_ ___GLO(80,___G_c_23_varset_2d_member_3f_)
#define ___PRM_c_23_varset_2d_member_3f_ ___PRM(80,___G_c_23_varset_2d_member_3f_)
#define ___GLO_c_23_varset_2d_remove ___GLO(81,___G_c_23_varset_2d_remove)
#define ___PRM_c_23_varset_2d_remove ___PRM(81,___G_c_23_varset_2d_remove)
#define ___GLO_c_23_varset_2d_reverse_2d_append_21_ ___GLO(82,___G_c_23_varset_2d_reverse_2d_append_21_)
#define ___PRM_c_23_varset_2d_reverse_2d_append_21_ ___PRM(82,___G_c_23_varset_2d_reverse_2d_append_21_)
#define ___GLO_c_23_varset_2d_singleton ___GLO(83,___G_c_23_varset_2d_singleton)
#define ___PRM_c_23_varset_2d_singleton ___PRM(83,___G_c_23_varset_2d_singleton)
#define ___GLO_c_23_varset_2d_size ___GLO(84,___G_c_23_varset_2d_size)
#define ___PRM_c_23_varset_2d_size ___PRM(84,___G_c_23_varset_2d_size)
#define ___GLO_c_23_varset_2d_union ___GLO(85,___G_c_23_varset_2d_union)
#define ___PRM_c_23_varset_2d_union ___PRM(85,___G_c_23_varset_2d_union)
#define ___GLO_c_23_varset_2d_union_2d_multi ___GLO(86,___G_c_23_varset_2d_union_2d_multi)
#define ___PRM_c_23_varset_2d_union_2d_multi ___PRM(86,___G_c_23_varset_2d_union_2d_multi)
#define ___GLO_c_23_varset_2d_unwrap ___GLO(87,___G_c_23_varset_2d_unwrap)
#define ___PRM_c_23_varset_2d_unwrap ___PRM(87,___G_c_23_varset_2d_unwrap)
#define ___GLO_c_23_varset_2d_wrap ___GLO(88,___G_c_23_varset_2d_wrap)
#define ___PRM_c_23_varset_2d_wrap ___PRM(88,___G_c_23_varset_2d_wrap)
#define ___GLO_c_23_vect_2d__3e_list ___GLO(89,___G_c_23_vect_2d__3e_list)
#define ___PRM_c_23_vect_2d__3e_list ___PRM(89,___G_c_23_vect_2d__3e_list)
#define ___GLO_c_23_warnings_2d_requested_3f_ ___GLO(90,___G_c_23_warnings_2d_requested_3f_)
#define ___PRM_c_23_warnings_2d_requested_3f_ ___PRM(90,___G_c_23_warnings_2d_requested_3f_)
#define ___GLO_c_23_with_2d_exception_2d_handling ___GLO(91,___G_c_23_with_2d_exception_2d_handling)
#define ___PRM_c_23_with_2d_exception_2d_handling ___PRM(91,___G_c_23_with_2d_exception_2d_handling)
#define ___GLO_drop ___GLO(92,___G_drop)
#define ___PRM_drop ___PRM(92,___G_drop)
#define ___GLO_last_2d_pair ___GLO(93,___G_last_2d_pair)
#define ___PRM_last_2d_pair ___PRM(93,___G_last_2d_pair)
#define ___GLO_take ___GLO(94,___G_take)
#define ___PRM_take ___PRM(94,___G_take)
#define ___GLO__23__23_call_2d_with_2d_current_2d_continuation ___GLO(95,___G__23__23_call_2d_with_2d_current_2d_continuation)
#define ___PRM__23__23_call_2d_with_2d_current_2d_continuation ___PRM(95,___G__23__23_call_2d_with_2d_current_2d_continuation)
#define ___GLO__23__23_newline0 ___GLO(96,___G__23__23_newline0)
#define ___PRM__23__23_newline0 ___PRM(96,___G__23__23_newline0)
#define ___GLO__23__23_read_2d_char1 ___GLO(97,___G__23__23_read_2d_char1)
#define ___PRM__23__23_read_2d_char1 ___PRM(97,___G__23__23_read_2d_char1)
#define ___GLO__2b_ ___GLO(98,___G__2b_)
#define ___PRM__2b_ ___PRM(98,___G__2b_)
#define ___GLO_apply ___GLO(99,___G_apply)
#define ___PRM_apply ___PRM(99,___G_apply)
#define ___GLO_c_23_fatal_2d_err ___GLO(100,___G_c_23_fatal_2d_err)
#define ___PRM_c_23_fatal_2d_err ___PRM(100,___G_c_23_fatal_2d_err)
#define ___GLO_c_23_locat_2d_show ___GLO(101,___G_c_23_locat_2d_show)
#define ___PRM_c_23_locat_2d_show ___PRM(101,___G_c_23_locat_2d_show)
#define ___GLO_display ___GLO(102,___G_display)
#define ___PRM_display ___PRM(102,___G_display)
#define ___GLO_equal_3f_ ___GLO(103,___G_equal_3f_)
#define ___PRM_equal_3f_ ___PRM(103,___G_equal_3f_)
#define ___GLO_make_2d_string ___GLO(104,___G_make_2d_string)
#define ___PRM_make_2d_string ___PRM(104,___G_make_2d_string)
#define ___GLO_make_2d_table ___GLO(105,___G_make_2d_table)
#define ___PRM_make_2d_table ___PRM(105,___G_make_2d_table)
#define ___GLO_make_2d_vector ___GLO(106,___G_make_2d_vector)
#define ___PRM_make_2d_vector ___PRM(106,___G_make_2d_vector)
#define ___GLO_reverse ___GLO(107,___G_reverse)
#define ___PRM_reverse ___PRM(107,___G_reverse)
#define ___GLO_string_3d__3f_ ___GLO(108,___G_string_3d__3f_)
#define ___PRM_string_3d__3f_ ___PRM(108,___G_string_3d__3f_)
#define ___GLO_table_2d_ref ___GLO(109,___G_table_2d_ref)
#define ___PRM_table_2d_ref ___PRM(109,___G_table_2d_ref)
#define ___GLO_table_2d_set_21_ ___GLO(110,___G_table_2d_set_21_)
#define ___PRM_table_2d_set_21_ ___PRM(110,___G_table_2d_set_21_)
#define ___GLO_write ___GLO(111,___G_write)
#define ___PRM_write ___PRM(111,___G_write)
___DEF_SUB_VEC(___X0,0UL)
___VEC0
___DEF_SUB_STR(___X1,13UL)
___STR8(42,42,42,32,69,82,82,79)
___STR5(82,32,45,45,32)
___DEF_SUB_STR(___X2,1UL)
___STR1(32)
___DEF_SUB_STR(___X3,9UL)
___STR8(42,42,42,32,69,82,82,79)
___STR1(82)
___DEF_SUB_STR(___X4,4UL)
___STR4(32,73,78,32)
___DEF_SUB_STR(___X5,4UL)
___STR4(32,45,45,32)
___DEF_SUB_STR(___X6,1UL)
___STR1(32)
___DEF_SUB_STR(___X7,11UL)
___STR8(42,42,42,32,87,65,82,78)
___STR3(73,78,71)
___DEF_SUB_STR(___X8,4UL)
___STR4(32,73,78,32)
___DEF_SUB_STR(___X9,4UL)
___STR4(32,45,45,32)
___DEF_SUB_STR(___X10,1UL)
___STR1(32)
___DEF_SUB_STR(___X11,45UL)
___STR8(42,42,42,32,69,82,82,79)
___STR8(82,32,45,45,32,67,111,109)
___STR8(112,105,108,101,114,32,105,110)
___STR8(116,101,114,110,97,108,32,101)
___STR8(114,114,111,114,32,100,101,116)
___STR5(101,99,116,101,100)
___DEF_SUB_STR(___X12,17UL)
___STR8(42,42,42,32,105,110,32,112)
___STR8(114,111,99,101,100,117,114,101)
___STR1(32)
___DEF_SUB_STR(___X13,1UL)
___STR1(32)
___DEF_SUB_STR(___X14,35UL)
___STR8(42,42,42,32,69,82,82,79)
___STR8(82,32,45,45,32,67,111,109)
___STR8(112,105,108,101,114,32,108,105)
___STR8(109,105,116,32,114,101,97,99)
___STR3(104,101,100)
___DEF_SUB_STR(___X15,4UL)
___STR4(42,42,42,32)
___DEF_SUB_STR(___X16,1UL)
___STR1(32)
___DEF_SUB_STR(___X17,26UL)
___STR8(113,117,101,117,101,45,103,101)
___STR8(116,33,44,32,113,117,101,117)
___STR8(101,32,105,115,32,101,109,112)
___STR2(116,121)
___DEF_SUB_STR(___X18,50UL)
___STR8(73,110,116,101,114,110,97,108)
___STR8(32,101,114,114,111,114,44,32)
___STR8(110,111,32,101,120,99,101,112)
___STR8(116,105,111,110,32,104,97,110)
___STR8(100,108,101,114,32,97,116,32)
___STR8(116,104,105,115,32,112,111,105)
___STR2(110,116)
___DEF_SUB_VEC(___X19,5UL)
___VEC1(___REF_SYM(0,___S___utils))
___VEC1(___REF_PRC(1))
___VEC1(___REF_FIX(1))
___VEC1(___REF_NUL)
___VEC1(___REF_FAL)
___VEC0
___BEGIN_SUB
___DEF_SUB(___X0)
,___DEF_SUB(___X1)
,___DEF_SUB(___X2)
,___DEF_SUB(___X3)
,___DEF_SUB(___X4)
,___DEF_SUB(___X5)
,___DEF_SUB(___X6)
,___DEF_SUB(___X7)
,___DEF_SUB(___X8)
,___DEF_SUB(___X9)
,___DEF_SUB(___X10)
,___DEF_SUB(___X11)
,___DEF_SUB(___X12)
,___DEF_SUB(___X13)
,___DEF_SUB(___X14)
,___DEF_SUB(___X15)
,___DEF_SUB(___X16)
,___DEF_SUB(___X17)
,___DEF_SUB(___X18)
,___DEF_SUB(___X19)
___END_SUB
#undef ___MD_ALL
#define ___MD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___MR_ALL
#define ___MR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___MW_ALL
#define ___MW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_M_COD
___BEGIN_M_HLBL
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0___utils_23_)
___DEF_M_HLBL(___L1___utils_23_)
___DEF_M_HLBL(___L2___utils_23_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_append_2d_lists)
___DEF_M_HLBL(___L1_c_23_append_2d_lists)
___DEF_M_HLBL(___L2_c_23_append_2d_lists)
___DEF_M_HLBL(___L3_c_23_append_2d_lists)
___DEF_M_HLBL(___L4_c_23_append_2d_lists)
___DEF_M_HLBL(___L5_c_23_append_2d_lists)
___DEF_M_HLBL(___L6_c_23_append_2d_lists)
___DEF_M_HLBL(___L7_c_23_append_2d_lists)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_reverse_2d_append_21_)
___DEF_M_HLBL(___L1_c_23_reverse_2d_append_21_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_list_2d_length)
___DEF_M_HLBL(___L1_c_23_list_2d_length)
___DEF_M_HLBL(___L2_c_23_list_2d_length)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_make_2d_counter)
___DEF_M_HLBL(___L1_c_23_make_2d_counter)
___DEF_M_HLBL(___L2_c_23_make_2d_counter)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_for_2d_each_2d_index)
___DEF_M_HLBL(___L1_c_23_for_2d_each_2d_index)
___DEF_M_HLBL(___L2_c_23_for_2d_each_2d_index)
___DEF_M_HLBL(___L3_c_23_for_2d_each_2d_index)
___DEF_M_HLBL(___L4_c_23_for_2d_each_2d_index)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_map_2d_index)
___DEF_M_HLBL(___L1_c_23_map_2d_index)
___DEF_M_HLBL(___L2_c_23_map_2d_index)
___DEF_M_HLBL(___L3_c_23_map_2d_index)
___DEF_M_HLBL(___L4_c_23_map_2d_index)
___DEF_M_HLBL(___L5_c_23_map_2d_index)
___DEF_M_HLBL(___L6_c_23_map_2d_index)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_pos_2d_in_2d_list)
___DEF_M_HLBL(___L1_c_23_pos_2d_in_2d_list)
___DEF_M_HLBL(___L2_c_23_pos_2d_in_2d_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_object_2d_pos_2d_in_2d_list)
___DEF_M_HLBL(___L1_c_23_object_2d_pos_2d_in_2d_list)
___DEF_M_HLBL(___L2_c_23_object_2d_pos_2d_in_2d_list)
___DEF_M_HLBL(___L3_c_23_object_2d_pos_2d_in_2d_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_string_2d_pos_2d_in_2d_list)
___DEF_M_HLBL(___L1_c_23_string_2d_pos_2d_in_2d_list)
___DEF_M_HLBL(___L2_c_23_string_2d_pos_2d_in_2d_list)
___DEF_M_HLBL(___L3_c_23_string_2d_pos_2d_in_2d_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_take)
___DEF_M_HLBL(___L1_take)
___DEF_M_HLBL(___L2_take)
___DEF_M_HLBL(___L3_take)
___DEF_M_HLBL(___L4_take)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_drop)
___DEF_M_HLBL(___L1_drop)
___DEF_M_HLBL(___L2_drop)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_pair_2d_up)
___DEF_M_HLBL(___L1_c_23_pair_2d_up)
___DEF_M_HLBL(___L2_c_23_pair_2d_up)
___DEF_M_HLBL(___L3_c_23_pair_2d_up)
___DEF_M_HLBL(___L4_c_23_pair_2d_up)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_last_2d_pair)
___DEF_M_HLBL(___L1_last_2d_pair)
___DEF_M_HLBL(___L2_last_2d_pair)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_keep)
___DEF_M_HLBL(___L1_c_23_keep)
___DEF_M_HLBL(___L2_c_23_keep)
___DEF_M_HLBL(___L3_c_23_keep)
___DEF_M_HLBL(___L4_c_23_keep)
___DEF_M_HLBL(___L5_c_23_keep)
___DEF_M_HLBL(___L6_c_23_keep)
___DEF_M_HLBL(___L7_c_23_keep)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_every_3f_)
___DEF_M_HLBL(___L1_c_23_every_3f_)
___DEF_M_HLBL(___L2_c_23_every_3f_)
___DEF_M_HLBL(___L3_c_23_every_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_remq)
___DEF_M_HLBL(___L1_c_23_remq)
___DEF_M_HLBL(___L2_c_23_remq)
___DEF_M_HLBL(___L3_c_23_remq)
___DEF_M_HLBL(___L4_c_23_remq)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_sort_2d_list)
___DEF_M_HLBL(___L1_c_23_sort_2d_list)
___DEF_M_HLBL(___L2_c_23_sort_2d_list)
___DEF_M_HLBL(___L3_c_23_sort_2d_list)
___DEF_M_HLBL(___L4_c_23_sort_2d_list)
___DEF_M_HLBL(___L5_c_23_sort_2d_list)
___DEF_M_HLBL(___L6_c_23_sort_2d_list)
___DEF_M_HLBL(___L7_c_23_sort_2d_list)
___DEF_M_HLBL(___L8_c_23_sort_2d_list)
___DEF_M_HLBL(___L9_c_23_sort_2d_list)
___DEF_M_HLBL(___L10_c_23_sort_2d_list)
___DEF_M_HLBL(___L11_c_23_sort_2d_list)
___DEF_M_HLBL(___L12_c_23_sort_2d_list)
___DEF_M_HLBL(___L13_c_23_sort_2d_list)
___DEF_M_HLBL(___L14_c_23_sort_2d_list)
___DEF_M_HLBL(___L15_c_23_sort_2d_list)
___DEF_M_HLBL(___L16_c_23_sort_2d_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_list_2d__3e_vect)
___DEF_M_HLBL(___L1_c_23_list_2d__3e_vect)
___DEF_M_HLBL(___L2_c_23_list_2d__3e_vect)
___DEF_M_HLBL(___L3_c_23_list_2d__3e_vect)
___DEF_M_HLBL(___L4_c_23_list_2d__3e_vect)
___DEF_M_HLBL(___L5_c_23_list_2d__3e_vect)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_vect_2d__3e_list)
___DEF_M_HLBL(___L1_c_23_vect_2d__3e_list)
___DEF_M_HLBL(___L2_c_23_vect_2d__3e_list)
___DEF_M_HLBL(___L3_c_23_vect_2d__3e_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_list_2d__3e_str)
___DEF_M_HLBL(___L1_c_23_list_2d__3e_str)
___DEF_M_HLBL(___L2_c_23_list_2d__3e_str)
___DEF_M_HLBL(___L3_c_23_list_2d__3e_str)
___DEF_M_HLBL(___L4_c_23_list_2d__3e_str)
___DEF_M_HLBL(___L5_c_23_list_2d__3e_str)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_str_2d__3e_list)
___DEF_M_HLBL(___L1_c_23_str_2d__3e_list)
___DEF_M_HLBL(___L2_c_23_str_2d__3e_list)
___DEF_M_HLBL(___L3_c_23_str_2d__3e_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_read_2d_line_2a_)
___DEF_M_HLBL(___L1_c_23_read_2d_line_2a_)
___DEF_M_HLBL(___L2_c_23_read_2d_line_2a_)
___DEF_M_HLBL(___L3_c_23_read_2d_line_2a_)
___DEF_M_HLBL(___L4_c_23_read_2d_line_2a_)
___DEF_M_HLBL(___L5_c_23_read_2d_line_2a_)
___DEF_M_HLBL(___L6_c_23_read_2d_line_2a_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_make_2d_stretchable_2d_vector)
___DEF_M_HLBL(___L1_c_23_make_2d_stretchable_2d_vector)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_stretchable_2d_vector_2d_length)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_stretchable_2d_vector_2d_ref)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_stretchable_2d_vector_2d_set_21_)
___DEF_M_HLBL(___L1_c_23_stretchable_2d_vector_2d_set_21_)
___DEF_M_HLBL(___L2_c_23_stretchable_2d_vector_2d_set_21_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_stretch_2d_vector)
___DEF_M_HLBL(___L1_c_23_stretch_2d_vector)
___DEF_M_HLBL(___L2_c_23_stretch_2d_vector)
___DEF_M_HLBL(___L3_c_23_stretch_2d_vector)
___DEF_M_HLBL(___L4_c_23_stretch_2d_vector)
___DEF_M_HLBL(___L5_c_23_stretch_2d_vector)
___DEF_M_HLBL(___L6_c_23_stretch_2d_vector)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_stretchable_2d_vector_2d_copy)
___DEF_M_HLBL(___L1_c_23_stretchable_2d_vector_2d_copy)
___DEF_M_HLBL(___L2_c_23_stretchable_2d_vector_2d_copy)
___DEF_M_HLBL(___L3_c_23_stretchable_2d_vector_2d_copy)
___DEF_M_HLBL(___L4_c_23_stretchable_2d_vector_2d_copy)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_M_HLBL(___L1_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_M_HLBL(___L2_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_M_HLBL(___L3_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_M_HLBL(___L4_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_stretchable_2d_vector_2d__3e_list)
___DEF_M_HLBL(___L1_c_23_stretchable_2d_vector_2d__3e_list)
___DEF_M_HLBL(___L2_c_23_stretchable_2d_vector_2d__3e_list)
___DEF_M_HLBL(___L3_c_23_stretchable_2d_vector_2d__3e_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_make_2d_ordered_2d_table)
___DEF_M_HLBL(___L1_c_23_make_2d_ordered_2d_table)
___DEF_M_HLBL(___L2_c_23_make_2d_ordered_2d_table)
___DEF_M_HLBL(___L3_c_23_make_2d_ordered_2d_table)
___DEF_M_HLBL(___L4_c_23_make_2d_ordered_2d_table)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ordered_2d_table_2d_length)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ordered_2d_table_2d_index)
___DEF_M_HLBL(___L1_c_23_ordered_2d_table_2d_index)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ordered_2d_table_2d_lookup)
___DEF_M_HLBL(___L1_c_23_ordered_2d_table_2d_lookup)
___DEF_M_HLBL(___L2_c_23_ordered_2d_table_2d_lookup)
___DEF_M_HLBL(___L3_c_23_ordered_2d_table_2d_lookup)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ordered_2d_table_2d_enter)
___DEF_M_HLBL(___L1_c_23_ordered_2d_table_2d_enter)
___DEF_M_HLBL(___L2_c_23_ordered_2d_table_2d_enter)
___DEF_M_HLBL(___L3_c_23_ordered_2d_table_2d_enter)
___DEF_M_HLBL(___L4_c_23_ordered_2d_table_2d_enter)
___DEF_M_HLBL(___L5_c_23_ordered_2d_table_2d_enter)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ordered_2d_table_2d__3e_list)
___DEF_M_HLBL(___L1_c_23_ordered_2d_table_2d__3e_list)
___DEF_M_HLBL(___L2_c_23_ordered_2d_table_2d__3e_list)
___DEF_M_HLBL(___L3_c_23_ordered_2d_table_2d__3e_list)
___DEF_M_HLBL(___L4_c_23_ordered_2d_table_2d__3e_list)
___DEF_M_HLBL(___L5_c_23_ordered_2d_table_2d__3e_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_bits_2d_and)
___DEF_M_HLBL(___L1_c_23_bits_2d_and)
___DEF_M_HLBL(___L2_c_23_bits_2d_and)
___DEF_M_HLBL(___L3_c_23_bits_2d_and)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_bits_2d_or)
___DEF_M_HLBL(___L1_c_23_bits_2d_or)
___DEF_M_HLBL(___L2_c_23_bits_2d_or)
___DEF_M_HLBL(___L3_c_23_bits_2d_or)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_bits_2d_shl)
___DEF_M_HLBL(___L1_c_23_bits_2d_shl)
___DEF_M_HLBL(___L2_c_23_bits_2d_shl)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_bits_2d_shr)
___DEF_M_HLBL(___L1_c_23_bits_2d_shr)
___DEF_M_HLBL(___L2_c_23_bits_2d_shr)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_with_2d_exception_2d_handling)
___DEF_M_HLBL(___L1_c_23_with_2d_exception_2d_handling)
___DEF_M_HLBL(___L2_c_23_with_2d_exception_2d_handling)
___DEF_M_HLBL(___L3_c_23_with_2d_exception_2d_handling)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_compiler_2d_error)
___DEF_M_HLBL(___L1_c_23_compiler_2d_error)
___DEF_M_HLBL(___L2_c_23_compiler_2d_error)
___DEF_M_HLBL(___L3_c_23_compiler_2d_error)
___DEF_M_HLBL(___L4_c_23_compiler_2d_error)
___DEF_M_HLBL(___L5_c_23_compiler_2d_error)
___DEF_M_HLBL(___L6_c_23_compiler_2d_error)
___DEF_M_HLBL(___L7_c_23_compiler_2d_error)
___DEF_M_HLBL(___L8_c_23_compiler_2d_error)
___DEF_M_HLBL(___L9_c_23_compiler_2d_error)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L1_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L2_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L3_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L4_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L5_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L6_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L7_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L8_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L9_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L10_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL(___L11_c_23_compiler_2d_user_2d_error)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L1_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L2_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L3_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L4_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L5_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L6_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L7_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L8_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L9_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL(___L10_c_23_compiler_2d_user_2d_warning)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L1_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L2_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L3_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L4_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L5_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L6_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L7_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L8_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L9_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L10_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL(___L11_c_23_compiler_2d_internal_2d_error)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L1_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L2_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L3_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L4_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L5_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L6_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L7_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L8_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L9_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L10_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL(___L11_c_23_compiler_2d_limitation_2d_error)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_compiler_2d_abort)
___DEF_M_HLBL(___L1_c_23_compiler_2d_abort)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_make_2d_gnode)
___DEF_M_HLBL(___L1_c_23_make_2d_gnode)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_gnode_2d_var)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_gnode_2d_depvars)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L1_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L2_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L3_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L4_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L5_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L6_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L7_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L8_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L9_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L10_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L11_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L12_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L13_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L14_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L15_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L16_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L17_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L18_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L19_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L20_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L21_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L22_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L23_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L24_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L25_c_23_transitive_2d_closure)
___DEF_M_HLBL(___L26_c_23_transitive_2d_closure)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_gnode_2d_find_2d_depvars)
___DEF_M_HLBL(___L1_c_23_gnode_2d_find_2d_depvars)
___DEF_M_HLBL(___L2_c_23_gnode_2d_find_2d_depvars)
___DEF_M_HLBL(___L3_c_23_gnode_2d_find_2d_depvars)
___DEF_M_HLBL(___L4_c_23_gnode_2d_find_2d_depvars)
___DEF_M_HLBL(___L5_c_23_gnode_2d_find_2d_depvars)
___DEF_M_HLBL(___L6_c_23_gnode_2d_find_2d_depvars)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_gnodes_2d_remove)
___DEF_M_HLBL(___L1_c_23_gnodes_2d_remove)
___DEF_M_HLBL(___L2_c_23_gnodes_2d_remove)
___DEF_M_HLBL(___L3_c_23_gnodes_2d_remove)
___DEF_M_HLBL(___L4_c_23_gnodes_2d_remove)
___DEF_M_HLBL(___L5_c_23_gnodes_2d_remove)
___DEF_M_HLBL(___L6_c_23_gnodes_2d_remove)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_topological_2d_sort)
___DEF_M_HLBL(___L1_c_23_topological_2d_sort)
___DEF_M_HLBL(___L2_c_23_topological_2d_sort)
___DEF_M_HLBL(___L3_c_23_topological_2d_sort)
___DEF_M_HLBL(___L4_c_23_topological_2d_sort)
___DEF_M_HLBL(___L5_c_23_topological_2d_sort)
___DEF_M_HLBL(___L6_c_23_topological_2d_sort)
___DEF_M_HLBL(___L7_c_23_topological_2d_sort)
___DEF_M_HLBL(___L8_c_23_topological_2d_sort)
___DEF_M_HLBL(___L9_c_23_topological_2d_sort)
___DEF_M_HLBL(___L10_c_23_topological_2d_sort)
___DEF_M_HLBL(___L11_c_23_topological_2d_sort)
___DEF_M_HLBL(___L12_c_23_topological_2d_sort)
___DEF_M_HLBL(___L13_c_23_topological_2d_sort)
___DEF_M_HLBL(___L14_c_23_topological_2d_sort)
___DEF_M_HLBL(___L15_c_23_topological_2d_sort)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_remove_2d_no_2d_depvars)
___DEF_M_HLBL(___L1_c_23_remove_2d_no_2d_depvars)
___DEF_M_HLBL(___L2_c_23_remove_2d_no_2d_depvars)
___DEF_M_HLBL(___L3_c_23_remove_2d_no_2d_depvars)
___DEF_M_HLBL(___L4_c_23_remove_2d_no_2d_depvars)
___DEF_M_HLBL(___L5_c_23_remove_2d_no_2d_depvars)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L1_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L2_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L3_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L4_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L5_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L6_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L7_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L8_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L9_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L10_c_23_remove_2d_cycle)
___DEF_M_HLBL(___L11_c_23_remove_2d_cycle)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ptset_2d_empty)
___DEF_M_HLBL(___L1_c_23_ptset_2d_empty)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_list_2d__3e_ptset)
___DEF_M_HLBL(___L1_c_23_list_2d__3e_ptset)
___DEF_M_HLBL(___L2_c_23_list_2d__3e_ptset)
___DEF_M_HLBL(___L3_c_23_list_2d__3e_ptset)
___DEF_M_HLBL(___L4_c_23_list_2d__3e_ptset)
___DEF_M_HLBL(___L5_c_23_list_2d__3e_ptset)
___DEF_M_HLBL(___L6_c_23_list_2d__3e_ptset)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ptset_2d__3e_list)
___DEF_M_HLBL(___L1_c_23_ptset_2d__3e_list)
___DEF_M_HLBL(___L2_c_23_ptset_2d__3e_list)
___DEF_M_HLBL(___L3_c_23_ptset_2d__3e_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ptset_2d_size)
___DEF_M_HLBL(___L1_c_23_ptset_2d_size)
___DEF_M_HLBL(___L2_c_23_ptset_2d_size)
___DEF_M_HLBL(___L3_c_23_ptset_2d_size)
___DEF_M_HLBL(___L4_c_23_ptset_2d_size)
___DEF_M_HLBL(___L5_c_23_ptset_2d_size)
___DEF_M_HLBL(___L6_c_23_ptset_2d_size)
___DEF_M_HLBL(___L7_c_23_ptset_2d_size)
___DEF_M_HLBL(___L8_c_23_ptset_2d_size)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ptset_2d_empty_3f_)
___DEF_M_HLBL(___L1_c_23_ptset_2d_empty_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ptset_2d_member_3f_)
___DEF_M_HLBL(___L1_c_23_ptset_2d_member_3f_)
___DEF_M_HLBL(___L2_c_23_ptset_2d_member_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ptset_2d_adjoin)
___DEF_M_HLBL(___L1_c_23_ptset_2d_adjoin)
___DEF_M_HLBL(___L2_c_23_ptset_2d_adjoin)
___DEF_M_HLBL(___L3_c_23_ptset_2d_adjoin)
___DEF_M_HLBL(___L4_c_23_ptset_2d_adjoin)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL(___L1_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL(___L2_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL(___L3_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL(___L4_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL(___L5_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL(___L6_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL(___L7_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL(___L8_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL(___L9_c_23_ptset_2d_every_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_ptset_2d_remove)
___DEF_M_HLBL(___L1_c_23_ptset_2d_remove)
___DEF_M_HLBL(___L2_c_23_ptset_2d_remove)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_reverse_2d_append_21_)
___DEF_M_HLBL(___L1_c_23_varset_2d_reverse_2d_append_21_)
___DEF_M_HLBL(___L2_c_23_varset_2d_reverse_2d_append_21_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_wrap)
___DEF_M_HLBL(___L1_c_23_varset_2d_wrap)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_unwrap)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_empty)
___DEF_M_HLBL(___L1_c_23_varset_2d_empty)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_singleton)
___DEF_M_HLBL(___L1_c_23_varset_2d_singleton)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L1_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L2_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L3_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L4_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L5_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L6_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L7_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L8_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L9_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L10_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L11_c_23_list_2d__3e_varset)
___DEF_M_HLBL(___L12_c_23_list_2d__3e_varset)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d__3e_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_size)
___DEF_M_HLBL(___L1_c_23_varset_2d_size)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_empty_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d__3c_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_member_3f_)
___DEF_M_HLBL(___L1_c_23_varset_2d_member_3f_)
___DEF_M_HLBL(___L2_c_23_varset_2d_member_3f_)
___DEF_M_HLBL(___L3_c_23_varset_2d_member_3f_)
___DEF_M_HLBL(___L4_c_23_varset_2d_member_3f_)
___DEF_M_HLBL(___L5_c_23_varset_2d_member_3f_)
___DEF_M_HLBL(___L6_c_23_varset_2d_member_3f_)
___DEF_M_HLBL(___L7_c_23_varset_2d_member_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_adjoin)
___DEF_M_HLBL(___L1_c_23_varset_2d_adjoin)
___DEF_M_HLBL(___L2_c_23_varset_2d_adjoin)
___DEF_M_HLBL(___L3_c_23_varset_2d_adjoin)
___DEF_M_HLBL(___L4_c_23_varset_2d_adjoin)
___DEF_M_HLBL(___L5_c_23_varset_2d_adjoin)
___DEF_M_HLBL(___L6_c_23_varset_2d_adjoin)
___DEF_M_HLBL(___L7_c_23_varset_2d_adjoin)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_remove)
___DEF_M_HLBL(___L1_c_23_varset_2d_remove)
___DEF_M_HLBL(___L2_c_23_varset_2d_remove)
___DEF_M_HLBL(___L3_c_23_varset_2d_remove)
___DEF_M_HLBL(___L4_c_23_varset_2d_remove)
___DEF_M_HLBL(___L5_c_23_varset_2d_remove)
___DEF_M_HLBL(___L6_c_23_varset_2d_remove)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_equal_3f_)
___DEF_M_HLBL(___L1_c_23_varset_2d_equal_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_difference)
___DEF_M_HLBL(___L1_c_23_varset_2d_difference)
___DEF_M_HLBL(___L2_c_23_varset_2d_difference)
___DEF_M_HLBL(___L3_c_23_varset_2d_difference)
___DEF_M_HLBL(___L4_c_23_varset_2d_difference)
___DEF_M_HLBL(___L5_c_23_varset_2d_difference)
___DEF_M_HLBL(___L6_c_23_varset_2d_difference)
___DEF_M_HLBL(___L7_c_23_varset_2d_difference)
___DEF_M_HLBL(___L8_c_23_varset_2d_difference)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_union)
___DEF_M_HLBL(___L1_c_23_varset_2d_union)
___DEF_M_HLBL(___L2_c_23_varset_2d_union)
___DEF_M_HLBL(___L3_c_23_varset_2d_union)
___DEF_M_HLBL(___L4_c_23_varset_2d_union)
___DEF_M_HLBL(___L5_c_23_varset_2d_union)
___DEF_M_HLBL(___L6_c_23_varset_2d_union)
___DEF_M_HLBL(___L7_c_23_varset_2d_union)
___DEF_M_HLBL(___L8_c_23_varset_2d_union)
___DEF_M_HLBL(___L9_c_23_varset_2d_union)
___DEF_M_HLBL(___L10_c_23_varset_2d_union)
___DEF_M_HLBL(___L11_c_23_varset_2d_union)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_intersection)
___DEF_M_HLBL(___L1_c_23_varset_2d_intersection)
___DEF_M_HLBL(___L2_c_23_varset_2d_intersection)
___DEF_M_HLBL(___L3_c_23_varset_2d_intersection)
___DEF_M_HLBL(___L4_c_23_varset_2d_intersection)
___DEF_M_HLBL(___L5_c_23_varset_2d_intersection)
___DEF_M_HLBL(___L6_c_23_varset_2d_intersection)
___DEF_M_HLBL(___L7_c_23_varset_2d_intersection)
___DEF_M_HLBL(___L8_c_23_varset_2d_intersection)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_intersects_3f_)
___DEF_M_HLBL(___L1_c_23_varset_2d_intersects_3f_)
___DEF_M_HLBL(___L2_c_23_varset_2d_intersects_3f_)
___DEF_M_HLBL(___L3_c_23_varset_2d_intersects_3f_)
___DEF_M_HLBL(___L4_c_23_varset_2d_intersects_3f_)
___DEF_M_HLBL(___L5_c_23_varset_2d_intersects_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL(___L1_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL(___L2_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL(___L3_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL(___L4_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL(___L5_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL(___L6_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL(___L7_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL(___L8_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL(___L9_c_23_varset_2d_union_2d_multi)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_n_2d_ary)
___DEF_M_HLBL(___L1_c_23_n_2d_ary)
___DEF_M_HLBL(___L2_c_23_n_2d_ary)
___DEF_M_HLBL(___L3_c_23_n_2d_ary)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_list_2d__3e_queue)
___DEF_M_HLBL(___L1_c_23_list_2d__3e_queue)
___DEF_M_HLBL(___L2_c_23_list_2d__3e_queue)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_queue_2d__3e_list)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_queue_2d_empty)
___DEF_M_HLBL(___L1_c_23_queue_2d_empty)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_queue_2d_empty_3f_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_queue_2d_get_21_)
___DEF_M_HLBL(___L1_c_23_queue_2d_get_21_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_queue_2d_put_21_)
___DEF_M_HLBL(___L1_c_23_queue_2d_put_21_)
___DEF_M_HLBL_INTRO
___DEF_M_HLBL(___L0_c_23_throw_2d_to_2d_exception_2d_handler)
___DEF_M_HLBL(___L1_c_23_throw_2d_to_2d_exception_2d_handler)
___END_M_HLBL
___BEGIN_M_SW
#undef ___PH_PROC
#define ___PH_PROC ___H___utils_23_
#undef ___PH_LBL0
#define ___PH_LBL0 1
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0___utils_23_)
___DEF_P_HLBL(___L1___utils_23_)
___DEF_P_HLBL(___L2___utils_23_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0___utils_23_)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(0,0,0,0)
___DEF_GLBL(___L___utils_23_)
___SET_GLO(68,___G_c_23_throw_2d_to_2d_exception_2d_handler,___PRC(579))
___SET_GLO(90,___G_c_23_warnings_2d_requested_3f_,___FAL)
___SET_GLO(90,___G_c_23_warnings_2d_requested_3f_,___TRU)
___SET_STK(1,___R0)
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1___utils_23_)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(0),___PRC(385),___L_c_23_ptset_2d_empty)
___DEF_SLBL(2,___L2___utils_23_)
___SET_GLO(42,___G_c_23_ptset_2d_empty_2d_set,___R1)
___SET_R1(___VOID)
___ADJFP(-4)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_append_2d_lists
#undef ___PH_LBL0
#define ___PH_LBL0 5
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_append_2d_lists)
___DEF_P_HLBL(___L1_c_23_append_2d_lists)
___DEF_P_HLBL(___L2_c_23_append_2d_lists)
___DEF_P_HLBL(___L3_c_23_append_2d_lists)
___DEF_P_HLBL(___L4_c_23_append_2d_lists)
___DEF_P_HLBL(___L5_c_23_append_2d_lists)
___DEF_P_HLBL(___L6_c_23_append_2d_lists)
___DEF_P_HLBL(___L7_c_23_append_2d_lists)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_append_2d_lists)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_append_2d_lists)
___IF(___NOT(___PAIRP(___R1)))
___GOTO(___L14_c_23_append_2d_lists)
___END_IF
___POLL(1)
___DEF_SLBL(1,___L1_c_23_append_2d_lists)
___GOTO(___L9_c_23_append_2d_lists)
___DEF_GLBL(___L8_c_23_append_2d_lists)
___SET_R2(___CAR(___R1))
___SET_STK(1,___R0)
___SET_STK(2,___R2)
___SET_R1(___CDR(___R1))
___SET_R0(___LBL(3))
___ADJFP(8)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_append_2d_lists)
___DEF_GLBL(___L9_c_23_append_2d_lists)
___SET_R2(___CDR(___R1))
___IF(___PAIRP(___R2))
___GOTO(___L8_c_23_append_2d_lists)
___END_IF
___SET_R1(___CAR(___R1))
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(3,___L3_c_23_append_2d_lists)
___IF(___NOT(___PAIRP(___STK(-6))))
___GOTO(___L13_c_23_append_2d_lists)
___END_IF
___SET_R2(___CAR(___STK(-6)))
___SET_R2(___CONS(___R2,___NUL))
___SET_STK(-5,___R1)
___SET_STK(-4,___R2)
___SET_R2(___CDR(___STK(-6)))
___SET_R1(___STK(-4))
___SET_R0(___LBL(7))
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4_c_23_append_2d_lists)
___IF(___PAIRP(___R2))
___GOTO(___L11_c_23_append_2d_lists)
___END_IF
___GOTO(___L12_c_23_append_2d_lists)
___DEF_GLBL(___L10_c_23_append_2d_lists)
___IF(___NOT(___PAIRP(___R2)))
___GOTO(___L12_c_23_append_2d_lists)
___END_IF
___DEF_GLBL(___L11_c_23_append_2d_lists)
___SET_R3(___CAR(___R2))
___SET_R3(___CONS(___R3,___NUL))
___SETCDR(___R1,___R3)
___SET_R2(___CDR(___R2))
___SET_R1(___R3)
___CHECK_HEAP(5,4096)
___DEF_SLBL(5,___L5_c_23_append_2d_lists)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_append_2d_lists)
___GOTO(___L10_c_23_append_2d_lists)
___DEF_GLBL(___L12_c_23_append_2d_lists)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(7,___L7_c_23_append_2d_lists)
___SETCDR(___R1,___STK(-5))
___SET_R1(___STK(-4))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L13_c_23_append_2d_lists)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L14_c_23_append_2d_lists)
___SET_R1(___NUL)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_reverse_2d_append_21_
#undef ___PH_LBL0
#define ___PH_LBL0 14
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_reverse_2d_append_21_)
___DEF_P_HLBL(___L1_c_23_reverse_2d_append_21_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_reverse_2d_append_21_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_reverse_2d_append_21_)
___IF(___NULLP(___R1))
___GOTO(___L4_c_23_reverse_2d_append_21_)
___END_IF
___GOTO(___L3_c_23_reverse_2d_append_21_)
___DEF_GLBL(___L2_c_23_reverse_2d_append_21_)
___IF(___NULLP(___R1))
___GOTO(___L4_c_23_reverse_2d_append_21_)
___END_IF
___DEF_GLBL(___L3_c_23_reverse_2d_append_21_)
___SET_R3(___CDR(___R1))
___SETCDR(___R1,___R2)
___SET_R2(___R1)
___SET_R1(___R3)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_reverse_2d_append_21_)
___GOTO(___L2_c_23_reverse_2d_append_21_)
___DEF_GLBL(___L4_c_23_reverse_2d_append_21_)
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_list_2d_length
#undef ___PH_LBL0
#define ___PH_LBL0 17
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_list_2d_length)
___DEF_P_HLBL(___L1_c_23_list_2d_length)
___DEF_P_HLBL(___L2_c_23_list_2d_length)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_list_2d_length)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_list_2d_length)
___SET_R2(___R1)
___SET_R1(___FIX(0L))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_list_2d_length)
___GOTO(___L4_c_23_list_2d_length)
___DEF_GLBL(___L3_c_23_list_2d_length)
___SET_R2(___CDR(___R2))
___SET_R1(___FIXADD(___R1,___FIX(1L)))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_list_2d_length)
___DEF_GLBL(___L4_c_23_list_2d_length)
___IF(___PAIRP(___R2))
___GOTO(___L3_c_23_list_2d_length)
___END_IF
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_make_2d_counter
#undef ___PH_LBL0
#define ___PH_LBL0 21
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_make_2d_counter)
___DEF_P_HLBL(___L1_c_23_make_2d_counter)
___DEF_P_HLBL(___L2_c_23_make_2d_counter)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_make_2d_counter)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_make_2d_counter)
___SET_R1(___BOX(___R1))
___SET_STK(1,___ALLOC_CLO(1UL))
___BEGIN_SETUP_CLO(1,___STK(1),2)
___ADD_CLO_ELEM(0,___R1)
___END_SETUP_CLO(1)
___SET_R1(___STK(1))
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_make_2d_counter)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(2,___L2_c_23_make_2d_counter)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(2,0,0,0)
___SET_R3(___CLO(___R4,1))
___SET_R1(___UNBOX(___R3))
___SET_R3(___CLO(___R4,1))
___SET_R2(___UNBOX(___R3))
___SET_R2(___FIXADD(___R2,___FIX(1L)))
___SET_R4(___CLO(___R4,1))
___SETBOX(___R4,___R2)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_for_2d_each_2d_index
#undef ___PH_LBL0
#define ___PH_LBL0 25
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_for_2d_each_2d_index)
___DEF_P_HLBL(___L1_c_23_for_2d_each_2d_index)
___DEF_P_HLBL(___L2_c_23_for_2d_each_2d_index)
___DEF_P_HLBL(___L3_c_23_for_2d_each_2d_index)
___DEF_P_HLBL(___L4_c_23_for_2d_each_2d_index)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_for_2d_each_2d_index)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_for_2d_each_2d_index)
___SET_R3(___FIX(0L))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_for_2d_each_2d_index)
___GOTO(___L5_c_23_for_2d_each_2d_index)
___DEF_SLBL(2,___L2_c_23_for_2d_each_2d_index)
___SET_R3(___FIXADD(___STK(-4),___FIX(1L)))
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_for_2d_each_2d_index)
___DEF_GLBL(___L5_c_23_for_2d_each_2d_index)
___IF(___NOT(___PAIRP(___R2)))
___GOTO(___L6_c_23_for_2d_each_2d_index)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R2(___R3)
___SET_R1(___CAR(___STK(3)))
___ADJFP(8)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_for_2d_each_2d_index)
___SET_R0(___LBL(2))
___JUMPGENNOTSAFE(___SET_NARGS(2),___STK(-6))
___DEF_GLBL(___L6_c_23_for_2d_each_2d_index)
___SET_R1(___VOID)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_map_2d_index
#undef ___PH_LBL0
#define ___PH_LBL0 31
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_map_2d_index)
___DEF_P_HLBL(___L1_c_23_map_2d_index)
___DEF_P_HLBL(___L2_c_23_map_2d_index)
___DEF_P_HLBL(___L3_c_23_map_2d_index)
___DEF_P_HLBL(___L4_c_23_map_2d_index)
___DEF_P_HLBL(___L5_c_23_map_2d_index)
___DEF_P_HLBL(___L6_c_23_map_2d_index)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_map_2d_index)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_map_2d_index)
___SET_STK(1,___R1)
___SET_R1(___R2)
___SET_R3(___NUL)
___SET_R2(___FIX(0L))
___ADJFP(1)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_map_2d_index)
___GOTO(___L7_c_23_map_2d_index)
___DEF_SLBL(2,___L2_c_23_map_2d_index)
___SET_R3(___CONS(___R1,___STK(-3)))
___SET_R2(___FIXADD(___STK(-4),___FIX(1L)))
___SET_R1(___CDR(___STK(-5)))
___SET_R0(___STK(-6))
___ADJFP(-7)
___CHECK_HEAP(3,4096)
___DEF_SLBL(3,___L3_c_23_map_2d_index)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_map_2d_index)
___DEF_GLBL(___L7_c_23_map_2d_index)
___IF(___NOT(___PAIRP(___R1)))
___GOTO(___L8_c_23_map_2d_index)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___CAR(___R1))
___ADJFP(7)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_map_2d_index)
___SET_R0(___LBL(2))
___JUMPGENNOTSAFE(___SET_NARGS(2),___STK(-7))
___DEF_GLBL(___L8_c_23_map_2d_index)
___SET_R1(___R3)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_map_2d_index)
___ADJFP(-1)
___JUMPPRM(___SET_NARGS(1),___PRM_reverse)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_pos_2d_in_2d_list
#undef ___PH_LBL0
#define ___PH_LBL0 39
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_pos_2d_in_2d_list)
___DEF_P_HLBL(___L1_c_23_pos_2d_in_2d_list)
___DEF_P_HLBL(___L2_c_23_pos_2d_in_2d_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_pos_2d_in_2d_list)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_pos_2d_in_2d_list)
___SET_R3(___FIX(0L))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_pos_2d_in_2d_list)
___GOTO(___L4_c_23_pos_2d_in_2d_list)
___DEF_GLBL(___L3_c_23_pos_2d_in_2d_list)
___SET_R4(___CAR(___R2))
___IF(___EQP(___R4,___R1))
___GOTO(___L5_c_23_pos_2d_in_2d_list)
___END_IF
___SET_R3(___FIXADD(___R3,___FIX(1L)))
___SET_R2(___CDR(___R2))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_pos_2d_in_2d_list)
___DEF_GLBL(___L4_c_23_pos_2d_in_2d_list)
___IF(___PAIRP(___R2))
___GOTO(___L3_c_23_pos_2d_in_2d_list)
___END_IF
___SET_R1(___FAL)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L5_c_23_pos_2d_in_2d_list)
___SET_R1(___R3)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_object_2d_pos_2d_in_2d_list
#undef ___PH_LBL0
#define ___PH_LBL0 43
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_object_2d_pos_2d_in_2d_list)
___DEF_P_HLBL(___L1_c_23_object_2d_pos_2d_in_2d_list)
___DEF_P_HLBL(___L2_c_23_object_2d_pos_2d_in_2d_list)
___DEF_P_HLBL(___L3_c_23_object_2d_pos_2d_in_2d_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_object_2d_pos_2d_in_2d_list)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_object_2d_pos_2d_in_2d_list)
___SET_R3(___FIX(0L))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_object_2d_pos_2d_in_2d_list)
___GOTO(___L5_c_23_object_2d_pos_2d_in_2d_list)
___DEF_SLBL(2,___L2_c_23_object_2d_pos_2d_in_2d_list)
___IF(___NOTFALSEP(___R1))
___GOTO(___L7_c_23_object_2d_pos_2d_in_2d_list)
___END_IF
___SET_R3(___STK(-4))
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___DEF_GLBL(___L4_c_23_object_2d_pos_2d_in_2d_list)
___SET_R3(___FIXADD(___R3,___FIX(1L)))
___SET_R2(___CDR(___R2))
___POLL(3)
___DEF_SLBL(3,___L3_c_23_object_2d_pos_2d_in_2d_list)
___DEF_GLBL(___L5_c_23_object_2d_pos_2d_in_2d_list)
___IF(___NOT(___PAIRP(___R2)))
___GOTO(___L9_c_23_object_2d_pos_2d_in_2d_list)
___END_IF
___SET_R4(___CAR(___R2))
___IF(___EQP(___R4,___R1))
___GOTO(___L8_c_23_object_2d_pos_2d_in_2d_list)
___END_IF
___IF(___NOT(___MEMALLOCATEDP(___R4)))
___GOTO(___L4_c_23_object_2d_pos_2d_in_2d_list)
___END_IF
___IF(___NOT(___MEMALLOCATEDP(___R1)))
___GOTO(___L4_c_23_object_2d_pos_2d_in_2d_list)
___END_IF
___SET_STK(1,___SUBTYPE(___R1))
___SET_STK(2,___SUBTYPE(___R4))
___ADJFP(2)
___IF(___FIXEQ(___STK(0),___STK(-1)))
___GOTO(___L6_c_23_object_2d_pos_2d_in_2d_list)
___END_IF
___ADJFP(-2)
___GOTO(___L4_c_23_object_2d_pos_2d_in_2d_list)
___DEF_GLBL(___L6_c_23_object_2d_pos_2d_in_2d_list)
___SET_STK(-1,___R0)
___SET_STK(0,___R1)
___SET_STK(1,___R2)
___SET_STK(2,___R3)
___SET_R2(___R1)
___SET_R1(___R4)
___SET_R0(___LBL(2))
___ADJFP(6)
___JUMPPRM(___SET_NARGS(2),___PRM_equal_3f_)
___DEF_GLBL(___L7_c_23_object_2d_pos_2d_in_2d_list)
___SET_R3(___STK(-4))
___SET_R0(___STK(-7))
___ADJFP(-8)
___DEF_GLBL(___L8_c_23_object_2d_pos_2d_in_2d_list)
___SET_R1(___R3)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L9_c_23_object_2d_pos_2d_in_2d_list)
___SET_R1(___FAL)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_string_2d_pos_2d_in_2d_list
#undef ___PH_LBL0
#define ___PH_LBL0 48
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_string_2d_pos_2d_in_2d_list)
___DEF_P_HLBL(___L1_c_23_string_2d_pos_2d_in_2d_list)
___DEF_P_HLBL(___L2_c_23_string_2d_pos_2d_in_2d_list)
___DEF_P_HLBL(___L3_c_23_string_2d_pos_2d_in_2d_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_string_2d_pos_2d_in_2d_list)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_string_2d_pos_2d_in_2d_list)
___SET_R3(___FIX(0L))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_string_2d_pos_2d_in_2d_list)
___GOTO(___L4_c_23_string_2d_pos_2d_in_2d_list)
___DEF_SLBL(2,___L2_c_23_string_2d_pos_2d_in_2d_list)
___IF(___NOTFALSEP(___R1))
___GOTO(___L6_c_23_string_2d_pos_2d_in_2d_list)
___END_IF
___SET_R3(___FIXADD(___STK(-4),___FIX(1L)))
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_string_2d_pos_2d_in_2d_list)
___DEF_GLBL(___L4_c_23_string_2d_pos_2d_in_2d_list)
___IF(___NOT(___PAIRP(___R2)))
___GOTO(___L5_c_23_string_2d_pos_2d_in_2d_list)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R2(___R1)
___SET_R1(___CAR(___STK(3)))
___SET_R0(___LBL(2))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(2),___PRM_string_3d__3f_)
___DEF_GLBL(___L5_c_23_string_2d_pos_2d_in_2d_list)
___SET_R1(___FAL)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L6_c_23_string_2d_pos_2d_in_2d_list)
___SET_R1(___STK(-4))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_take
#undef ___PH_LBL0
#define ___PH_LBL0 53
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_take)
___DEF_P_HLBL(___L1_take)
___DEF_P_HLBL(___L2_take)
___DEF_P_HLBL(___L3_take)
___DEF_P_HLBL(___L4_take)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_take)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_take)
___POLL(1)
___DEF_SLBL(1,___L1_take)
___GOTO(___L6_take)
___DEF_GLBL(___L5_take)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R2(___FIXSUB(___R2,___FIX(1L)))
___SET_R1(___CDR(___R1))
___SET_R0(___LBL(3))
___ADJFP(8)
___POLL(2)
___DEF_SLBL(2,___L2_take)
___DEF_GLBL(___L6_take)
___IF(___FIXGT(___R2,___FIX(0L)))
___GOTO(___L5_take)
___END_IF
___SET_R1(___NUL)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(3,___L3_take)
___SET_R2(___CAR(___STK(-6)))
___SET_R1(___CONS(___R2,___R1))
___ADJFP(-7)
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4_take)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_drop
#undef ___PH_LBL0
#define ___PH_LBL0 59
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_drop)
___DEF_P_HLBL(___L1_drop)
___DEF_P_HLBL(___L2_drop)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_drop)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_drop)
___POLL(1)
___DEF_SLBL(1,___L1_drop)
___GOTO(___L4_drop)
___DEF_GLBL(___L3_drop)
___SET_R2(___FIXSUB(___R2,___FIX(1L)))
___SET_R1(___CDR(___R1))
___POLL(2)
___DEF_SLBL(2,___L2_drop)
___DEF_GLBL(___L4_drop)
___IF(___FIXGT(___R2,___FIX(0L)))
___GOTO(___L3_drop)
___END_IF
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_pair_2d_up
#undef ___PH_LBL0
#define ___PH_LBL0 63
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_pair_2d_up)
___DEF_P_HLBL(___L1_c_23_pair_2d_up)
___DEF_P_HLBL(___L2_c_23_pair_2d_up)
___DEF_P_HLBL(___L3_c_23_pair_2d_up)
___DEF_P_HLBL(___L4_c_23_pair_2d_up)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_pair_2d_up)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_pair_2d_up)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_pair_2d_up)
___GOTO(___L6_c_23_pair_2d_up)
___DEF_GLBL(___L5_c_23_pair_2d_up)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___CDR(___R2))
___SET_R1(___CDR(___R1))
___SET_R0(___LBL(3))
___ADJFP(8)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_pair_2d_up)
___DEF_GLBL(___L6_c_23_pair_2d_up)
___IF(___PAIRP(___R1))
___GOTO(___L5_c_23_pair_2d_up)
___END_IF
___SET_R1(___NUL)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(3,___L3_c_23_pair_2d_up)
___SET_R2(___CAR(___STK(-5)))
___SET_R3(___CAR(___STK(-6)))
___SET_R2(___CONS(___R3,___R2))
___SET_R1(___CONS(___R2,___R1))
___ADJFP(-7)
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4_c_23_pair_2d_up)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_last_2d_pair
#undef ___PH_LBL0
#define ___PH_LBL0 69
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_last_2d_pair)
___DEF_P_HLBL(___L1_last_2d_pair)
___DEF_P_HLBL(___L2_last_2d_pair)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_last_2d_pair)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_last_2d_pair)
___POLL(1)
___DEF_SLBL(1,___L1_last_2d_pair)
___GOTO(___L4_last_2d_pair)
___DEF_GLBL(___L3_last_2d_pair)
___SET_R1(___CDR(___R1))
___POLL(2)
___DEF_SLBL(2,___L2_last_2d_pair)
___DEF_GLBL(___L4_last_2d_pair)
___SET_R2(___CDR(___R1))
___IF(___PAIRP(___R2))
___GOTO(___L3_last_2d_pair)
___END_IF
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_keep
#undef ___PH_LBL0
#define ___PH_LBL0 73
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_keep)
___DEF_P_HLBL(___L1_c_23_keep)
___DEF_P_HLBL(___L2_c_23_keep)
___DEF_P_HLBL(___L3_c_23_keep)
___DEF_P_HLBL(___L4_c_23_keep)
___DEF_P_HLBL(___L5_c_23_keep)
___DEF_P_HLBL(___L6_c_23_keep)
___DEF_P_HLBL(___L7_c_23_keep)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_keep)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_keep)
___SET_R3(___NUL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_keep)
___GOTO(___L8_c_23_keep)
___DEF_SLBL(2,___L2_c_23_keep)
___IF(___NOTFALSEP(___R1))
___GOTO(___L10_c_23_keep)
___END_IF
___SET_R3(___STK(-4))
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_keep)
___DEF_GLBL(___L8_c_23_keep)
___IF(___NOT(___NULLP(___R2)))
___GOTO(___L9_c_23_keep)
___END_IF
___SET_R1(___R3)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_keep)
___JUMPINT(___SET_NARGS(2),___PRC(14),___L_c_23_reverse_2d_append_21_)
___DEF_GLBL(___L9_c_23_keep)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___CAR(___R2))
___ADJFP(8)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_keep)
___SET_R0(___LBL(2))
___JUMPGENNOTSAFE(___SET_NARGS(1),___STK(-6))
___DEF_GLBL(___L10_c_23_keep)
___SET_R1(___CAR(___STK(-5)))
___SET_R3(___CONS(___R1,___STK(-4)))
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___CHECK_HEAP(6,4096)
___DEF_SLBL(6,___L6_c_23_keep)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_keep)
___GOTO(___L8_c_23_keep)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_every_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 82
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_every_3f_)
___DEF_P_HLBL(___L1_c_23_every_3f_)
___DEF_P_HLBL(___L2_c_23_every_3f_)
___DEF_P_HLBL(___L3_c_23_every_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_every_3f_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_every_3f_)
___IF(___NULLP(___R2))
___GOTO(___L6_c_23_every_3f_)
___END_IF
___GOTO(___L4_c_23_every_3f_)
___DEF_SLBL(1,___L1_c_23_every_3f_)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L5_c_23_every_3f_)
___END_IF
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_every_3f_)
___IF(___NULLP(___R2))
___GOTO(___L6_c_23_every_3f_)
___END_IF
___DEF_GLBL(___L4_c_23_every_3f_)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___CAR(___R2))
___ADJFP(8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_every_3f_)
___SET_R0(___LBL(1))
___JUMPGENNOTSAFE(___SET_NARGS(1),___STK(-6))
___DEF_GLBL(___L5_c_23_every_3f_)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L6_c_23_every_3f_)
___SET_R1(___TRU)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_remq
#undef ___PH_LBL0
#define ___PH_LBL0 87
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_remq)
___DEF_P_HLBL(___L1_c_23_remq)
___DEF_P_HLBL(___L2_c_23_remq)
___DEF_P_HLBL(___L3_c_23_remq)
___DEF_P_HLBL(___L4_c_23_remq)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_remq)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_remq)
___SET_STK(1,___R1)
___SET_STK(2,___R2)
___SET_R1(___STK(2))
___SET_R3(___NUL)
___ADJFP(1)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_remq)
___GOTO(___L6_c_23_remq)
___DEF_GLBL(___L5_c_23_remq)
___SET_R4(___CAR(___R2))
___IF(___EQP(___R4,___STK(0)))
___GOTO(___L7_c_23_remq)
___END_IF
___SET_R4(___CAR(___R2))
___SET_R3(___CONS(___R4,___R3))
___SET_R2(___CDR(___R2))
___CHECK_HEAP(2,4096)
___DEF_SLBL(2,___L2_c_23_remq)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_remq)
___DEF_GLBL(___L6_c_23_remq)
___IF(___NOT(___NULLP(___R2)))
___GOTO(___L5_c_23_remq)
___END_IF
___ADJFP(-1)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L7_c_23_remq)
___SET_R2(___CDR(___R2))
___SET_R1(___R3)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_remq)
___ADJFP(-1)
___JUMPINT(___SET_NARGS(2),___PRC(14),___L_c_23_reverse_2d_append_21_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_sort_2d_list
#undef ___PH_LBL0
#define ___PH_LBL0 93
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_sort_2d_list)
___DEF_P_HLBL(___L1_c_23_sort_2d_list)
___DEF_P_HLBL(___L2_c_23_sort_2d_list)
___DEF_P_HLBL(___L3_c_23_sort_2d_list)
___DEF_P_HLBL(___L4_c_23_sort_2d_list)
___DEF_P_HLBL(___L5_c_23_sort_2d_list)
___DEF_P_HLBL(___L6_c_23_sort_2d_list)
___DEF_P_HLBL(___L7_c_23_sort_2d_list)
___DEF_P_HLBL(___L8_c_23_sort_2d_list)
___DEF_P_HLBL(___L9_c_23_sort_2d_list)
___DEF_P_HLBL(___L10_c_23_sort_2d_list)
___DEF_P_HLBL(___L11_c_23_sort_2d_list)
___DEF_P_HLBL(___L12_c_23_sort_2d_list)
___DEF_P_HLBL(___L13_c_23_sort_2d_list)
___DEF_P_HLBL(___L14_c_23_sort_2d_list)
___DEF_P_HLBL(___L15_c_23_sort_2d_list)
___DEF_P_HLBL(___L16_c_23_sort_2d_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_sort_2d_list)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_sort_2d_list)
___SET_STK(1,___R2)
___SET_R2(___R1)
___SET_R1(___STK(1))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_sort_2d_list)
___IF(___NULLP(___R2))
___GOTO(___L22_c_23_sort_2d_list)
___END_IF
___GOTO(___L17_c_23_sort_2d_list)
___DEF_SLBL(2,___L2_c_23_sort_2d_list)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(9))
___IF(___NULLP(___R2))
___GOTO(___L22_c_23_sort_2d_list)
___END_IF
___DEF_GLBL(___L17_c_23_sort_2d_list)
___SET_R3(___CDR(___R2))
___IF(___NULLP(___R3))
___GOTO(___L22_c_23_sort_2d_list)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___R2)
___SET_R0(___LBL(8))
___ADJFP(8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_sort_2d_list)
___DEF_GLBL(___L18_c_23_sort_2d_list)
___IF(___NULLP(___R1))
___GOTO(___L20_c_23_sort_2d_list)
___END_IF
___DEF_GLBL(___L19_c_23_sort_2d_list)
___SET_R2(___CDR(___R1))
___IF(___NULLP(___R2))
___GOTO(___L20_c_23_sort_2d_list)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___CDDR(___R1))
___SET_R0(___LBL(5))
___ADJFP(8)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_sort_2d_list)
___GOTO(___L18_c_23_sort_2d_list)
___DEF_SLBL(5,___L5_c_23_sort_2d_list)
___SET_R2(___CAR(___STK(-6)))
___SET_R1(___CONS(___R2,___R1))
___ADJFP(-7)
___CHECK_HEAP(6,4096)
___DEF_SLBL(6,___L6_c_23_sort_2d_list)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_SLBL(7,___L7_c_23_sort_2d_list)
___SET_STK(-4,___R1)
___SET_R1(___CDR(___STK(-5)))
___SET_R0(___LBL(2))
___IF(___NOT(___NULLP(___R1)))
___GOTO(___L19_c_23_sort_2d_list)
___END_IF
___DEF_GLBL(___L20_c_23_sort_2d_list)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(8,___L8_c_23_sort_2d_list)
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(7))
___IF(___NULLP(___R2))
___GOTO(___L22_c_23_sort_2d_list)
___END_IF
___GOTO(___L17_c_23_sort_2d_list)
___DEF_SLBL(9,___L9_c_23_sort_2d_list)
___SET_R3(___R1)
___SET_R2(___STK(-4))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(10)
___DEF_SLBL(10,___L10_c_23_sort_2d_list)
___IF(___NULLP(___R2))
___GOTO(___L23_c_23_sort_2d_list)
___END_IF
___DEF_GLBL(___L21_c_23_sort_2d_list)
___IF(___NOT(___NULLP(___R3)))
___GOTO(___L25_c_23_sort_2d_list)
___END_IF
___DEF_GLBL(___L22_c_23_sort_2d_list)
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(11,___L11_c_23_sort_2d_list)
___IF(___NOTFALSEP(___R1))
___GOTO(___L24_c_23_sort_2d_list)
___END_IF
___SET_R3(___CDR(___STK(-7)))
___SET_R2(___STK(-8))
___SET_R1(___STK(-9))
___SET_R0(___LBL(14))
___ADJFP(-4)
___IF(___NOT(___NULLP(___R2)))
___GOTO(___L21_c_23_sort_2d_list)
___END_IF
___DEF_GLBL(___L23_c_23_sort_2d_list)
___SET_R1(___R3)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L24_c_23_sort_2d_list)
___SET_R3(___STK(-7))
___SET_R2(___CDR(___STK(-8)))
___SET_R1(___STK(-9))
___SET_R0(___LBL(12))
___IF(___NULLP(___R2))
___GOTO(___L23_c_23_sort_2d_list)
___END_IF
___GOTO(___L21_c_23_sort_2d_list)
___DEF_SLBL(12,___L12_c_23_sort_2d_list)
___SET_R1(___CONS(___STK(-6),___R1))
___ADJFP(-10)
___CHECK_HEAP(13,4096)
___DEF_SLBL(13,___L13_c_23_sort_2d_list)
___ADJFP(-2)
___JUMPPRM(___NOTHING,___STK(2))
___DEF_SLBL(14,___L14_c_23_sort_2d_list)
___SET_R1(___CONS(___STK(-7),___R1))
___ADJFP(-6)
___CHECK_HEAP(15,4096)
___DEF_SLBL(15,___L15_c_23_sort_2d_list)
___ADJFP(-2)
___JUMPPRM(___NOTHING,___STK(2))
___DEF_GLBL(___L25_c_23_sort_2d_list)
___SET_R4(___CAR(___R2))
___SET_STK(1,___CAR(___R3))
___SET_STK(2,___R0)
___SET_STK(3,___R1)
___SET_STK(4,___R2)
___SET_STK(5,___R3)
___SET_STK(6,___R4)
___SET_R2(___STK(1))
___SET_R1(___R4)
___ADJFP(12)
___POLL(16)
___DEF_SLBL(16,___L16_c_23_sort_2d_list)
___SET_R0(___LBL(11))
___JUMPGENNOTSAFE(___SET_NARGS(2),___STK(-9))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_list_2d__3e_vect
#undef ___PH_LBL0
#define ___PH_LBL0 111
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_list_2d__3e_vect)
___DEF_P_HLBL(___L1_c_23_list_2d__3e_vect)
___DEF_P_HLBL(___L2_c_23_list_2d__3e_vect)
___DEF_P_HLBL(___L3_c_23_list_2d__3e_vect)
___DEF_P_HLBL(___L4_c_23_list_2d__3e_vect)
___DEF_P_HLBL(___L5_c_23_list_2d__3e_vect)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_list_2d__3e_vect)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_list_2d__3e_vect)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_list_2d__3e_vect)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(1),___PRC(17),___L_c_23_list_2d_length)
___DEF_SLBL(2,___L2_c_23_list_2d__3e_vect)
___SET_R0(___LBL(3))
___JUMPPRM(___SET_NARGS(1),___PRM_make_2d_vector)
___DEF_SLBL(3,___L3_c_23_list_2d__3e_vect)
___SET_R2(___STK(-6))
___SET_R3(___FIX(0L))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_list_2d__3e_vect)
___GOTO(___L7_c_23_list_2d__3e_vect)
___DEF_GLBL(___L6_c_23_list_2d__3e_vect)
___SET_R4(___CAR(___R2))
___VECTORSET(___R1,___R3,___R4)
___SET_R3(___FIXADD(___R3,___FIX(1L)))
___SET_R2(___CDR(___R2))
___POLL(5)
___DEF_SLBL(5,___L5_c_23_list_2d__3e_vect)
___DEF_GLBL(___L7_c_23_list_2d__3e_vect)
___IF(___PAIRP(___R2))
___GOTO(___L6_c_23_list_2d__3e_vect)
___END_IF
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_vect_2d__3e_list
#undef ___PH_LBL0
#define ___PH_LBL0 118
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_vect_2d__3e_list)
___DEF_P_HLBL(___L1_c_23_vect_2d__3e_list)
___DEF_P_HLBL(___L2_c_23_vect_2d__3e_list)
___DEF_P_HLBL(___L3_c_23_vect_2d__3e_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_vect_2d__3e_list)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_vect_2d__3e_list)
___SET_R2(___VECTORLENGTH(___R1))
___SET_R3(___FIXSUB(___R2,___FIX(1L)))
___SET_R2(___NUL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_vect_2d__3e_list)
___GOTO(___L5_c_23_vect_2d__3e_list)
___DEF_GLBL(___L4_c_23_vect_2d__3e_list)
___SET_R4(___VECTORREF(___R1,___R3))
___SET_R2(___CONS(___R4,___R2))
___SET_R3(___FIXSUB(___R3,___FIX(1L)))
___CHECK_HEAP(2,4096)
___DEF_SLBL(2,___L2_c_23_vect_2d__3e_list)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_vect_2d__3e_list)
___DEF_GLBL(___L5_c_23_vect_2d__3e_list)
___IF(___NOT(___FIXLT(___R3,___FIX(0L))))
___GOTO(___L4_c_23_vect_2d__3e_list)
___END_IF
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_list_2d__3e_str
#undef ___PH_LBL0
#define ___PH_LBL0 123
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_list_2d__3e_str)
___DEF_P_HLBL(___L1_c_23_list_2d__3e_str)
___DEF_P_HLBL(___L2_c_23_list_2d__3e_str)
___DEF_P_HLBL(___L3_c_23_list_2d__3e_str)
___DEF_P_HLBL(___L4_c_23_list_2d__3e_str)
___DEF_P_HLBL(___L5_c_23_list_2d__3e_str)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_list_2d__3e_str)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_list_2d__3e_str)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_list_2d__3e_str)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(1),___PRC(17),___L_c_23_list_2d_length)
___DEF_SLBL(2,___L2_c_23_list_2d__3e_str)
___SET_R0(___LBL(3))
___JUMPPRM(___SET_NARGS(1),___PRM_make_2d_string)
___DEF_SLBL(3,___L3_c_23_list_2d__3e_str)
___SET_R2(___STK(-6))
___SET_R3(___FIX(0L))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_list_2d__3e_str)
___GOTO(___L7_c_23_list_2d__3e_str)
___DEF_GLBL(___L6_c_23_list_2d__3e_str)
___SET_R4(___CAR(___R2))
___STRINGSET(___R1,___R3,___R4)
___SET_R3(___FIXADD(___R3,___FIX(1L)))
___SET_R2(___CDR(___R2))
___POLL(5)
___DEF_SLBL(5,___L5_c_23_list_2d__3e_str)
___DEF_GLBL(___L7_c_23_list_2d__3e_str)
___IF(___PAIRP(___R2))
___GOTO(___L6_c_23_list_2d__3e_str)
___END_IF
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_str_2d__3e_list
#undef ___PH_LBL0
#define ___PH_LBL0 130
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_str_2d__3e_list)
___DEF_P_HLBL(___L1_c_23_str_2d__3e_list)
___DEF_P_HLBL(___L2_c_23_str_2d__3e_list)
___DEF_P_HLBL(___L3_c_23_str_2d__3e_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_str_2d__3e_list)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_str_2d__3e_list)
___SET_R2(___STRINGLENGTH(___R1))
___SET_R3(___FIXSUB(___R2,___FIX(1L)))
___SET_R2(___NUL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_str_2d__3e_list)
___GOTO(___L5_c_23_str_2d__3e_list)
___DEF_GLBL(___L4_c_23_str_2d__3e_list)
___SET_R4(___STRINGREF(___R1,___R3))
___SET_R2(___CONS(___R4,___R2))
___SET_R3(___FIXSUB(___R3,___FIX(1L)))
___CHECK_HEAP(2,4096)
___DEF_SLBL(2,___L2_c_23_str_2d__3e_list)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_str_2d__3e_list)
___DEF_GLBL(___L5_c_23_str_2d__3e_list)
___IF(___NOT(___FIXLT(___R3,___FIX(0L))))
___GOTO(___L4_c_23_str_2d__3e_list)
___END_IF
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_read_2d_line_2a_
#undef ___PH_LBL0
#define ___PH_LBL0 135
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_read_2d_line_2a_)
___DEF_P_HLBL(___L1_c_23_read_2d_line_2a_)
___DEF_P_HLBL(___L2_c_23_read_2d_line_2a_)
___DEF_P_HLBL(___L3_c_23_read_2d_line_2a_)
___DEF_P_HLBL(___L4_c_23_read_2d_line_2a_)
___DEF_P_HLBL(___L5_c_23_read_2d_line_2a_)
___DEF_P_HLBL(___L6_c_23_read_2d_line_2a_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_read_2d_line_2a_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_read_2d_line_2a_)
___SET_R2(___NUL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_read_2d_line_2a_)
___GOTO(___L8_c_23_read_2d_line_2a_)
___DEF_SLBL(2,___L2_c_23_read_2d_line_2a_)
___SET_R2(___STK(-5))
___SET_R0(___STK(-6))
___ADJFP(-7)
___IF(___EOFP(___R1))
___GOTO(___L9_c_23_read_2d_line_2a_)
___END_IF
___DEF_GLBL(___L7_c_23_read_2d_line_2a_)
___IF(___CHAREQP(___R1,___CHR(13)))
___GOTO(___L9_c_23_read_2d_line_2a_)
___END_IF
___IF(___CHAREQP(___R1,___CHR(10)))
___GOTO(___L9_c_23_read_2d_line_2a_)
___END_IF
___SET_R2(___CONS(___R1,___R2))
___SET_R1(___STK(0))
___ADJFP(-1)
___CHECK_HEAP(3,4096)
___DEF_SLBL(3,___L3_c_23_read_2d_line_2a_)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_read_2d_line_2a_)
___DEF_GLBL(___L8_c_23_read_2d_line_2a_)
___READCHAR1P(___R1)
___SET_R3(___temp)
___SET_STK(1,___R1)
___SET_R1(___R3)
___ADJFP(1)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L10_c_23_read_2d_line_2a_)
___END_IF
___IF(___NOT(___EOFP(___R1)))
___GOTO(___L7_c_23_read_2d_line_2a_)
___END_IF
___DEF_GLBL(___L9_c_23_read_2d_line_2a_)
___SET_STK(0,___R0)
___SET_R1(___R2)
___SET_R0(___LBL(5))
___ADJFP(3)
___JUMPPRM(___SET_NARGS(1),___PRM_reverse)
___DEF_SLBL(5,___L5_c_23_read_2d_line_2a_)
___SET_R0(___STK(-3))
___POLL(6)
___DEF_SLBL(6,___L6_c_23_read_2d_line_2a_)
___ADJFP(-4)
___JUMPINT(___SET_NARGS(1),___PRC(123),___L_c_23_list_2d__3e_str)
___DEF_GLBL(___L10_c_23_read_2d_line_2a_)
___SET_STK(1,___R0)
___SET_STK(2,___R2)
___SET_R1(___STK(0))
___SET_R0(___LBL(2))
___ADJFP(7)
___JUMPPRM(___SET_NARGS(1),___PRM__23__23_read_2d_char1)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_make_2d_stretchable_2d_vector
#undef ___PH_LBL0
#define ___PH_LBL0 143
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_make_2d_stretchable_2d_vector)
___DEF_P_HLBL(___L1_c_23_make_2d_stretchable_2d_vector)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_make_2d_stretchable_2d_vector)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_make_2d_stretchable_2d_vector)
___BEGIN_ALLOC_VECTOR(3UL)
___ADD_VECTOR_ELEM(0,___SUB(0))
___ADD_VECTOR_ELEM(1,___R1)
___ADD_VECTOR_ELEM(2,___FIX(0L))
___END_ALLOC_VECTOR(3)
___SET_R1(___GET_VECTOR(3))
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_make_2d_stretchable_2d_vector)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_stretchable_2d_vector_2d_length
#undef ___PH_LBL0
#define ___PH_LBL0 146
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_stretchable_2d_vector_2d_length)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_stretchable_2d_vector_2d_length)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_stretchable_2d_vector_2d_length)
___SET_R1(___VECTORREF(___R1,___FIX(2L)))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_stretchable_2d_vector_2d_ref
#undef ___PH_LBL0
#define ___PH_LBL0 148
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_stretchable_2d_vector_2d_ref)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_stretchable_2d_vector_2d_ref)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_stretchable_2d_vector_2d_ref)
___SET_R3(___VECTORREF(___R1,___FIX(0L)))
___SET_R4(___VECTORLENGTH(___R3))
___IF(___NOT(___FIXLT(___R2,___R4)))
___GOTO(___L1_c_23_stretchable_2d_vector_2d_ref)
___END_IF
___SET_R1(___VECTORREF(___R3,___R2))
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L1_c_23_stretchable_2d_vector_2d_ref)
___SET_R1(___VECTORREF(___R1,___FIX(1L)))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_stretchable_2d_vector_2d_set_21_
#undef ___PH_LBL0
#define ___PH_LBL0 150
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_stretchable_2d_vector_2d_set_21_)
___DEF_P_HLBL(___L1_c_23_stretchable_2d_vector_2d_set_21_)
___DEF_P_HLBL(___L2_c_23_stretchable_2d_vector_2d_set_21_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_stretchable_2d_vector_2d_set_21_)
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,3,0,0)
___DEF_GLBL(___L_c_23_stretchable_2d_vector_2d_set_21_)
___SET_R4(___VECTORREF(___R1,___FIX(0L)))
___SET_STK(1,___VECTORLENGTH(___R4))
___SET_STK(2,___VECTORREF(___R1,___FIX(2L)))
___ADJFP(2)
___IF(___NOT(___FIXLT(___R2,___STK(0))))
___GOTO(___L3_c_23_stretchable_2d_vector_2d_set_21_)
___END_IF
___IF(___FIXLT(___R2,___STK(-1)))
___GOTO(___L5_c_23_stretchable_2d_vector_2d_set_21_)
___END_IF
___GOTO(___L4_c_23_stretchable_2d_vector_2d_set_21_)
___DEF_GLBL(___L3_c_23_stretchable_2d_vector_2d_set_21_)
___SET_STK(0,___FIXADD(___R2,___FIX(1L)))
___VECTORSET(___R1,___FIX(2L),___STK(0))
___IF(___FIXLT(___R2,___STK(-1)))
___GOTO(___L5_c_23_stretchable_2d_vector_2d_set_21_)
___END_IF
___DEF_GLBL(___L4_c_23_stretchable_2d_vector_2d_set_21_)
___SET_STK(0,___R0)
___SET_STK(1,___R1)
___SET_STK(2,___R2)
___SET_STK(3,___R3)
___SET_R1(___FIXMUL(___STK(-1),___FIX(3L)))
___SET_R1(___FIXQUO(___R1,___FIX(2L)))
___SET_R1(___FIXMAX(___R2,___R1))
___SET_R2(___FIXADD(___R1,___FIX(1L)))
___SET_R3(___VECTORREF(___STK(1),___FIX(1L)))
___SET_R1(___R4)
___ADJFP(6)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_stretchable_2d_vector_2d_set_21_)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(3),___PRC(154),___L_c_23_stretch_2d_vector)
___DEF_SLBL(2,___L2_c_23_stretchable_2d_vector_2d_set_21_)
___VECTORSET(___STK(-5),___FIX(0L),___R1)
___VECTORSET(___R1,___STK(-4),___STK(-3))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(2))
___DEF_GLBL(___L5_c_23_stretchable_2d_vector_2d_set_21_)
___VECTORSET(___R4,___R2,___R3) ___SET_R1(___R4)
___ADJFP(-2)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_stretch_2d_vector
#undef ___PH_LBL0
#define ___PH_LBL0 154
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_stretch_2d_vector)
___DEF_P_HLBL(___L1_c_23_stretch_2d_vector)
___DEF_P_HLBL(___L2_c_23_stretch_2d_vector)
___DEF_P_HLBL(___L3_c_23_stretch_2d_vector)
___DEF_P_HLBL(___L4_c_23_stretch_2d_vector)
___DEF_P_HLBL(___L5_c_23_stretch_2d_vector)
___DEF_P_HLBL(___L6_c_23_stretch_2d_vector)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_stretch_2d_vector)
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,3,0,0)
___DEF_GLBL(___L_c_23_stretch_2d_vector)
___SET_R4(___VECTORLENGTH(___R1))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_STK(5,___R4)
___SET_R1(___R2)
___SET_R0(___LBL(1))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_make_2d_vector)
___DEF_SLBL(1,___L1_c_23_stretch_2d_vector)
___SET_STK(-2,___R1)
___SET_STK(5,___STK(-6))
___SET_R2(___STK(-3))
___SET_R3(___FIX(0L))
___SET_R0(___LBL(4))
___ADJFP(5)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_stretch_2d_vector)
___GOTO(___L8_c_23_stretch_2d_vector)
___DEF_GLBL(___L7_c_23_stretch_2d_vector)
___SET_R4(___VECTORREF(___STK(0),___R3))
___VECTORSET(___R1,___R3,___R4)
___SET_R3(___FIXADD(___R3,___FIX(1L)))
___POLL(3)
___DEF_SLBL(3,___L3_c_23_stretch_2d_vector)
___DEF_GLBL(___L8_c_23_stretch_2d_vector)
___IF(___FIXLT(___R3,___R2))
___GOTO(___L7_c_23_stretch_2d_vector)
___END_IF
___DEF_GLBL(___L9_c_23_stretch_2d_vector)
___SET_R1(___VOID)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(4,___L4_c_23_stretch_2d_vector)
___SET_STK(1,___STK(-9))
___SET_R3(___STK(-7))
___SET_R2(___STK(-6))
___SET_R1(___STK(-8))
___SET_R0(___LBL(6))
___ADJFP(1)
___IF(___FIXLT(___R3,___STK(0)))
___GOTO(___L11_c_23_stretch_2d_vector)
___END_IF
___GOTO(___L9_c_23_stretch_2d_vector)
___DEF_GLBL(___L10_c_23_stretch_2d_vector)
___IF(___NOT(___FIXLT(___R3,___STK(0))))
___GOTO(___L9_c_23_stretch_2d_vector)
___END_IF
___DEF_GLBL(___L11_c_23_stretch_2d_vector)
___VECTORSET(___R2,___R3,___R1)
___SET_R3(___FIXADD(___R3,___FIX(1L)))
___POLL(5)
___DEF_SLBL(5,___L5_c_23_stretch_2d_vector)
___GOTO(___L10_c_23_stretch_2d_vector)
___DEF_SLBL(6,___L6_c_23_stretch_2d_vector)
___SET_R1(___STK(-6))
___ADJFP(-12)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_stretchable_2d_vector_2d_copy
#undef ___PH_LBL0
#define ___PH_LBL0 162
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_stretchable_2d_vector_2d_copy)
___DEF_P_HLBL(___L1_c_23_stretchable_2d_vector_2d_copy)
___DEF_P_HLBL(___L2_c_23_stretchable_2d_vector_2d_copy)
___DEF_P_HLBL(___L3_c_23_stretchable_2d_vector_2d_copy)
___DEF_P_HLBL(___L4_c_23_stretchable_2d_vector_2d_copy)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_stretchable_2d_vector_2d_copy)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_stretchable_2d_vector_2d_copy)
___SET_R2(___VECTORREF(___R1,___FIX(0L)))
___SET_R3(___VECTORREF(___R1,___FIX(2L)))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R3)
___SET_R0(___LBL(1))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_make_2d_vector)
___DEF_SLBL(1,___L1_c_23_stretchable_2d_vector_2d_copy)
___SET_STK(-3,___STK(-7))
___SET_STK(-7,___STK(-6))
___SET_STK(-6,___STK(-5))
___SET_R2(___R1)
___SET_R3(___FIXSUB(___STK(-4),___FIX(1L)))
___SET_R1(___STK(-4))
___SET_R0(___STK(-3))
___ADJFP(-6)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_stretchable_2d_vector_2d_copy)
___GOTO(___L6_c_23_stretchable_2d_vector_2d_copy)
___DEF_GLBL(___L5_c_23_stretchable_2d_vector_2d_copy)
___SET_R4(___VECTORREF(___STK(0),___R3))
___VECTORSET(___R2,___R3,___R4)
___SET_R3(___FIXSUB(___R3,___FIX(1L)))
___POLL(3)
___DEF_SLBL(3,___L3_c_23_stretchable_2d_vector_2d_copy)
___DEF_GLBL(___L6_c_23_stretchable_2d_vector_2d_copy)
___IF(___FIXGE(___R3,___FIX(0L)))
___GOTO(___L5_c_23_stretchable_2d_vector_2d_copy)
___END_IF
___SET_R3(___VECTORREF(___STK(-1),___FIX(1L)))
___BEGIN_ALLOC_VECTOR(3UL)
___ADD_VECTOR_ELEM(0,___R2)
___ADD_VECTOR_ELEM(1,___R3)
___ADD_VECTOR_ELEM(2,___R1)
___END_ALLOC_VECTOR(3)
___SET_R1(___GET_VECTOR(3))
___ADJFP(-2)
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4_c_23_stretchable_2d_vector_2d_copy)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_stretchable_2d_vector_2d_for_2d_each
#undef ___PH_LBL0
#define ___PH_LBL0 168
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_P_HLBL(___L1_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_P_HLBL(___L2_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_P_HLBL(___L3_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_P_HLBL(___L4_c_23_stretchable_2d_vector_2d_for_2d_each)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_stretchable_2d_vector_2d_for_2d_each)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_stretchable_2d_vector_2d_for_2d_each)
___SET_R3(___VECTORREF(___R2,___FIX(0L)))
___SET_R2(___VECTORREF(___R2,___FIX(2L)))
___SET_STK(1,___R1)
___SET_STK(2,___R2)
___SET_R2(___R3)
___SET_R1(___STK(2))
___SET_R3(___FIX(0L))
___ADJFP(1)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_stretchable_2d_vector_2d_for_2d_each)
___GOTO(___L5_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_SLBL(2,___L2_c_23_stretchable_2d_vector_2d_for_2d_each)
___SET_R3(___FIXADD(___STK(-3),___FIX(1L)))
___SET_R2(___STK(-4))
___SET_R1(___STK(-5))
___SET_R0(___STK(-6))
___ADJFP(-7)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_stretchable_2d_vector_2d_for_2d_each)
___DEF_GLBL(___L5_c_23_stretchable_2d_vector_2d_for_2d_each)
___IF(___NOT(___FIXLT(___R3,___R1)))
___GOTO(___L6_c_23_stretchable_2d_vector_2d_for_2d_each)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___VECTORREF(___R2,___R3))
___SET_R2(___R3)
___ADJFP(7)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_stretchable_2d_vector_2d_for_2d_each)
___SET_R0(___LBL(2))
___JUMPGENNOTSAFE(___SET_NARGS(2),___STK(-7))
___DEF_GLBL(___L6_c_23_stretchable_2d_vector_2d_for_2d_each)
___SET_R1(___VOID)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_stretchable_2d_vector_2d__3e_list
#undef ___PH_LBL0
#define ___PH_LBL0 174
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_stretchable_2d_vector_2d__3e_list)
___DEF_P_HLBL(___L1_c_23_stretchable_2d_vector_2d__3e_list)
___DEF_P_HLBL(___L2_c_23_stretchable_2d_vector_2d__3e_list)
___DEF_P_HLBL(___L3_c_23_stretchable_2d_vector_2d__3e_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_stretchable_2d_vector_2d__3e_list)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_stretchable_2d_vector_2d__3e_list)
___SET_R2(___VECTORREF(___R1,___FIX(0L)))
___SET_R1(___VECTORREF(___R1,___FIX(2L)))
___SET_R1(___FIXSUB(___R1,___FIX(1L)))
___SET_STK(1,___R2)
___SET_R2(___R1)
___SET_R1(___STK(1))
___SET_R3(___NUL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_stretchable_2d_vector_2d__3e_list)
___GOTO(___L5_c_23_stretchable_2d_vector_2d__3e_list)
___DEF_GLBL(___L4_c_23_stretchable_2d_vector_2d__3e_list)
___SET_R4(___VECTORREF(___R1,___R2))
___SET_R3(___CONS(___R4,___R3))
___SET_R2(___FIXSUB(___R2,___FIX(1L)))
___CHECK_HEAP(2,4096)
___DEF_SLBL(2,___L2_c_23_stretchable_2d_vector_2d__3e_list)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_stretchable_2d_vector_2d__3e_list)
___DEF_GLBL(___L5_c_23_stretchable_2d_vector_2d__3e_list)
___IF(___NOT(___FIXLT(___R2,___FIX(0L))))
___GOTO(___L4_c_23_stretchable_2d_vector_2d__3e_list)
___END_IF
___SET_R1(___R3)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_make_2d_ordered_2d_table
#undef ___PH_LBL0
#define ___PH_LBL0 179
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_make_2d_ordered_2d_table)
___DEF_P_HLBL(___L1_c_23_make_2d_ordered_2d_table)
___DEF_P_HLBL(___L2_c_23_make_2d_ordered_2d_table)
___DEF_P_HLBL(___L3_c_23_make_2d_ordered_2d_table)
___DEF_P_HLBL(___L4_c_23_make_2d_ordered_2d_table)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_make_2d_ordered_2d_table)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_make_2d_ordered_2d_table)
___SET_STK(1,___R0)
___SET_R2(___R1)
___SET_R1(___KEY_test)
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_make_2d_ordered_2d_table)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(2),105,___G_make_2d_table)
___DEF_SLBL(2,___L2_c_23_make_2d_ordered_2d_table)
___SET_STK(-2,___R1)
___SET_R1(___FAL)
___SET_R0(___LBL(3))
___ADJFP(4)
___JUMPINT(___SET_NARGS(1),___PRC(143),___L_c_23_make_2d_stretchable_2d_vector)
___DEF_SLBL(3,___L3_c_23_make_2d_ordered_2d_table)
___BEGIN_ALLOC_VECTOR(3UL)
___ADD_VECTOR_ELEM(0,___STK(-6))
___ADD_VECTOR_ELEM(1,___R1)
___ADD_VECTOR_ELEM(2,___FIX(0L))
___END_ALLOC_VECTOR(3)
___SET_R1(___GET_VECTOR(3))
___ADJFP(-7)
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4_c_23_make_2d_ordered_2d_table)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ordered_2d_table_2d_length
#undef ___PH_LBL0
#define ___PH_LBL0 185
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ordered_2d_table_2d_length)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ordered_2d_table_2d_length)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_ordered_2d_table_2d_length)
___SET_R1(___VECTORREF(___R1,___FIX(2L)))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ordered_2d_table_2d_index
#undef ___PH_LBL0
#define ___PH_LBL0 187
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R1 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R1 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ordered_2d_table_2d_index)
___DEF_P_HLBL(___L1_c_23_ordered_2d_table_2d_index)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ordered_2d_table_2d_index)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_ordered_2d_table_2d_index)
___SET_R1(___VECTORREF(___R1,___FIX(0L)))
___SET_R3(___FAL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ordered_2d_table_2d_index)
___JUMPGLONOTSAFE(___SET_NARGS(3),109,___G_table_2d_ref)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ordered_2d_table_2d_lookup
#undef ___PH_LBL0
#define ___PH_LBL0 190
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ordered_2d_table_2d_lookup)
___DEF_P_HLBL(___L1_c_23_ordered_2d_table_2d_lookup)
___DEF_P_HLBL(___L2_c_23_ordered_2d_table_2d_lookup)
___DEF_P_HLBL(___L3_c_23_ordered_2d_table_2d_lookup)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ordered_2d_table_2d_lookup)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_ordered_2d_table_2d_lookup)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___VECTORREF(___R1,___FIX(0L)))
___SET_R3(___FAL)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ordered_2d_table_2d_lookup)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(3),109,___G_table_2d_ref)
___DEF_SLBL(2,___L2_c_23_ordered_2d_table_2d_lookup)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L4_c_23_ordered_2d_table_2d_lookup)
___END_IF
___SET_R2(___R1)
___SET_R1(___VECTORREF(___STK(-6),___FIX(1L)))
___SET_R0(___LBL(3))
___ADJFP(-4)
___JUMPINT(___SET_NARGS(2),___PRC(148),___L_c_23_stretchable_2d_vector_2d_ref)
___DEF_SLBL(3,___L3_c_23_ordered_2d_table_2d_lookup)
___SET_R1(___CDR(___R1))
___ADJFP(-4)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L4_c_23_ordered_2d_table_2d_lookup)
___SET_R1(___FAL)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ordered_2d_table_2d_enter
#undef ___PH_LBL0
#define ___PH_LBL0 195
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ordered_2d_table_2d_enter)
___DEF_P_HLBL(___L1_c_23_ordered_2d_table_2d_enter)
___DEF_P_HLBL(___L2_c_23_ordered_2d_table_2d_enter)
___DEF_P_HLBL(___L3_c_23_ordered_2d_table_2d_enter)
___DEF_P_HLBL(___L4_c_23_ordered_2d_table_2d_enter)
___DEF_P_HLBL(___L5_c_23_ordered_2d_table_2d_enter)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ordered_2d_table_2d_enter)
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,3,0,0)
___DEF_GLBL(___L_c_23_ordered_2d_table_2d_enter)
___SET_R4(___VECTORREF(___R1,___FIX(2L)))
___SET_STK(1,___FIXADD(___R4,___FIX(1L)))
___VECTORSET(___R1,___FIX(2L),___STK(1))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_STK(5,___R4)
___SET_R3(___R4)
___SET_R1(___VECTORREF(___R1,___FIX(0L)))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ordered_2d_table_2d_enter)
___SET_R0(___LBL(2))
___JUMPGLONOTSAFE(___SET_NARGS(3),110,___G_table_2d_set_21_)
___DEF_SLBL(2,___L2_c_23_ordered_2d_table_2d_enter)
___SET_R2(___STK(-3))
___SET_R1(___STK(-5))
___SET_R0(___LBL(3))
___JUMPGENNOTSAFE(___SET_NARGS(2),___STK(-4))
___DEF_SLBL(3,___L3_c_23_ordered_2d_table_2d_enter)
___SET_STK(-4,___R1)
___SET_R3(___CONS(___STK(-5),___R1))
___SET_R2(___STK(-3))
___SET_R1(___VECTORREF(___STK(-6),___FIX(1L)))
___SET_R0(___LBL(5))
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4_c_23_ordered_2d_table_2d_enter)
___JUMPINT(___SET_NARGS(3),___PRC(150),___L_c_23_stretchable_2d_vector_2d_set_21_)
___DEF_SLBL(5,___L5_c_23_ordered_2d_table_2d_enter)
___SET_R1(___STK(-4))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ordered_2d_table_2d__3e_list
#undef ___PH_LBL0
#define ___PH_LBL0 202
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ordered_2d_table_2d__3e_list)
___DEF_P_HLBL(___L1_c_23_ordered_2d_table_2d__3e_list)
___DEF_P_HLBL(___L2_c_23_ordered_2d_table_2d__3e_list)
___DEF_P_HLBL(___L3_c_23_ordered_2d_table_2d__3e_list)
___DEF_P_HLBL(___L4_c_23_ordered_2d_table_2d__3e_list)
___DEF_P_HLBL(___L5_c_23_ordered_2d_table_2d__3e_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ordered_2d_table_2d__3e_list)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_ordered_2d_table_2d__3e_list)
___SET_R2(___VECTORREF(___R1,___FIX(2L)))
___SET_R2(___FIXSUB(___R2,___FIX(1L)))
___SET_R3(___NUL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ordered_2d_table_2d__3e_list)
___GOTO(___L6_c_23_ordered_2d_table_2d__3e_list)
___DEF_SLBL(2,___L2_c_23_ordered_2d_table_2d__3e_list)
___SET_R3(___CONS(___R1,___STK(-4)))
___SET_R2(___FIXSUB(___STK(-5),___FIX(1L)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___CHECK_HEAP(3,4096)
___DEF_SLBL(3,___L3_c_23_ordered_2d_table_2d__3e_list)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_ordered_2d_table_2d__3e_list)
___DEF_GLBL(___L6_c_23_ordered_2d_table_2d__3e_list)
___IF(___FIXLT(___R2,___FIX(0L)))
___GOTO(___L7_c_23_ordered_2d_table_2d__3e_list)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___VECTORREF(___R1,___FIX(1L)))
___ADJFP(8)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_ordered_2d_table_2d__3e_list)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(148),___L_c_23_stretchable_2d_vector_2d_ref)
___DEF_GLBL(___L7_c_23_ordered_2d_table_2d__3e_list)
___SET_R1(___R3)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_bits_2d_and
#undef ___PH_LBL0
#define ___PH_LBL0 209
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_bits_2d_and)
___DEF_P_HLBL(___L1_c_23_bits_2d_and)
___DEF_P_HLBL(___L2_c_23_bits_2d_and)
___DEF_P_HLBL(___L3_c_23_bits_2d_and)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_bits_2d_and)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_bits_2d_and)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_bits_2d_and)
___GOTO(___L5_c_23_bits_2d_and)
___DEF_GLBL(___L4_c_23_bits_2d_and)
___IF(___FIXEQ(___R2,___FIX(0L)))
___GOTO(___L6_c_23_bits_2d_and)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___FIXQUO(___R2,___FIX(2L)))
___SET_R1(___FIXQUO(___R1,___FIX(2L)))
___SET_R0(___LBL(3))
___ADJFP(8)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_bits_2d_and)
___DEF_GLBL(___L5_c_23_bits_2d_and)
___IF(___NOT(___FIXEQ(___R1,___FIX(0L))))
___GOTO(___L4_c_23_bits_2d_and)
___END_IF
___DEF_GLBL(___L6_c_23_bits_2d_and)
___SET_R1(___FIX(0L))
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(3,___L3_c_23_bits_2d_and)
___SET_R1(___FIXMUL(___R1,___FIX(2L)))
___IF(___NOT(___FIXODDP(___STK(-6))))
___GOTO(___L7_c_23_bits_2d_and)
___END_IF
___IF(___NOT(___FIXODDP(___STK(-5))))
___GOTO(___L7_c_23_bits_2d_and)
___END_IF
___SET_R1(___FIXADD(___R1,___FIX(1L)))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L7_c_23_bits_2d_and)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_bits_2d_or
#undef ___PH_LBL0
#define ___PH_LBL0 214
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_bits_2d_or)
___DEF_P_HLBL(___L1_c_23_bits_2d_or)
___DEF_P_HLBL(___L2_c_23_bits_2d_or)
___DEF_P_HLBL(___L3_c_23_bits_2d_or)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_bits_2d_or)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_bits_2d_or)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_bits_2d_or)
___GOTO(___L5_c_23_bits_2d_or)
___DEF_GLBL(___L4_c_23_bits_2d_or)
___IF(___FIXEQ(___R2,___FIX(0L)))
___GOTO(___L6_c_23_bits_2d_or)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___FIXQUO(___R2,___FIX(2L)))
___SET_R1(___FIXQUO(___R1,___FIX(2L)))
___SET_R0(___LBL(3))
___ADJFP(8)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_bits_2d_or)
___DEF_GLBL(___L5_c_23_bits_2d_or)
___IF(___NOT(___FIXEQ(___R1,___FIX(0L))))
___GOTO(___L4_c_23_bits_2d_or)
___END_IF
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L6_c_23_bits_2d_or)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(3,___L3_c_23_bits_2d_or)
___SET_R1(___FIXMUL(___R1,___FIX(2L)))
___IF(___FIXODDP(___STK(-6)))
___GOTO(___L7_c_23_bits_2d_or)
___END_IF
___IF(___NOT(___FIXODDP(___STK(-5))))
___GOTO(___L8_c_23_bits_2d_or)
___END_IF
___DEF_GLBL(___L7_c_23_bits_2d_or)
___SET_R1(___FIXADD(___R1,___FIX(1L)))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L8_c_23_bits_2d_or)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_bits_2d_shl
#undef ___PH_LBL0
#define ___PH_LBL0 219
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_bits_2d_shl)
___DEF_P_HLBL(___L1_c_23_bits_2d_shl)
___DEF_P_HLBL(___L2_c_23_bits_2d_shl)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_bits_2d_shl)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_bits_2d_shl)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_bits_2d_shl)
___GOTO(___L4_c_23_bits_2d_shl)
___DEF_GLBL(___L3_c_23_bits_2d_shl)
___SET_R2(___FIXSUB(___R2,___FIX(1L)))
___SET_R1(___FIXMUL(___R1,___FIX(2L)))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_bits_2d_shl)
___DEF_GLBL(___L4_c_23_bits_2d_shl)
___IF(___FIXGT(___R2,___FIX(0L)))
___GOTO(___L3_c_23_bits_2d_shl)
___END_IF
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_bits_2d_shr
#undef ___PH_LBL0
#define ___PH_LBL0 223
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_bits_2d_shr)
___DEF_P_HLBL(___L1_c_23_bits_2d_shr)
___DEF_P_HLBL(___L2_c_23_bits_2d_shr)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_bits_2d_shr)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_bits_2d_shr)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_bits_2d_shr)
___GOTO(___L4_c_23_bits_2d_shr)
___DEF_GLBL(___L3_c_23_bits_2d_shr)
___SET_R2(___FIXSUB(___R2,___FIX(1L)))
___SET_R1(___FIXQUO(___R1,___FIX(2L)))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_bits_2d_shr)
___DEF_GLBL(___L4_c_23_bits_2d_shr)
___IF(___FIXGT(___R2,___FIX(0L)))
___GOTO(___L3_c_23_bits_2d_shr)
___END_IF
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_with_2d_exception_2d_handling
#undef ___PH_LBL0
#define ___PH_LBL0 227
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_with_2d_exception_2d_handling)
___DEF_P_HLBL(___L1_c_23_with_2d_exception_2d_handling)
___DEF_P_HLBL(___L2_c_23_with_2d_exception_2d_handling)
___DEF_P_HLBL(___L3_c_23_with_2d_exception_2d_handling)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_with_2d_exception_2d_handling)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_with_2d_exception_2d_handling)
___SET_STK(1,___GLO_c_23_throw_2d_to_2d_exception_2d_handler)
___SET_STK(2,___R0)
___SET_STK(3,___R1)
___SET_R1(___LBL(2))
___SET_R2(___STK(3))
___SET_R0(___LBL(1))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(2),___PRM__23__23_call_2d_with_2d_current_2d_continuation)
___DEF_SLBL(1,___L1_c_23_with_2d_exception_2d_handling)
___SET_GLO(68,___G_c_23_throw_2d_to_2d_exception_2d_handler,___STK(-7))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(2))
___DEF_SLBL(2,___L2_c_23_with_2d_exception_2d_handling)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(2,2,0,0)
___SET_GLO(68,___G_c_23_throw_2d_to_2d_exception_2d_handler,___R1)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_with_2d_exception_2d_handling)
___JUMPGENNOTSAFE(___SET_NARGS(0),___R2)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_compiler_2d_error
#undef ___PH_LBL0
#define ___PH_LBL0 232
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_compiler_2d_error)
___DEF_P_HLBL(___L1_c_23_compiler_2d_error)
___DEF_P_HLBL(___L2_c_23_compiler_2d_error)
___DEF_P_HLBL(___L3_c_23_compiler_2d_error)
___DEF_P_HLBL(___L4_c_23_compiler_2d_error)
___DEF_P_HLBL(___L5_c_23_compiler_2d_error)
___DEF_P_HLBL(___L6_c_23_compiler_2d_error)
___DEF_P_HLBL(___L7_c_23_compiler_2d_error)
___DEF_P_HLBL(___L8_c_23_compiler_2d_error)
___DEF_P_HLBL(___L9_c_23_compiler_2d_error)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_compiler_2d_error)
___IF_NARGS_EQ(1,___SET_R2(___NUL))
___GET_REST(0,1,0,0)
___DEF_GLBL(___L_c_23_compiler_2d_error)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___SUB(1))
___SET_R0(___LBL(1))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(1,___L1_c_23_compiler_2d_error)
___SET_R1(___STK(-6))
___SET_R0(___LBL(2))
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(2,___L2_c_23_compiler_2d_error)
___SET_R1(___STK(-5))
___SET_R0(___LBL(7))
___ADJFP(-4)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_compiler_2d_error)
___GOTO(___L10_c_23_compiler_2d_error)
___DEF_SLBL(4,___L4_c_23_compiler_2d_error)
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_compiler_2d_error)
___DEF_GLBL(___L10_c_23_compiler_2d_error)
___IF(___NOT(___PAIRP(___R1)))
___GOTO(___L11_c_23_compiler_2d_error)
___END_IF
___SET_R2(___CAR(___R1))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___SUB(2))
___SET_R0(___LBL(6))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(6,___L6_c_23_compiler_2d_error)
___SET_R1(___STK(-5))
___SET_R0(___LBL(4))
___JUMPPRM(___SET_NARGS(1),___PRM_write)
___DEF_GLBL(___L11_c_23_compiler_2d_error)
___SET_R1(___VOID)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(7,___L7_c_23_compiler_2d_error)
___SET_R0(___LBL(8))
___JUMPPRM(___SET_NARGS(0),___PRM__23__23_newline0)
___DEF_SLBL(8,___L8_c_23_compiler_2d_error)
___SET_R0(___STK(-3))
___POLL(9)
___DEF_SLBL(9,___L9_c_23_compiler_2d_error)
___ADJFP(-4)
___JUMPINT(___SET_NARGS(0),___PRC(294),___L_c_23_compiler_2d_abort)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_compiler_2d_user_2d_error
#undef ___PH_LBL0
#define ___PH_LBL0 243
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L1_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L2_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L3_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L4_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L5_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L6_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L7_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L8_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L9_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L10_c_23_compiler_2d_user_2d_error)
___DEF_P_HLBL(___L11_c_23_compiler_2d_user_2d_error)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_compiler_2d_user_2d_error)
___IF_NARGS_EQ(2,___SET_R3(___NUL))
___GET_REST(0,2,0,0)
___DEF_GLBL(___L_c_23_compiler_2d_user_2d_error)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___SUB(3))
___SET_R0(___LBL(1))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(1,___L1_c_23_compiler_2d_user_2d_error)
___SET_R2(___STK(-6))
___SET_R1(___SUB(4))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_compiler_2d_user_2d_error)
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),101,___G_c_23_locat_2d_show)
___DEF_SLBL(3,___L3_c_23_compiler_2d_user_2d_error)
___SET_R1(___SUB(5))
___SET_R0(___LBL(4))
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(4,___L4_c_23_compiler_2d_user_2d_error)
___SET_R1(___STK(-5))
___SET_R0(___LBL(5))
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(5,___L5_c_23_compiler_2d_user_2d_error)
___SET_R1(___STK(-4))
___SET_R0(___LBL(9))
___ADJFP(-4)
___IF(___PAIRP(___R1))
___GOTO(___L12_c_23_compiler_2d_user_2d_error)
___END_IF
___GOTO(___L13_c_23_compiler_2d_user_2d_error)
___DEF_SLBL(6,___L6_c_23_compiler_2d_user_2d_error)
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_compiler_2d_user_2d_error)
___IF(___NOT(___PAIRP(___R1)))
___GOTO(___L13_c_23_compiler_2d_user_2d_error)
___END_IF
___DEF_GLBL(___L12_c_23_compiler_2d_user_2d_error)
___SET_R2(___CAR(___R1))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___SUB(6))
___SET_R0(___LBL(8))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(8,___L8_c_23_compiler_2d_user_2d_error)
___SET_R1(___STK(-5))
___SET_R0(___LBL(6))
___JUMPPRM(___SET_NARGS(1),___PRM_write)
___DEF_GLBL(___L13_c_23_compiler_2d_user_2d_error)
___SET_R1(___VOID)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(9,___L9_c_23_compiler_2d_user_2d_error)
___SET_R0(___LBL(10))
___JUMPPRM(___SET_NARGS(0),___PRM__23__23_newline0)
___DEF_SLBL(10,___L10_c_23_compiler_2d_user_2d_error)
___SET_R0(___STK(-3))
___POLL(11)
___DEF_SLBL(11,___L11_c_23_compiler_2d_user_2d_error)
___ADJFP(-4)
___JUMPINT(___SET_NARGS(0),___PRC(294),___L_c_23_compiler_2d_abort)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_compiler_2d_user_2d_warning
#undef ___PH_LBL0
#define ___PH_LBL0 256
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L1_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L2_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L3_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L4_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L5_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L6_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L7_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L8_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L9_c_23_compiler_2d_user_2d_warning)
___DEF_P_HLBL(___L10_c_23_compiler_2d_user_2d_warning)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_compiler_2d_user_2d_warning)
___IF_NARGS_EQ(2,___SET_R3(___NUL))
___GET_REST(0,2,0,0)
___DEF_GLBL(___L_c_23_compiler_2d_user_2d_warning)
___IF(___NOT(___NOTFALSEP(___GLO_c_23_warnings_2d_requested_3f_)))
___GOTO(___L12_c_23_compiler_2d_user_2d_warning)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___SUB(7))
___SET_R0(___LBL(1))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(1,___L1_c_23_compiler_2d_user_2d_warning)
___SET_R2(___STK(-6))
___SET_R1(___SUB(8))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_compiler_2d_user_2d_warning)
___SET_R0(___LBL(3))
___JUMPGLONOTSAFE(___SET_NARGS(2),101,___G_c_23_locat_2d_show)
___DEF_SLBL(3,___L3_c_23_compiler_2d_user_2d_warning)
___SET_R1(___SUB(9))
___SET_R0(___LBL(4))
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(4,___L4_c_23_compiler_2d_user_2d_warning)
___SET_R1(___STK(-5))
___SET_R0(___LBL(5))
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(5,___L5_c_23_compiler_2d_user_2d_warning)
___SET_R1(___STK(-4))
___SET_R0(___LBL(9))
___ADJFP(-4)
___IF(___PAIRP(___R1))
___GOTO(___L11_c_23_compiler_2d_user_2d_warning)
___END_IF
___GOTO(___L12_c_23_compiler_2d_user_2d_warning)
___DEF_SLBL(6,___L6_c_23_compiler_2d_user_2d_warning)
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_compiler_2d_user_2d_warning)
___IF(___NOT(___PAIRP(___R1)))
___GOTO(___L12_c_23_compiler_2d_user_2d_warning)
___END_IF
___DEF_GLBL(___L11_c_23_compiler_2d_user_2d_warning)
___SET_R2(___CAR(___R1))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___SUB(10))
___SET_R0(___LBL(8))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(8,___L8_c_23_compiler_2d_user_2d_warning)
___SET_R1(___STK(-5))
___SET_R0(___LBL(6))
___JUMPPRM(___SET_NARGS(1),___PRM_write)
___DEF_GLBL(___L12_c_23_compiler_2d_user_2d_warning)
___SET_R1(___VOID)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(9,___L9_c_23_compiler_2d_user_2d_warning)
___SET_R0(___STK(-3))
___POLL(10)
___DEF_SLBL(10,___L10_c_23_compiler_2d_user_2d_warning)
___ADJFP(-4)
___JUMPPRM(___SET_NARGS(0),___PRM__23__23_newline0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_compiler_2d_internal_2d_error
#undef ___PH_LBL0
#define ___PH_LBL0 268
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L1_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L2_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L3_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L4_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L5_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L6_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L7_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L8_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L9_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L10_c_23_compiler_2d_internal_2d_error)
___DEF_P_HLBL(___L11_c_23_compiler_2d_internal_2d_error)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_compiler_2d_internal_2d_error)
___IF_NARGS_EQ(1,___SET_R2(___NUL))
___GET_REST(0,1,0,0)
___DEF_GLBL(___L_c_23_compiler_2d_internal_2d_error)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___SUB(11))
___SET_R0(___LBL(1))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(1,___L1_c_23_compiler_2d_internal_2d_error)
___SET_R0(___LBL(2))
___JUMPPRM(___SET_NARGS(0),___PRM__23__23_newline0)
___DEF_SLBL(2,___L2_c_23_compiler_2d_internal_2d_error)
___SET_R1(___SUB(12))
___SET_R0(___LBL(3))
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(3,___L3_c_23_compiler_2d_internal_2d_error)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(4,___L4_c_23_compiler_2d_internal_2d_error)
___SET_R1(___STK(-5))
___SET_R0(___LBL(9))
___ADJFP(-4)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_compiler_2d_internal_2d_error)
___GOTO(___L12_c_23_compiler_2d_internal_2d_error)
___DEF_SLBL(6,___L6_c_23_compiler_2d_internal_2d_error)
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_compiler_2d_internal_2d_error)
___DEF_GLBL(___L12_c_23_compiler_2d_internal_2d_error)
___IF(___NOT(___PAIRP(___R1)))
___GOTO(___L13_c_23_compiler_2d_internal_2d_error)
___END_IF
___SET_R2(___CAR(___R1))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___SUB(13))
___SET_R0(___LBL(8))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(8,___L8_c_23_compiler_2d_internal_2d_error)
___SET_R1(___STK(-5))
___SET_R0(___LBL(6))
___JUMPPRM(___SET_NARGS(1),___PRM_write)
___DEF_GLBL(___L13_c_23_compiler_2d_internal_2d_error)
___SET_R1(___VOID)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(9,___L9_c_23_compiler_2d_internal_2d_error)
___SET_R0(___LBL(10))
___JUMPPRM(___SET_NARGS(0),___PRM__23__23_newline0)
___DEF_SLBL(10,___L10_c_23_compiler_2d_internal_2d_error)
___SET_R0(___STK(-3))
___POLL(11)
___DEF_SLBL(11,___L11_c_23_compiler_2d_internal_2d_error)
___ADJFP(-4)
___JUMPINT(___SET_NARGS(0),___PRC(294),___L_c_23_compiler_2d_abort)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_compiler_2d_limitation_2d_error
#undef ___PH_LBL0
#define ___PH_LBL0 281
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L1_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L2_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L3_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L4_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L5_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L6_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L7_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L8_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L9_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L10_c_23_compiler_2d_limitation_2d_error)
___DEF_P_HLBL(___L11_c_23_compiler_2d_limitation_2d_error)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_compiler_2d_limitation_2d_error)
___IF_NARGS_EQ(1,___SET_R2(___NUL))
___GET_REST(0,1,0,0)
___DEF_GLBL(___L_c_23_compiler_2d_limitation_2d_error)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___SUB(14))
___SET_R0(___LBL(1))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(1,___L1_c_23_compiler_2d_limitation_2d_error)
___SET_R0(___LBL(2))
___JUMPPRM(___SET_NARGS(0),___PRM__23__23_newline0)
___DEF_SLBL(2,___L2_c_23_compiler_2d_limitation_2d_error)
___SET_R1(___SUB(15))
___SET_R0(___LBL(3))
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(3,___L3_c_23_compiler_2d_limitation_2d_error)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(4,___L4_c_23_compiler_2d_limitation_2d_error)
___SET_R1(___STK(-5))
___SET_R0(___LBL(9))
___ADJFP(-4)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_compiler_2d_limitation_2d_error)
___GOTO(___L12_c_23_compiler_2d_limitation_2d_error)
___DEF_SLBL(6,___L6_c_23_compiler_2d_limitation_2d_error)
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_compiler_2d_limitation_2d_error)
___DEF_GLBL(___L12_c_23_compiler_2d_limitation_2d_error)
___IF(___NOT(___PAIRP(___R1)))
___GOTO(___L13_c_23_compiler_2d_limitation_2d_error)
___END_IF
___SET_R2(___CAR(___R1))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___SUB(16))
___SET_R0(___LBL(8))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_display)
___DEF_SLBL(8,___L8_c_23_compiler_2d_limitation_2d_error)
___SET_R1(___STK(-5))
___SET_R0(___LBL(6))
___JUMPPRM(___SET_NARGS(1),___PRM_write)
___DEF_GLBL(___L13_c_23_compiler_2d_limitation_2d_error)
___SET_R1(___VOID)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(9,___L9_c_23_compiler_2d_limitation_2d_error)
___SET_R0(___LBL(10))
___JUMPPRM(___SET_NARGS(0),___PRM__23__23_newline0)
___DEF_SLBL(10,___L10_c_23_compiler_2d_limitation_2d_error)
___SET_R0(___STK(-3))
___POLL(11)
___DEF_SLBL(11,___L11_c_23_compiler_2d_limitation_2d_error)
___ADJFP(-4)
___JUMPINT(___SET_NARGS(0),___PRC(294),___L_c_23_compiler_2d_abort)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_compiler_2d_abort
#undef ___PH_LBL0
#define ___PH_LBL0 294
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R1 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R1 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_compiler_2d_abort)
___DEF_P_HLBL(___L1_c_23_compiler_2d_abort)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_compiler_2d_abort)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(0,0,0,0)
___DEF_GLBL(___L_c_23_compiler_2d_abort)
___SET_R1(___FAL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_compiler_2d_abort)
___JUMPGLONOTSAFE(___SET_NARGS(1),68,___G_c_23_throw_2d_to_2d_exception_2d_handler)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_make_2d_gnode
#undef ___PH_LBL0
#define ___PH_LBL0 297
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_make_2d_gnode)
___DEF_P_HLBL(___L1_c_23_make_2d_gnode)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_make_2d_gnode)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_make_2d_gnode)
___BEGIN_ALLOC_VECTOR(2UL)
___ADD_VECTOR_ELEM(0,___R1)
___ADD_VECTOR_ELEM(1,___R2)
___END_ALLOC_VECTOR(2)
___SET_R1(___GET_VECTOR(2))
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_make_2d_gnode)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_gnode_2d_var
#undef ___PH_LBL0
#define ___PH_LBL0 300
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_gnode_2d_var)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_gnode_2d_var)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_gnode_2d_var)
___SET_R1(___VECTORREF(___R1,___FIX(0L)))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_gnode_2d_depvars
#undef ___PH_LBL0
#define ___PH_LBL0 302
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_gnode_2d_depvars)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_gnode_2d_depvars)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_gnode_2d_depvars)
___SET_R1(___VECTORREF(___R1,___FIX(1L)))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_transitive_2d_closure
#undef ___PH_LBL0
#define ___PH_LBL0 304
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L1_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L2_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L3_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L4_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L5_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L6_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L7_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L8_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L9_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L10_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L11_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L12_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L13_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L14_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L15_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L16_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L17_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L18_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L19_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L20_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L21_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L22_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L23_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L24_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L25_c_23_transitive_2d_closure)
___DEF_P_HLBL(___L26_c_23_transitive_2d_closure)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_transitive_2d_closure)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_transitive_2d_closure)
___SET_STK(1,___R0)
___SET_R2(___LBL(23))
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_transitive_2d_closure)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(93),___L_c_23_sort_2d_list)
___DEF_SLBL(2,___L2_c_23_transitive_2d_closure)
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(1),___PRC(111),___L_c_23_list_2d__3e_vect)
___DEF_SLBL(3,___L3_c_23_transitive_2d_closure)
___SET_R2(___VECTORLENGTH(___R1))
___SET_STK(-2,___R2)
___SET_R2(___R1)
___SET_R1(___STK(-2))
___SET_R0(___STK(-3))
___ADJFP(-4)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_transitive_2d_closure)
___GOTO(___L27_c_23_transitive_2d_closure)
___DEF_SLBL(5,___L5_c_23_transitive_2d_closure)
___IF(___NOT(___NOTFALSEP(___UNBOX(___STK(-4)))))
___GOTO(___L33_c_23_transitive_2d_closure)
___END_IF
___SET_R2(___R1)
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_transitive_2d_closure)
___DEF_GLBL(___L27_c_23_transitive_2d_closure)
___SET_R3(___BOX(___FAL))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R0(___LBL(8))
___ADJFP(8)
___CHECK_HEAP(7,4096)
___DEF_SLBL(7,___L7_c_23_transitive_2d_closure)
___JUMPPRM(___SET_NARGS(1),___PRM_make_2d_vector)
___DEF_SLBL(8,___L8_c_23_transitive_2d_closure)
___SET_STK(1,___STK(-6))
___SET_STK(2,___STK(-5))
___SET_R2(___R1)
___SET_R1(___STK(-4))
___SET_R3(___FIX(0L))
___SET_R0(___LBL(5))
___ADJFP(2)
___POLL(9)
___DEF_SLBL(9,___L9_c_23_transitive_2d_closure)
___GOTO(___L29_c_23_transitive_2d_closure)
___DEF_SLBL(10,___L10_c_23_transitive_2d_closure)
___IF(___FIXEQ(___STK(-3),___R1))
___GOTO(___L28_c_23_transitive_2d_closure)
___END_IF
___SETBOX(___STK(-7),___TRU)
___DEF_GLBL(___L28_c_23_transitive_2d_closure)
___SET_R1(___VECTORREF(___STK(-4),___FIX(0L)))
___BEGIN_ALLOC_VECTOR(2UL)
___ADD_VECTOR_ELEM(0,___R1)
___ADD_VECTOR_ELEM(1,___STK(-9))
___END_ALLOC_VECTOR(2)
___SET_R1(___GET_VECTOR(2))
___VECTORSET(___STK(-6),___STK(-5),___R1)
___SET_R3(___FIXADD(___STK(-5),___FIX(1L)))
___SET_R2(___STK(-6))
___SET_R1(___STK(-7))
___SET_R0(___STK(-8))
___ADJFP(-10)
___CHECK_HEAP(11,4096)
___DEF_SLBL(11,___L11_c_23_transitive_2d_closure)
___POLL(12)
___DEF_SLBL(12,___L12_c_23_transitive_2d_closure)
___DEF_GLBL(___L29_c_23_transitive_2d_closure)
___IF(___FIXEQ(___R3,___STK(-1)))
___GOTO(___L32_c_23_transitive_2d_closure)
___END_IF
___SET_R4(___VECTORREF(___STK(0),___R3))
___SET_STK(1,___VECTORREF(___R4,___FIX(1L)))
___SET_STK(2,___R0)
___SET_STK(3,___R1)
___SET_STK(4,___R2)
___SET_STK(5,___R3)
___SET_STK(6,___R4)
___SET_R1(___CDR(___STK(1)))
___SET_R2(___R1)
___SET_R1(___STK(0))
___SET_R0(___LBL(18))
___ADJFP(10)
___POLL(13)
___DEF_SLBL(13,___L13_c_23_transitive_2d_closure)
___IF(___NOT(___PAIRP(___R2)))
___GOTO(___L31_c_23_transitive_2d_closure)
___END_IF
___DEF_GLBL(___L30_c_23_transitive_2d_closure)
___SET_R3(___CAR(___R2))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___R1)
___SET_R1(___R3)
___ADJFP(8)
___POLL(14)
___DEF_SLBL(14,___L14_c_23_transitive_2d_closure)
___SET_R0(___LBL(15))
___JUMPINT(___SET_NARGS(2),___PRC(332),___L_c_23_gnode_2d_find_2d_depvars)
___DEF_SLBL(15,___L15_c_23_transitive_2d_closure)
___SET_STK(-4,___R1)
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___LBL(16))
___IF(___PAIRP(___R2))
___GOTO(___L30_c_23_transitive_2d_closure)
___END_IF
___DEF_GLBL(___L31_c_23_transitive_2d_closure)
___SET_R1(___NUL)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(16,___L16_c_23_transitive_2d_closure)
___SET_R1(___CONS(___STK(-4),___R1))
___ADJFP(-7)
___CHECK_HEAP(17,4096)
___DEF_SLBL(17,___L17_c_23_transitive_2d_closure)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_SLBL(18,___L18_c_23_transitive_2d_closure)
___SET_R1(___CONS(___STK(-9),___R1))
___SET_R0(___LBL(20))
___CHECK_HEAP(19,4096)
___DEF_SLBL(19,___L19_c_23_transitive_2d_closure)
___JUMPINT(___SET_NARGS(1),___PRC(546),___L_c_23_varset_2d_union_2d_multi)
___DEF_SLBL(20,___L20_c_23_transitive_2d_closure)
___SET_STK(-9,___R1)
___SET_R0(___LBL(21))
___JUMPINT(___SET_NARGS(1),___PRC(470),___L_c_23_varset_2d_size)
___DEF_SLBL(21,___L21_c_23_transitive_2d_closure)
___SET_STK(-3,___R1)
___SET_R1(___VECTORREF(___STK(-4),___FIX(1L)))
___SET_R0(___LBL(10))
___JUMPINT(___SET_NARGS(1),___PRC(470),___L_c_23_varset_2d_size)
___DEF_GLBL(___L32_c_23_transitive_2d_closure)
___SET_R1(___R2)
___ADJFP(-2)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L33_c_23_transitive_2d_closure)
___SET_R0(___STK(-7))
___POLL(22)
___DEF_SLBL(22,___L22_c_23_transitive_2d_closure)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(1),___PRC(118),___L_c_23_vect_2d__3e_list)
___DEF_SLBL(23,___L23_c_23_transitive_2d_closure)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(23,2,0,0)
___SET_STK(1,___R0)
___SET_STK(2,___R2)
___ADJFP(8)
___POLL(24)
___DEF_SLBL(24,___L24_c_23_transitive_2d_closure)
___SET_R0(___LBL(25))
___JUMPINT(___SET_NARGS(1),___PRC(300),___L_c_23_gnode_2d_var)
___DEF_SLBL(25,___L25_c_23_transitive_2d_closure)
___SET_STK(-5,___R1)
___SET_R1(___STK(-6))
___SET_R0(___LBL(26))
___JUMPINT(___SET_NARGS(1),___PRC(300),___L_c_23_gnode_2d_var)
___DEF_SLBL(26,___L26_c_23_transitive_2d_closure)
___SET_R1(___VECTORREF(___R1,___FIX(8L)))
___SET_R2(___VECTORREF(___STK(-5),___FIX(8L)))
___SET_R1(___BOOLEAN(___FIXLT(___R2,___R1)))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_gnode_2d_find_2d_depvars
#undef ___PH_LBL0
#define ___PH_LBL0 332
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_gnode_2d_find_2d_depvars)
___DEF_P_HLBL(___L1_c_23_gnode_2d_find_2d_depvars)
___DEF_P_HLBL(___L2_c_23_gnode_2d_find_2d_depvars)
___DEF_P_HLBL(___L3_c_23_gnode_2d_find_2d_depvars)
___DEF_P_HLBL(___L4_c_23_gnode_2d_find_2d_depvars)
___DEF_P_HLBL(___L5_c_23_gnode_2d_find_2d_depvars)
___DEF_P_HLBL(___L6_c_23_gnode_2d_find_2d_depvars)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_gnode_2d_find_2d_depvars)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_gnode_2d_find_2d_depvars)
___SET_STK(1,___R1)
___SET_R1(___VECTORLENGTH(___R2))
___SET_R3(___FIXSUB(___R1,___FIX(1L)))
___SET_R1(___R2)
___SET_R2(___FIX(0L))
___ADJFP(1)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_gnode_2d_find_2d_depvars)
___GOTO(___L7_c_23_gnode_2d_find_2d_depvars)
___DEF_SLBL(2,___L2_c_23_gnode_2d_find_2d_depvars)
___IF(___NOTFALSEP(___R1))
___GOTO(___L10_c_23_gnode_2d_find_2d_depvars)
___END_IF
___SET_R3(___STK(-6))
___SET_R2(___FIXADD(___STK(-5),___FIX(1L)))
___SET_R1(___STK(-8))
___SET_R0(___STK(-9))
___ADJFP(-11)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_gnode_2d_find_2d_depvars)
___DEF_GLBL(___L7_c_23_gnode_2d_find_2d_depvars)
___IF(___NOT(___FIXLT(___R3,___R2)))
___GOTO(___L8_c_23_gnode_2d_find_2d_depvars)
___END_IF
___POLL(4)
___DEF_SLBL(4,___L4_c_23_gnode_2d_find_2d_depvars)
___ADJFP(-1)
___JUMPINT(___SET_NARGS(0),___PRC(448),___L_c_23_varset_2d_empty)
___DEF_GLBL(___L8_c_23_gnode_2d_find_2d_depvars)
___SET_R4(___FIXADD(___R3,___R2))
___SET_R4(___FIXQUO(___R4,___FIX(2L)))
___SET_STK(1,___VECTORREF(___R1,___R4))
___SET_STK(2,___VECTORREF(___STK(1),___FIX(0L)))
___ADJFP(2)
___IF(___EQP(___STK(0),___STK(-2)))
___GOTO(___L9_c_23_gnode_2d_find_2d_depvars)
___END_IF
___SET_STK(0,___R0)
___SET_STK(1,___R1)
___SET_STK(2,___R2)
___SET_STK(3,___R3)
___SET_STK(4,___R4)
___SET_R2(___VECTORREF(___STK(-1),___FIX(0L)))
___SET_R1(___STK(-2))
___ADJFP(9)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_gnode_2d_find_2d_depvars)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(475),___L_c_23_varset_2d__3c_)
___DEF_GLBL(___L9_c_23_gnode_2d_find_2d_depvars)
___SET_R1(___VECTORREF(___STK(-1),___FIX(1L)))
___ADJFP(-3)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L10_c_23_gnode_2d_find_2d_depvars)
___SET_R3(___FIXSUB(___STK(-5),___FIX(1L)))
___SET_R2(___STK(-7))
___SET_R1(___STK(-8))
___SET_R0(___STK(-9))
___ADJFP(-11)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_gnode_2d_find_2d_depvars)
___GOTO(___L7_c_23_gnode_2d_find_2d_depvars)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_gnodes_2d_remove
#undef ___PH_LBL0
#define ___PH_LBL0 340
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_gnodes_2d_remove)
___DEF_P_HLBL(___L1_c_23_gnodes_2d_remove)
___DEF_P_HLBL(___L2_c_23_gnodes_2d_remove)
___DEF_P_HLBL(___L3_c_23_gnodes_2d_remove)
___DEF_P_HLBL(___L4_c_23_gnodes_2d_remove)
___DEF_P_HLBL(___L5_c_23_gnodes_2d_remove)
___DEF_P_HLBL(___L6_c_23_gnodes_2d_remove)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_gnodes_2d_remove)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_gnodes_2d_remove)
___IF(___NULLP(___R1))
___GOTO(___L12_c_23_gnodes_2d_remove)
___END_IF
___GOTO(___L7_c_23_gnodes_2d_remove)
___DEF_SLBL(1,___L1_c_23_gnodes_2d_remove)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L11_c_23_gnodes_2d_remove)
___END_IF
___SET_R2(___STK(-5))
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_gnodes_2d_remove)
___IF(___NULLP(___R1))
___GOTO(___L12_c_23_gnodes_2d_remove)
___END_IF
___DEF_GLBL(___L7_c_23_gnodes_2d_remove)
___SET_R3(___CAR(___R1))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R1(___R3)
___SET_R0(___LBL(1))
___ADJFP(8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_gnodes_2d_remove)
___DEF_GLBL(___L8_c_23_gnodes_2d_remove)
___IF(___NOT(___PAIRP(___R2)))
___GOTO(___L10_c_23_gnodes_2d_remove)
___END_IF
___SET_R3(___CAR(___R2))
___IF(___EQP(___R1,___R3))
___GOTO(___L9_c_23_gnodes_2d_remove)
___END_IF
___SET_R2(___CDR(___R2))
___POLL(4)
___DEF_SLBL(4,___L4_c_23_gnodes_2d_remove)
___GOTO(___L8_c_23_gnodes_2d_remove)
___DEF_GLBL(___L9_c_23_gnodes_2d_remove)
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L10_c_23_gnodes_2d_remove)
___SET_R1(___FAL)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L11_c_23_gnodes_2d_remove)
___SET_R2(___STK(-5))
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___LBL(5))
___IF(___NOT(___NULLP(___R1)))
___GOTO(___L7_c_23_gnodes_2d_remove)
___END_IF
___DEF_GLBL(___L12_c_23_gnodes_2d_remove)
___SET_R1(___NUL)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(5,___L5_c_23_gnodes_2d_remove)
___SET_R1(___CONS(___STK(-4),___R1))
___ADJFP(-7)
___CHECK_HEAP(6,4096)
___DEF_SLBL(6,___L6_c_23_gnodes_2d_remove)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_topological_2d_sort
#undef ___PH_LBL0
#define ___PH_LBL0 348
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_topological_2d_sort)
___DEF_P_HLBL(___L1_c_23_topological_2d_sort)
___DEF_P_HLBL(___L2_c_23_topological_2d_sort)
___DEF_P_HLBL(___L3_c_23_topological_2d_sort)
___DEF_P_HLBL(___L4_c_23_topological_2d_sort)
___DEF_P_HLBL(___L5_c_23_topological_2d_sort)
___DEF_P_HLBL(___L6_c_23_topological_2d_sort)
___DEF_P_HLBL(___L7_c_23_topological_2d_sort)
___DEF_P_HLBL(___L8_c_23_topological_2d_sort)
___DEF_P_HLBL(___L9_c_23_topological_2d_sort)
___DEF_P_HLBL(___L10_c_23_topological_2d_sort)
___DEF_P_HLBL(___L11_c_23_topological_2d_sort)
___DEF_P_HLBL(___L12_c_23_topological_2d_sort)
___DEF_P_HLBL(___L13_c_23_topological_2d_sort)
___DEF_P_HLBL(___L14_c_23_topological_2d_sort)
___DEF_P_HLBL(___L15_c_23_topological_2d_sort)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_topological_2d_sort)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_topological_2d_sort)
___IF(___NULLP(___R1))
___GOTO(___L19_c_23_topological_2d_sort)
___END_IF
___GOTO(___L16_c_23_topological_2d_sort)
___DEF_SLBL(1,___L1_c_23_topological_2d_sort)
___SET_R0(___LBL(14))
___IF(___NULLP(___R1))
___GOTO(___L19_c_23_topological_2d_sort)
___END_IF
___DEF_GLBL(___L16_c_23_topological_2d_sort)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___ADJFP(8)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_topological_2d_sort)
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(1),___PRC(365),___L_c_23_remove_2d_no_2d_depvars)
___DEF_SLBL(3,___L3_c_23_topological_2d_sort)
___IF(___NOTFALSEP(___R1))
___GOTO(___L17_c_23_topological_2d_sort)
___END_IF
___GOTO(___L21_c_23_topological_2d_sort)
___DEF_SLBL(4,___L4_c_23_topological_2d_sort)
___DEF_GLBL(___L17_c_23_topological_2d_sort)
___SET_STK(-5,___R1)
___SET_R0(___LBL(8))
___IF(___NOT(___PAIRP(___R1)))
___GOTO(___L19_c_23_topological_2d_sort)
___END_IF
___DEF_GLBL(___L18_c_23_topological_2d_sort)
___SET_R2(___CAR(___R1))
___SET_R2(___VECTORREF(___R2,___FIX(0L)))
___SET_STK(1,___R0)
___SET_STK(2,___R2)
___SET_R1(___CDR(___R1))
___SET_R0(___LBL(6))
___ADJFP(8)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_topological_2d_sort)
___IF(___PAIRP(___R1))
___GOTO(___L18_c_23_topological_2d_sort)
___END_IF
___DEF_GLBL(___L19_c_23_topological_2d_sort)
___SET_R1(___NUL)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(6,___L6_c_23_topological_2d_sort)
___SET_R1(___CONS(___STK(-6),___R1))
___ADJFP(-7)
___CHECK_HEAP(7,4096)
___DEF_SLBL(7,___L7_c_23_topological_2d_sort)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_SLBL(8,___L8_c_23_topological_2d_sort)
___SET_R0(___LBL(9))
___JUMPINT(___SET_NARGS(1),___PRC(454),___L_c_23_list_2d__3e_varset)
___DEF_SLBL(9,___L9_c_23_topological_2d_sort)
___SET_STK(-4,___R1)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___LBL(10))
___JUMPINT(___SET_NARGS(2),___PRC(340),___L_c_23_gnodes_2d_remove)
___DEF_SLBL(10,___L10_c_23_topological_2d_sort)
___SET_R2(___R1)
___SET_R1(___STK(-4))
___SET_R0(___LBL(1))
___IF(___PAIRP(___R2))
___GOTO(___L20_c_23_topological_2d_sort)
___END_IF
___GOTO(___L19_c_23_topological_2d_sort)
___DEF_SLBL(11,___L11_c_23_topological_2d_sort)
___SET_R2(___VECTORREF(___STK(-4),___FIX(0L)))
___BEGIN_ALLOC_VECTOR(2UL)
___ADD_VECTOR_ELEM(0,___R2)
___ADD_VECTOR_ELEM(1,___R1)
___END_ALLOC_VECTOR(2)
___SET_R1(___GET_VECTOR(2))
___SET_STK(-4,___R1)
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___LBL(14))
___CHECK_HEAP(12,4096)
___DEF_SLBL(12,___L12_c_23_topological_2d_sort)
___IF(___NOT(___PAIRP(___R2)))
___GOTO(___L19_c_23_topological_2d_sort)
___END_IF
___DEF_GLBL(___L20_c_23_topological_2d_sort)
___SET_R3(___CAR(___R2))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R2(___R1)
___SET_R1(___VECTORREF(___R3,___FIX(1L)))
___ADJFP(8)
___POLL(13)
___DEF_SLBL(13,___L13_c_23_topological_2d_sort)
___SET_R0(___LBL(11))
___JUMPINT(___SET_NARGS(2),___PRC(506),___L_c_23_varset_2d_difference)
___DEF_SLBL(14,___L14_c_23_topological_2d_sort)
___SET_R1(___CONS(___STK(-4),___R1))
___ADJFP(-7)
___CHECK_HEAP(15,4096)
___DEF_SLBL(15,___L15_c_23_topological_2d_sort)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L21_c_23_topological_2d_sort)
___SET_R1(___STK(-6))
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(1),___PRC(372),___L_c_23_remove_2d_cycle)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_remove_2d_no_2d_depvars
#undef ___PH_LBL0
#define ___PH_LBL0 365
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_remove_2d_no_2d_depvars)
___DEF_P_HLBL(___L1_c_23_remove_2d_no_2d_depvars)
___DEF_P_HLBL(___L2_c_23_remove_2d_no_2d_depvars)
___DEF_P_HLBL(___L3_c_23_remove_2d_no_2d_depvars)
___DEF_P_HLBL(___L4_c_23_remove_2d_no_2d_depvars)
___DEF_P_HLBL(___L5_c_23_remove_2d_no_2d_depvars)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_remove_2d_no_2d_depvars)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_remove_2d_no_2d_depvars)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___LBL(3))
___SET_R2(___STK(2))
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_remove_2d_no_2d_depvars)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(73),___L_c_23_keep)
___DEF_SLBL(2,___L2_c_23_remove_2d_no_2d_depvars)
___IF(___NOT(___NULLP(___R1)))
___GOTO(___L6_c_23_remove_2d_no_2d_depvars)
___END_IF
___SET_R1(___FAL)
___ADJFP(-4)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L6_c_23_remove_2d_no_2d_depvars)
___ADJFP(-4)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_SLBL(3,___L3_c_23_remove_2d_no_2d_depvars)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(3,1,0,0)
___SET_STK(1,___R0)
___ADJFP(4)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_remove_2d_no_2d_depvars)
___SET_R0(___LBL(5))
___JUMPINT(___SET_NARGS(1),___PRC(302),___L_c_23_gnode_2d_depvars)
___DEF_SLBL(5,___L5_c_23_remove_2d_no_2d_depvars)
___SET_R1(___CDR(___R1))
___SET_R1(___BOOLEAN(___NULLP(___R1)))
___ADJFP(-4)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_remove_2d_cycle
#undef ___PH_LBL0
#define ___PH_LBL0 372
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L1_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L2_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L3_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L4_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L5_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L6_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L7_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L8_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L9_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L10_c_23_remove_2d_cycle)
___DEF_P_HLBL(___L11_c_23_remove_2d_cycle)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_remove_2d_cycle)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_remove_2d_cycle)
___SET_R2(___R1)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_remove_2d_cycle)
___GOTO(___L13_c_23_remove_2d_cycle)
___DEF_SLBL(2,___L2_c_23_remove_2d_cycle)
___IF(___NOTFALSEP(___R1))
___GOTO(___L14_c_23_remove_2d_cycle)
___END_IF
___DEF_GLBL(___L12_c_23_remove_2d_cycle)
___SET_R2(___CDR(___STK(-3)))
___SET_R1(___STK(-4))
___SET_R0(___STK(-5))
___ADJFP(-8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_remove_2d_cycle)
___DEF_GLBL(___L13_c_23_remove_2d_cycle)
___SET_R3(___CAR(___R2))
___SET_R4(___VECTORREF(___R3,___FIX(1L)))
___SET_STK(1,___ALLOC_CLO(1UL))
___SET_STK(2,___ALLOC_CLO(1UL))
___BEGIN_SETUP_CLO(1,___STK(1),10)
___ADD_CLO_ELEM(0,___R4)
___END_SETUP_CLO(1)
___BEGIN_SETUP_CLO(1,___STK(2),8)
___ADD_CLO_ELEM(0,___R4)
___END_SETUP_CLO(1)
___SET_STK(3,___R0)
___SET_STK(4,___R1)
___SET_STK(5,___R2)
___SET_R1(___R3)
___ADJFP(8)
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4_c_23_remove_2d_cycle)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_remove_2d_cycle)
___SET_R0(___LBL(6))
___JUMPGENNOTSAFE(___SET_NARGS(1),___STK(-6))
___DEF_SLBL(6,___L6_c_23_remove_2d_cycle)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L12_c_23_remove_2d_cycle)
___END_IF
___SET_R2(___STK(-4))
___SET_R1(___STK(-6))
___SET_R0(___LBL(7))
___JUMPINT(___SET_NARGS(2),___PRC(73),___L_c_23_keep)
___DEF_SLBL(7,___L7_c_23_remove_2d_cycle)
___SET_STK(-6,___R1)
___SET_R2(___R1)
___SET_R1(___STK(-7))
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(82),___L_c_23_every_3f_)
___DEF_SLBL(8,___L8_c_23_remove_2d_cycle)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(8,1,0,0)
___SET_R2(___CLO(___R4,1))
___SET_R1(___VECTORREF(___R1,___FIX(0L)))
___POLL(9)
___DEF_SLBL(9,___L9_c_23_remove_2d_cycle)
___JUMPINT(___SET_NARGS(2),___PRC(477),___L_c_23_varset_2d_member_3f_)
___DEF_SLBL(10,___L10_c_23_remove_2d_cycle)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(10,1,0,0)
___SET_R2(___CLO(___R4,1))
___SET_R1(___VECTORREF(___R1,___FIX(1L)))
___POLL(11)
___DEF_SLBL(11,___L11_c_23_remove_2d_cycle)
___JUMPINT(___SET_NARGS(2),___PRC(503),___L_c_23_varset_2d_equal_3f_)
___DEF_GLBL(___L14_c_23_remove_2d_cycle)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(3))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ptset_2d_empty
#undef ___PH_LBL0
#define ___PH_LBL0 385
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ptset_2d_empty)
___DEF_P_HLBL(___L1_c_23_ptset_2d_empty)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ptset_2d_empty)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(0,0,0,0)
___DEF_GLBL(___L_c_23_ptset_2d_empty)
___BEGIN_ALLOC_VECTOR(11UL)
___ADD_VECTOR_ELEM(0,___NUL)
___ADD_VECTOR_ELEM(1,___NUL)
___ADD_VECTOR_ELEM(2,___NUL)
___ADD_VECTOR_ELEM(3,___NUL)
___ADD_VECTOR_ELEM(4,___NUL)
___ADD_VECTOR_ELEM(5,___NUL)
___ADD_VECTOR_ELEM(6,___NUL)
___ADD_VECTOR_ELEM(7,___NUL)
___ADD_VECTOR_ELEM(8,___NUL)
___ADD_VECTOR_ELEM(9,___NUL)
___ADD_VECTOR_ELEM(10,___NUL)
___END_ALLOC_VECTOR(11)
___SET_R1(___GET_VECTOR(11))
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_ptset_2d_empty)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_list_2d__3e_ptset
#undef ___PH_LBL0
#define ___PH_LBL0 388
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_list_2d__3e_ptset)
___DEF_P_HLBL(___L1_c_23_list_2d__3e_ptset)
___DEF_P_HLBL(___L2_c_23_list_2d__3e_ptset)
___DEF_P_HLBL(___L3_c_23_list_2d__3e_ptset)
___DEF_P_HLBL(___L4_c_23_list_2d__3e_ptset)
___DEF_P_HLBL(___L5_c_23_list_2d__3e_ptset)
___DEF_P_HLBL(___L6_c_23_list_2d__3e_ptset)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_list_2d__3e_ptset)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_list_2d__3e_ptset)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_list_2d__3e_ptset)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(0),___PRC(385),___L_c_23_ptset_2d_empty)
___DEF_SLBL(2,___L2_c_23_list_2d__3e_ptset)
___SET_R2(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_list_2d__3e_ptset)
___GOTO(___L7_c_23_list_2d__3e_ptset)
___DEF_SLBL(4,___L4_c_23_list_2d__3e_ptset)
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_list_2d__3e_ptset)
___DEF_GLBL(___L7_c_23_list_2d__3e_ptset)
___IF(___NOT(___PAIRP(___R2)))
___GOTO(___L8_c_23_list_2d__3e_ptset)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___CAR(___R2))
___ADJFP(8)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_list_2d__3e_ptset)
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(418),___L_c_23_ptset_2d_adjoin)
___DEF_GLBL(___L8_c_23_list_2d__3e_ptset)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ptset_2d__3e_list
#undef ___PH_LBL0
#define ___PH_LBL0 396
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ptset_2d__3e_list)
___DEF_P_HLBL(___L1_c_23_ptset_2d__3e_list)
___DEF_P_HLBL(___L2_c_23_ptset_2d__3e_list)
___DEF_P_HLBL(___L3_c_23_ptset_2d__3e_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ptset_2d__3e_list)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_ptset_2d__3e_list)
___SET_STK(1,___R0)
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ptset_2d__3e_list)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(1),___PRC(118),___L_c_23_vect_2d__3e_list)
___DEF_SLBL(2,___L2_c_23_ptset_2d__3e_list)
___SET_R0(___STK(-3))
___POLL(3)
___DEF_SLBL(3,___L3_c_23_ptset_2d__3e_list)
___ADJFP(-4)
___JUMPINT(___SET_NARGS(1),___PRC(5),___L_c_23_append_2d_lists)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ptset_2d_size
#undef ___PH_LBL0
#define ___PH_LBL0 401
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ptset_2d_size)
___DEF_P_HLBL(___L1_c_23_ptset_2d_size)
___DEF_P_HLBL(___L2_c_23_ptset_2d_size)
___DEF_P_HLBL(___L3_c_23_ptset_2d_size)
___DEF_P_HLBL(___L4_c_23_ptset_2d_size)
___DEF_P_HLBL(___L5_c_23_ptset_2d_size)
___DEF_P_HLBL(___L6_c_23_ptset_2d_size)
___DEF_P_HLBL(___L7_c_23_ptset_2d_size)
___DEF_P_HLBL(___L8_c_23_ptset_2d_size)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ptset_2d_size)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_ptset_2d_size)
___SET_STK(1,___R0)
___ADJFP(4)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ptset_2d_size)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(1),___PRC(118),___L_c_23_vect_2d__3e_list)
___DEF_SLBL(2,___L2_c_23_ptset_2d_size)
___SET_R0(___LBL(7))
___IF(___PAIRP(___R1))
___GOTO(___L9_c_23_ptset_2d_size)
___END_IF
___GOTO(___L10_c_23_ptset_2d_size)
___DEF_SLBL(3,___L3_c_23_ptset_2d_size)
___SET_STK(-5,___R1)
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___LBL(5))
___IF(___NOT(___PAIRP(___R1)))
___GOTO(___L10_c_23_ptset_2d_size)
___END_IF
___DEF_GLBL(___L9_c_23_ptset_2d_size)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R1(___CAR(___R1))
___ADJFP(8)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_ptset_2d_size)
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(1),___PRC(17),___L_c_23_list_2d_length)
___DEF_SLBL(5,___L5_c_23_ptset_2d_size)
___SET_R1(___CONS(___STK(-5),___R1))
___ADJFP(-7)
___CHECK_HEAP(6,4096)
___DEF_SLBL(6,___L6_c_23_ptset_2d_size)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_GLBL(___L10_c_23_ptset_2d_size)
___SET_R1(___NUL)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(7,___L7_c_23_ptset_2d_size)
___SET_R2(___R1)
___SET_R1(___PRM__2b_)
___SET_R0(___STK(-3))
___POLL(8)
___DEF_SLBL(8,___L8_c_23_ptset_2d_size)
___ADJFP(-4)
___JUMPPRM(___SET_NARGS(2),___PRM_apply)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ptset_2d_empty_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 411
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ptset_2d_empty_3f_)
___DEF_P_HLBL(___L1_c_23_ptset_2d_empty_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ptset_2d_empty_3f_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_ptset_2d_empty_3f_)
___IF(___EQP(___R1,___GLO_c_23_ptset_2d_empty_2d_set))
___GOTO(___L3_c_23_ptset_2d_empty_3f_)
___END_IF
___IF(___NOT(___MEMALLOCATEDP(___R1)))
___GOTO(___L2_c_23_ptset_2d_empty_3f_)
___END_IF
___IF(___NOT(___MEMALLOCATEDP(___GLO_c_23_ptset_2d_empty_2d_set)))
___GOTO(___L2_c_23_ptset_2d_empty_3f_)
___END_IF
___SET_R2(___SUBTYPE(___R1))
___SET_R3(___SUBTYPE(___GLO_c_23_ptset_2d_empty_2d_set))
___IF(___NOT(___FIXEQ(___R2,___R3)))
___GOTO(___L2_c_23_ptset_2d_empty_3f_)
___END_IF
___SET_R2(___GLO_c_23_ptset_2d_empty_2d_set)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ptset_2d_empty_3f_)
___JUMPPRM(___SET_NARGS(2),___PRM_equal_3f_)
___DEF_GLBL(___L2_c_23_ptset_2d_empty_3f_)
___SET_R1(___FAL)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L3_c_23_ptset_2d_empty_3f_)
___SET_R1(___TRU)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ptset_2d_member_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 414
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ptset_2d_member_3f_)
___DEF_P_HLBL(___L1_c_23_ptset_2d_member_3f_)
___DEF_P_HLBL(___L2_c_23_ptset_2d_member_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ptset_2d_member_3f_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_ptset_2d_member_3f_)
___SET_R3(___VECTORREF(___R1,___FIX(7L)))
___SET_R3(___FIXMOD(___R3,___FIX(11L)))
___SET_R2(___VECTORREF(___R2,___R3))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ptset_2d_member_3f_)
___GOTO(___L4_c_23_ptset_2d_member_3f_)
___DEF_GLBL(___L3_c_23_ptset_2d_member_3f_)
___SET_R3(___CAR(___R2))
___IF(___EQP(___R1,___R3))
___GOTO(___L5_c_23_ptset_2d_member_3f_)
___END_IF
___SET_R2(___CDR(___R2))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_ptset_2d_member_3f_)
___DEF_GLBL(___L4_c_23_ptset_2d_member_3f_)
___IF(___PAIRP(___R2))
___GOTO(___L3_c_23_ptset_2d_member_3f_)
___END_IF
___SET_R1(___FAL)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L5_c_23_ptset_2d_member_3f_)
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ptset_2d_adjoin
#undef ___PH_LBL0
#define ___PH_LBL0 418
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ptset_2d_adjoin)
___DEF_P_HLBL(___L1_c_23_ptset_2d_adjoin)
___DEF_P_HLBL(___L2_c_23_ptset_2d_adjoin)
___DEF_P_HLBL(___L3_c_23_ptset_2d_adjoin)
___DEF_P_HLBL(___L4_c_23_ptset_2d_adjoin)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ptset_2d_adjoin)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_ptset_2d_adjoin)
___SET_R3(___VECTORREF(___R2,___FIX(7L)))
___SET_R3(___FIXMOD(___R3,___FIX(11L)))
___SET_R4(___VECTORREF(___R1,___R3))
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_STK(5,___R4)
___SET_R2(___R4)
___SET_R1(___STK(3))
___SET_R0(___LBL(3))
___ADJFP(8)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ptset_2d_adjoin)
___GOTO(___L6_c_23_ptset_2d_adjoin)
___DEF_GLBL(___L5_c_23_ptset_2d_adjoin)
___SET_R3(___CAR(___R2))
___IF(___EQP(___R1,___R3))
___GOTO(___L7_c_23_ptset_2d_adjoin)
___END_IF
___SET_R2(___CDR(___R2))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_ptset_2d_adjoin)
___DEF_GLBL(___L6_c_23_ptset_2d_adjoin)
___IF(___PAIRP(___R2))
___GOTO(___L5_c_23_ptset_2d_adjoin)
___END_IF
___SET_R1(___FAL)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L7_c_23_ptset_2d_adjoin)
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___DEF_SLBL(3,___L3_c_23_ptset_2d_adjoin)
___IF(___NOTFALSEP(___R1))
___GOTO(___L8_c_23_ptset_2d_adjoin)
___END_IF
___SET_R1(___CONS(___STK(-5),___STK(-3)))
___VECTORSET(___STK(-6),___STK(-4),___R1)
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4_c_23_ptset_2d_adjoin)
___DEF_GLBL(___L8_c_23_ptset_2d_adjoin)
___SET_R1(___STK(-6))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ptset_2d_every_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 424
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ptset_2d_every_3f_)
___DEF_P_HLBL(___L1_c_23_ptset_2d_every_3f_)
___DEF_P_HLBL(___L2_c_23_ptset_2d_every_3f_)
___DEF_P_HLBL(___L3_c_23_ptset_2d_every_3f_)
___DEF_P_HLBL(___L4_c_23_ptset_2d_every_3f_)
___DEF_P_HLBL(___L5_c_23_ptset_2d_every_3f_)
___DEF_P_HLBL(___L6_c_23_ptset_2d_every_3f_)
___DEF_P_HLBL(___L7_c_23_ptset_2d_every_3f_)
___DEF_P_HLBL(___L8_c_23_ptset_2d_every_3f_)
___DEF_P_HLBL(___L9_c_23_ptset_2d_every_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ptset_2d_every_3f_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_ptset_2d_every_3f_)
___SET_STK(1,___ALLOC_CLO(1UL))
___BEGIN_SETUP_CLO(1,___STK(1),8)
___ADD_CLO_ELEM(0,___R1)
___END_SETUP_CLO(1)
___SET_STK(2,___R0)
___SET_R1(___R2)
___ADJFP(8)
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_ptset_2d_every_3f_)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_ptset_2d_every_3f_)
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(1),___PRC(118),___L_c_23_vect_2d__3e_list)
___DEF_SLBL(3,___L3_c_23_ptset_2d_every_3f_)
___SET_R2(___R1)
___SET_R0(___STK(-6))
___SET_R1(___STK(-7))
___ADJFP(-8)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_ptset_2d_every_3f_)
___GOTO(___L10_c_23_ptset_2d_every_3f_)
___DEF_SLBL(5,___L5_c_23_ptset_2d_every_3f_)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L12_c_23_ptset_2d_every_3f_)
___END_IF
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_ptset_2d_every_3f_)
___DEF_GLBL(___L10_c_23_ptset_2d_every_3f_)
___IF(___NULLP(___R2))
___GOTO(___L11_c_23_ptset_2d_every_3f_)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___CAR(___R2))
___ADJFP(8)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_ptset_2d_every_3f_)
___SET_R0(___LBL(5))
___JUMPGENNOTSAFE(___SET_NARGS(1),___STK(-6))
___DEF_GLBL(___L11_c_23_ptset_2d_every_3f_)
___SET_R1(___TRU)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L12_c_23_ptset_2d_every_3f_)
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(1))
___DEF_SLBL(8,___L8_c_23_ptset_2d_every_3f_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(8,1,0,0)
___SET_R2(___R1)
___SET_R1(___CLO(___R4,1))
___POLL(9)
___DEF_SLBL(9,___L9_c_23_ptset_2d_every_3f_)
___GOTO(___L10_c_23_ptset_2d_every_3f_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_ptset_2d_remove
#undef ___PH_LBL0
#define ___PH_LBL0 435
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_ptset_2d_remove)
___DEF_P_HLBL(___L1_c_23_ptset_2d_remove)
___DEF_P_HLBL(___L2_c_23_ptset_2d_remove)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_ptset_2d_remove)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_ptset_2d_remove)
___SET_R3(___VECTORREF(___R2,___FIX(7L)))
___SET_R3(___FIXMOD(___R3,___FIX(11L)))
___SET_R4(___VECTORREF(___R1,___R3))
___IF(___NULLP(___R4))
___GOTO(___L7_c_23_ptset_2d_remove)
___END_IF
___SET_STK(1,___CAR(___R4))
___ADJFP(1)
___IF(___EQP(___R2,___STK(0)))
___GOTO(___L6_c_23_ptset_2d_remove)
___END_IF
___SET_STK(0,___R1)
___SET_R1(___R2)
___SET_R3(___CDR(___R4))
___SET_R2(___R4)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_ptset_2d_remove)
___GOTO(___L4_c_23_ptset_2d_remove)
___DEF_GLBL(___L3_c_23_ptset_2d_remove)
___SET_R4(___CAR(___R3))
___IF(___EQP(___R4,___R1))
___GOTO(___L5_c_23_ptset_2d_remove)
___END_IF
___SET_R2(___CDR(___R3))
___SET_STK(1,___R3)
___SET_R3(___R2)
___SET_R2(___STK(1))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_ptset_2d_remove)
___DEF_GLBL(___L4_c_23_ptset_2d_remove)
___IF(___NOT(___NULLP(___R3)))
___GOTO(___L3_c_23_ptset_2d_remove)
___END_IF
___SET_R1(___STK(0))
___ADJFP(-1)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L5_c_23_ptset_2d_remove)
___SET_R1(___CDR(___R3))
___SETCDR(___R2,___R1)
___SET_R1(___STK(0))
___ADJFP(-1)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L6_c_23_ptset_2d_remove)
___SET_R2(___CDR(___R4))
___VECTORSET(___R1,___R3,___R2)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L7_c_23_ptset_2d_remove)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_reverse_2d_append_21_
#undef ___PH_LBL0
#define ___PH_LBL0 439
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_reverse_2d_append_21_)
___DEF_P_HLBL(___L1_c_23_varset_2d_reverse_2d_append_21_)
___DEF_P_HLBL(___L2_c_23_varset_2d_reverse_2d_append_21_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_reverse_2d_append_21_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d_reverse_2d_append_21_)
___IF(___NULLP(___R1))
___GOTO(___L5_c_23_varset_2d_reverse_2d_append_21_)
___END_IF
___GOTO(___L4_c_23_varset_2d_reverse_2d_append_21_)
___DEF_GLBL(___L3_c_23_varset_2d_reverse_2d_append_21_)
___IF(___NULLP(___R1))
___GOTO(___L5_c_23_varset_2d_reverse_2d_append_21_)
___END_IF
___DEF_GLBL(___L4_c_23_varset_2d_reverse_2d_append_21_)
___SET_R3(___CDR(___R1))
___SETCDR(___R1,___R2)
___SET_R2(___R1)
___SET_R1(___R3)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_varset_2d_reverse_2d_append_21_)
___GOTO(___L3_c_23_varset_2d_reverse_2d_append_21_)
___DEF_GLBL(___L5_c_23_varset_2d_reverse_2d_append_21_)
___SET_R1(___CONS(___FAL,___R2))
___CHECK_HEAP(2,4096)
___DEF_SLBL(2,___L2_c_23_varset_2d_reverse_2d_append_21_)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_wrap
#undef ___PH_LBL0
#define ___PH_LBL0 443
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_wrap)
___DEF_P_HLBL(___L1_c_23_varset_2d_wrap)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_wrap)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_varset_2d_wrap)
___SET_R1(___CONS(___FAL,___R1))
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_varset_2d_wrap)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_unwrap
#undef ___PH_LBL0
#define ___PH_LBL0 446
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_unwrap)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_unwrap)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_varset_2d_unwrap)
___SET_R1(___CDR(___R1))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_empty
#undef ___PH_LBL0
#define ___PH_LBL0 448
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_empty)
___DEF_P_HLBL(___L1_c_23_varset_2d_empty)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_empty)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(0,0,0,0)
___DEF_GLBL(___L_c_23_varset_2d_empty)
___SET_R1(___CONS(___FAL,___NUL))
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_varset_2d_empty)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_singleton
#undef ___PH_LBL0
#define ___PH_LBL0 451
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_singleton)
___DEF_P_HLBL(___L1_c_23_varset_2d_singleton)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_singleton)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_varset_2d_singleton)
___SET_R1(___CONS(___R1,___NUL))
___SET_R1(___CONS(___FAL,___R1))
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_varset_2d_singleton)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_list_2d__3e_varset
#undef ___PH_LBL0
#define ___PH_LBL0 454
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L1_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L2_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L3_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L4_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L5_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L6_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L7_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L8_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L9_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L10_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L11_c_23_list_2d__3e_varset)
___DEF_P_HLBL(___L12_c_23_list_2d__3e_varset)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_list_2d__3e_varset)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_list_2d__3e_varset)
___IF(___NOT(___NULLP(___R1)))
___GOTO(___L13_c_23_list_2d__3e_varset)
___END_IF
___POLL(1)
___DEF_SLBL(1,___L1_c_23_list_2d__3e_varset)
___JUMPINT(___SET_NARGS(0),___PRC(448),___L_c_23_varset_2d_empty)
___DEF_GLBL(___L13_c_23_list_2d__3e_varset)
___SET_R3(___CDR(___R1))
___SET_R2(___CAR(___R1))
___POLL(2)
___DEF_SLBL(2,___L2_c_23_list_2d__3e_varset)
___GOTO(___L14_c_23_list_2d__3e_varset)
___DEF_SLBL(3,___L3_c_23_list_2d__3e_varset)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L16_c_23_list_2d__3e_varset)
___END_IF
___SET_R1(___STK(-6))
___SET_R3(___CDR(___STK(-5)))
___SET_R2(___CAR(___STK(-5)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_list_2d__3e_varset)
___DEF_GLBL(___L14_c_23_list_2d__3e_varset)
___IF(___NULLP(___R3))
___GOTO(___L15_c_23_list_2d__3e_varset)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R3)
___SET_R1(___CAR(___R3))
___SET_STK(4,___R2)
___SET_R2(___R1)
___SET_R1(___STK(4))
___ADJFP(8)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_list_2d__3e_varset)
___SET_R0(___LBL(3))
___JUMPINT(___SET_NARGS(2),___PRC(475),___L_c_23_varset_2d__3c_)
___DEF_GLBL(___L15_c_23_list_2d__3e_varset)
___SET_R1(___CONS(___FAL,___R1))
___CHECK_HEAP(6,4096)
___DEF_SLBL(6,___L6_c_23_list_2d__3e_varset)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L16_c_23_list_2d__3e_varset)
___SET_R1(___STK(-6))
___SET_R2(___NUL)
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_list_2d__3e_varset)
___GOTO(___L17_c_23_list_2d__3e_varset)
___DEF_SLBL(8,___L8_c_23_list_2d__3e_varset)
___SET_R2(___CONS(___R1,___STK(-5)))
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___CHECK_HEAP(9,4096)
___DEF_SLBL(9,___L9_c_23_list_2d__3e_varset)
___POLL(10)
___DEF_SLBL(10,___L10_c_23_list_2d__3e_varset)
___DEF_GLBL(___L17_c_23_list_2d__3e_varset)
___IF(___NOT(___NULLP(___R1)))
___GOTO(___L18_c_23_list_2d__3e_varset)
___END_IF
___SET_R1(___R2)
___POLL(11)
___DEF_SLBL(11,___L11_c_23_list_2d__3e_varset)
___JUMPINT(___SET_NARGS(1),___PRC(546),___L_c_23_varset_2d_union_2d_multi)
___DEF_GLBL(___L18_c_23_list_2d__3e_varset)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___CAR(___R1))
___ADJFP(8)
___POLL(12)
___DEF_SLBL(12,___L12_c_23_list_2d__3e_varset)
___SET_R0(___LBL(8))
___JUMPINT(___SET_NARGS(1),___PRC(451),___L_c_23_varset_2d_singleton)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d__3e_list
#undef ___PH_LBL0
#define ___PH_LBL0 468
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d__3e_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d__3e_list)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_varset_2d__3e_list)
___SET_R1(___CDR(___R1))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_size
#undef ___PH_LBL0
#define ___PH_LBL0 470
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_size)
___DEF_P_HLBL(___L1_c_23_varset_2d_size)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_size)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_varset_2d_size)
___SET_R2(___CAR(___R1))
___IF(___NOTFALSEP(___R2))
___GOTO(___L2_c_23_varset_2d_size)
___END_IF
___SET_R1(___CDR(___R1))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_varset_2d_size)
___JUMPINT(___SET_NARGS(1),___PRC(17),___L_c_23_list_2d_length)
___DEF_GLBL(___L2_c_23_varset_2d_size)
___SET_R1(___VECTORLENGTH(___R2))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_empty_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 473
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_empty_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_empty_3f_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_varset_2d_empty_3f_)
___SET_R1(___CDR(___R1))
___SET_R1(___BOOLEAN(___NULLP(___R1)))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d__3c_
#undef ___PH_LBL0
#define ___PH_LBL0 475
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1 ___D_R2
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1 ___R_R2
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d__3c_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d__3c_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d__3c_)
___SET_R2(___VECTORREF(___R2,___FIX(8L)))
___SET_R1(___VECTORREF(___R1,___FIX(8L)))
___SET_R1(___BOOLEAN(___FIXLT(___R1,___R2)))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_member_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 477
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_member_3f_)
___DEF_P_HLBL(___L1_c_23_varset_2d_member_3f_)
___DEF_P_HLBL(___L2_c_23_varset_2d_member_3f_)
___DEF_P_HLBL(___L3_c_23_varset_2d_member_3f_)
___DEF_P_HLBL(___L4_c_23_varset_2d_member_3f_)
___DEF_P_HLBL(___L5_c_23_varset_2d_member_3f_)
___DEF_P_HLBL(___L6_c_23_varset_2d_member_3f_)
___DEF_P_HLBL(___L7_c_23_varset_2d_member_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_member_3f_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d_member_3f_)
___IF(___NOTFALSEP(___CAR(___R2)))
___GOTO(___L8_c_23_varset_2d_member_3f_)
___END_IF
___GOTO(___L13_c_23_varset_2d_member_3f_)
___DEF_SLBL(1,___L1_c_23_varset_2d_member_3f_)
___SETCAR(___STK(-5),___R1)
___SET_R2(___STK(-5))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___DEF_GLBL(___L8_c_23_varset_2d_member_3f_)
___SET_R2(___CAR(___R2))
___SET_STK(1,___R1)
___SET_R1(___VECTORLENGTH(___R2))
___SET_R3(___FIXSUB(___R1,___FIX(1L)))
___SET_R1(___R2)
___SET_R2(___FIX(0L))
___ADJFP(1)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_varset_2d_member_3f_)
___DEF_GLBL(___L9_c_23_varset_2d_member_3f_)
___IF(___NOT(___FIXLE(___R2,___R3)))
___GOTO(___L12_c_23_varset_2d_member_3f_)
___END_IF
___SET_R4(___FIXADD(___R2,___R3))
___SET_R4(___FIXQUO(___R4,___FIX(2L)))
___SET_STK(1,___VECTORREF(___R1,___R4))
___ADJFP(1)
___IF(___EQP(___STK(-1),___STK(0)))
___GOTO(___L11_c_23_varset_2d_member_3f_)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_STK(5,___R4)
___SET_R2(___STK(0))
___SET_R1(___STK(-1))
___ADJFP(10)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_varset_2d_member_3f_)
___SET_R0(___LBL(4))
___JUMPINT(___SET_NARGS(2),___PRC(475),___L_c_23_varset_2d__3c_)
___DEF_SLBL(4,___L4_c_23_varset_2d_member_3f_)
___IF(___NOT(___NOTFALSEP(___R1)))
___GOTO(___L10_c_23_varset_2d_member_3f_)
___END_IF
___SET_R3(___FIXSUB(___STK(-5),___FIX(1L)))
___SET_R2(___STK(-7))
___SET_R1(___STK(-8))
___SET_R0(___STK(-9))
___ADJFP(-11)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_varset_2d_member_3f_)
___GOTO(___L9_c_23_varset_2d_member_3f_)
___DEF_GLBL(___L10_c_23_varset_2d_member_3f_)
___SET_R3(___STK(-6))
___SET_R2(___FIXADD(___STK(-5),___FIX(1L)))
___SET_R1(___STK(-8))
___SET_R0(___STK(-9))
___ADJFP(-11)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_varset_2d_member_3f_)
___GOTO(___L9_c_23_varset_2d_member_3f_)
___DEF_GLBL(___L11_c_23_varset_2d_member_3f_)
___SET_R1(___TRU)
___ADJFP(-2)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L12_c_23_varset_2d_member_3f_)
___SET_R1(___FAL)
___ADJFP(-1)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L13_c_23_varset_2d_member_3f_)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R1(___CDR(___R2))
___ADJFP(8)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_varset_2d_member_3f_)
___SET_R0(___LBL(1))
___JUMPINT(___SET_NARGS(1),___PRC(111),___L_c_23_list_2d__3e_vect)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_adjoin
#undef ___PH_LBL0
#define ___PH_LBL0 486
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_adjoin)
___DEF_P_HLBL(___L1_c_23_varset_2d_adjoin)
___DEF_P_HLBL(___L2_c_23_varset_2d_adjoin)
___DEF_P_HLBL(___L3_c_23_varset_2d_adjoin)
___DEF_P_HLBL(___L4_c_23_varset_2d_adjoin)
___DEF_P_HLBL(___L5_c_23_varset_2d_adjoin)
___DEF_P_HLBL(___L6_c_23_varset_2d_adjoin)
___DEF_P_HLBL(___L7_c_23_varset_2d_adjoin)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_adjoin)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d_adjoin)
___SET_STK(1,___R1)
___SET_R1(___CDR(___R1))
___SET_STK(2,___R2)
___SET_R2(___R1)
___SET_R1(___STK(2))
___SET_R3(___NUL)
___ADJFP(1)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_varset_2d_adjoin)
___GOTO(___L8_c_23_varset_2d_adjoin)
___DEF_SLBL(2,___L2_c_23_varset_2d_adjoin)
___IF(___NOTFALSEP(___R1))
___GOTO(___L11_c_23_varset_2d_adjoin)
___END_IF
___SET_R1(___CAR(___STK(-4)))
___IF(___EQP(___R1,___STK(-5)))
___GOTO(___L12_c_23_varset_2d_adjoin)
___END_IF
___SET_R1(___CAR(___STK(-4)))
___SET_R3(___CONS(___R1,___STK(-3)))
___SET_R2(___CDR(___STK(-4)))
___SET_R1(___STK(-5))
___SET_R0(___STK(-6))
___ADJFP(-7)
___CHECK_HEAP(3,4096)
___DEF_SLBL(3,___L3_c_23_varset_2d_adjoin)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_varset_2d_adjoin)
___DEF_GLBL(___L8_c_23_varset_2d_adjoin)
___IF(___NOT(___NULLP(___R2)))
___GOTO(___L10_c_23_varset_2d_adjoin)
___END_IF
___DEF_GLBL(___L9_c_23_varset_2d_adjoin)
___SET_R2(___CONS(___R1,___R2))
___SET_R1(___R3)
___CHECK_HEAP(5,4096)
___DEF_SLBL(5,___L5_c_23_varset_2d_adjoin)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_varset_2d_adjoin)
___ADJFP(-1)
___JUMPINT(___SET_NARGS(2),___PRC(439),___L_c_23_varset_2d_reverse_2d_append_21_)
___DEF_GLBL(___L10_c_23_varset_2d_adjoin)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R2(___CAR(___R2))
___ADJFP(7)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_varset_2d_adjoin)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(475),___L_c_23_varset_2d__3c_)
___DEF_GLBL(___L11_c_23_varset_2d_adjoin)
___SET_R3(___STK(-3))
___SET_R2(___STK(-4))
___SET_R1(___STK(-5))
___SET_R0(___STK(-6))
___ADJFP(-7)
___GOTO(___L9_c_23_varset_2d_adjoin)
___DEF_GLBL(___L12_c_23_varset_2d_adjoin)
___SET_R1(___STK(-7))
___ADJFP(-8)
___JUMPPRM(___NOTHING,___STK(2))
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_remove
#undef ___PH_LBL0
#define ___PH_LBL0 495
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_remove)
___DEF_P_HLBL(___L1_c_23_varset_2d_remove)
___DEF_P_HLBL(___L2_c_23_varset_2d_remove)
___DEF_P_HLBL(___L3_c_23_varset_2d_remove)
___DEF_P_HLBL(___L4_c_23_varset_2d_remove)
___DEF_P_HLBL(___L5_c_23_varset_2d_remove)
___DEF_P_HLBL(___L6_c_23_varset_2d_remove)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_remove)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d_remove)
___SET_STK(1,___R1)
___SET_R1(___CDR(___R1))
___SET_STK(2,___R2)
___SET_R2(___R1)
___SET_R1(___STK(2))
___SET_R3(___NUL)
___ADJFP(1)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_varset_2d_remove)
___GOTO(___L7_c_23_varset_2d_remove)
___DEF_SLBL(2,___L2_c_23_varset_2d_remove)
___IF(___NOTFALSEP(___R1))
___GOTO(___L8_c_23_varset_2d_remove)
___END_IF
___SET_R1(___CAR(___STK(-4)))
___IF(___EQP(___R1,___STK(-5)))
___GOTO(___L10_c_23_varset_2d_remove)
___END_IF
___SET_R1(___CAR(___STK(-4)))
___SET_R3(___CONS(___R1,___STK(-3)))
___SET_R2(___CDR(___STK(-4)))
___SET_R1(___STK(-5))
___SET_R0(___STK(-6))
___ADJFP(-7)
___CHECK_HEAP(3,4096)
___DEF_SLBL(3,___L3_c_23_varset_2d_remove)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_varset_2d_remove)
___DEF_GLBL(___L7_c_23_varset_2d_remove)
___IF(___NULLP(___R2))
___GOTO(___L9_c_23_varset_2d_remove)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R2(___CAR(___R2))
___ADJFP(7)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_varset_2d_remove)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(475),___L_c_23_varset_2d__3c_)
___DEF_GLBL(___L8_c_23_varset_2d_remove)
___SET_R0(___STK(-6))
___ADJFP(-7)
___DEF_GLBL(___L9_c_23_varset_2d_remove)
___SET_R1(___STK(0))
___ADJFP(-1)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L10_c_23_varset_2d_remove)
___SET_R2(___CDR(___STK(-4)))
___SET_R1(___STK(-3))
___SET_R0(___STK(-6))
___POLL(6)
___DEF_SLBL(6,___L6_c_23_varset_2d_remove)
___ADJFP(-8)
___JUMPINT(___SET_NARGS(2),___PRC(439),___L_c_23_varset_2d_reverse_2d_append_21_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_equal_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 503
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_equal_3f_)
___DEF_P_HLBL(___L1_c_23_varset_2d_equal_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_equal_3f_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d_equal_3f_)
___GOTO(___L3_c_23_varset_2d_equal_3f_)
___DEF_GLBL(___L2_c_23_varset_2d_equal_3f_)
___IF(___NULLP(___R1))
___GOTO(___L4_c_23_varset_2d_equal_3f_)
___END_IF
___IF(___NULLP(___R2))
___GOTO(___L5_c_23_varset_2d_equal_3f_)
___END_IF
___SET_R3(___CAR(___R2))
___SET_R4(___CAR(___R1))
___IF(___NOT(___EQP(___R4,___R3)))
___GOTO(___L5_c_23_varset_2d_equal_3f_)
___END_IF
___DEF_GLBL(___L3_c_23_varset_2d_equal_3f_)
___SET_R2(___CDR(___R2))
___SET_R1(___CDR(___R1))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_varset_2d_equal_3f_)
___GOTO(___L2_c_23_varset_2d_equal_3f_)
___DEF_GLBL(___L4_c_23_varset_2d_equal_3f_)
___SET_R1(___BOOLEAN(___NULLP(___R2)))
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L5_c_23_varset_2d_equal_3f_)
___SET_R1(___FAL)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_difference
#undef ___PH_LBL0
#define ___PH_LBL0 506
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_difference)
___DEF_P_HLBL(___L1_c_23_varset_2d_difference)
___DEF_P_HLBL(___L2_c_23_varset_2d_difference)
___DEF_P_HLBL(___L3_c_23_varset_2d_difference)
___DEF_P_HLBL(___L4_c_23_varset_2d_difference)
___DEF_P_HLBL(___L5_c_23_varset_2d_difference)
___DEF_P_HLBL(___L6_c_23_varset_2d_difference)
___DEF_P_HLBL(___L7_c_23_varset_2d_difference)
___DEF_P_HLBL(___L8_c_23_varset_2d_difference)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_difference)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d_difference)
___SET_R2(___CDR(___R2))
___SET_R1(___CDR(___R1))
___SET_R3(___NUL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_varset_2d_difference)
___GOTO(___L9_c_23_varset_2d_difference)
___DEF_SLBL(2,___L2_c_23_varset_2d_difference)
___IF(___NOTFALSEP(___R1))
___GOTO(___L12_c_23_varset_2d_difference)
___END_IF
___IF(___EQP(___STK(-6),___STK(-11)))
___GOTO(___L13_c_23_varset_2d_difference)
___END_IF
___SET_R3(___STK(-7))
___SET_R2(___CDR(___STK(-8)))
___SET_R1(___STK(-9))
___SET_R0(___STK(-10))
___ADJFP(-12)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_varset_2d_difference)
___DEF_GLBL(___L9_c_23_varset_2d_difference)
___IF(___NOT(___NULLP(___R1)))
___GOTO(___L11_c_23_varset_2d_difference)
___END_IF
___DEF_GLBL(___L10_c_23_varset_2d_difference)
___SET_R2(___R1)
___SET_R1(___R3)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_varset_2d_difference)
___JUMPINT(___SET_NARGS(2),___PRC(439),___L_c_23_varset_2d_reverse_2d_append_21_)
___DEF_GLBL(___L11_c_23_varset_2d_difference)
___IF(___NULLP(___R2))
___GOTO(___L10_c_23_varset_2d_difference)
___END_IF
___SET_R4(___CAR(___R1))
___SET_STK(1,___CAR(___R2))
___SET_STK(2,___R0)
___SET_STK(3,___R1)
___SET_STK(4,___R2)
___SET_STK(5,___R3)
___SET_STK(6,___R4)
___SET_R2(___STK(1))
___SET_R1(___R4)
___ADJFP(12)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_varset_2d_difference)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(475),___L_c_23_varset_2d__3c_)
___DEF_GLBL(___L12_c_23_varset_2d_difference)
___SET_R3(___CONS(___STK(-6),___STK(-7)))
___SET_R2(___STK(-8))
___SET_R1(___CDR(___STK(-9)))
___SET_R0(___STK(-10))
___ADJFP(-12)
___CHECK_HEAP(6,4096)
___DEF_SLBL(6,___L6_c_23_varset_2d_difference)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_varset_2d_difference)
___GOTO(___L9_c_23_varset_2d_difference)
___DEF_GLBL(___L13_c_23_varset_2d_difference)
___SET_R3(___STK(-7))
___SET_R2(___CDR(___STK(-8)))
___SET_R1(___CDR(___STK(-9)))
___SET_R0(___STK(-10))
___ADJFP(-12)
___POLL(8)
___DEF_SLBL(8,___L8_c_23_varset_2d_difference)
___GOTO(___L9_c_23_varset_2d_difference)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_union
#undef ___PH_LBL0
#define ___PH_LBL0 516
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_union)
___DEF_P_HLBL(___L1_c_23_varset_2d_union)
___DEF_P_HLBL(___L2_c_23_varset_2d_union)
___DEF_P_HLBL(___L3_c_23_varset_2d_union)
___DEF_P_HLBL(___L4_c_23_varset_2d_union)
___DEF_P_HLBL(___L5_c_23_varset_2d_union)
___DEF_P_HLBL(___L6_c_23_varset_2d_union)
___DEF_P_HLBL(___L7_c_23_varset_2d_union)
___DEF_P_HLBL(___L8_c_23_varset_2d_union)
___DEF_P_HLBL(___L9_c_23_varset_2d_union)
___DEF_P_HLBL(___L10_c_23_varset_2d_union)
___DEF_P_HLBL(___L11_c_23_varset_2d_union)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_union)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d_union)
___SET_R2(___CDR(___R2))
___SET_R1(___CDR(___R1))
___SET_R3(___NUL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_varset_2d_union)
___GOTO(___L12_c_23_varset_2d_union)
___DEF_SLBL(2,___L2_c_23_varset_2d_union)
___IF(___NOTFALSEP(___R1))
___GOTO(___L17_c_23_varset_2d_union)
___END_IF
___SET_R3(___CONS(___STK(-11),___STK(-7)))
___SET_R2(___CDR(___STK(-8)))
___SET_R1(___STK(-9))
___SET_R0(___STK(-10))
___ADJFP(-12)
___CHECK_HEAP(3,4096)
___DEF_SLBL(3,___L3_c_23_varset_2d_union)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_varset_2d_union)
___DEF_GLBL(___L12_c_23_varset_2d_union)
___IF(___NOT(___NULLP(___R1)))
___GOTO(___L14_c_23_varset_2d_union)
___END_IF
___SET_R1(___R3)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_varset_2d_union)
___DEF_GLBL(___L13_c_23_varset_2d_union)
___JUMPINT(___SET_NARGS(2),___PRC(439),___L_c_23_varset_2d_reverse_2d_append_21_)
___DEF_GLBL(___L14_c_23_varset_2d_union)
___IF(___NOT(___NULLP(___R2)))
___GOTO(___L15_c_23_varset_2d_union)
___END_IF
___SET_R2(___R1)
___SET_R1(___R3)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_varset_2d_union)
___GOTO(___L13_c_23_varset_2d_union)
___DEF_GLBL(___L15_c_23_varset_2d_union)
___SET_R4(___CAR(___R1))
___SET_STK(1,___CAR(___R2))
___ADJFP(1)
___IF(___NOT(___EQP(___R4,___STK(0))))
___GOTO(___L16_c_23_varset_2d_union)
___END_IF
___SET_R3(___CONS(___R4,___R3))
___SET_R2(___CDR(___R2))
___SET_R1(___CDR(___R1))
___ADJFP(-1)
___CHECK_HEAP(7,4096)
___DEF_SLBL(7,___L7_c_23_varset_2d_union)
___POLL(8)
___DEF_SLBL(8,___L8_c_23_varset_2d_union)
___GOTO(___L12_c_23_varset_2d_union)
___DEF_GLBL(___L16_c_23_varset_2d_union)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_STK(5,___R4)
___SET_R2(___STK(0))
___SET_R1(___R4)
___ADJFP(11)
___POLL(9)
___DEF_SLBL(9,___L9_c_23_varset_2d_union)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(475),___L_c_23_varset_2d__3c_)
___DEF_GLBL(___L17_c_23_varset_2d_union)
___SET_R3(___CONS(___STK(-6),___STK(-7)))
___SET_R2(___STK(-8))
___SET_R1(___CDR(___STK(-9)))
___SET_R0(___STK(-10))
___ADJFP(-12)
___CHECK_HEAP(10,4096)
___DEF_SLBL(10,___L10_c_23_varset_2d_union)
___POLL(11)
___DEF_SLBL(11,___L11_c_23_varset_2d_union)
___GOTO(___L12_c_23_varset_2d_union)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_intersection
#undef ___PH_LBL0
#define ___PH_LBL0 529
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_intersection)
___DEF_P_HLBL(___L1_c_23_varset_2d_intersection)
___DEF_P_HLBL(___L2_c_23_varset_2d_intersection)
___DEF_P_HLBL(___L3_c_23_varset_2d_intersection)
___DEF_P_HLBL(___L4_c_23_varset_2d_intersection)
___DEF_P_HLBL(___L5_c_23_varset_2d_intersection)
___DEF_P_HLBL(___L6_c_23_varset_2d_intersection)
___DEF_P_HLBL(___L7_c_23_varset_2d_intersection)
___DEF_P_HLBL(___L8_c_23_varset_2d_intersection)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_intersection)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d_intersection)
___SET_R2(___CDR(___R2))
___SET_R1(___CDR(___R1))
___SET_R3(___NUL)
___POLL(1)
___DEF_SLBL(1,___L1_c_23_varset_2d_intersection)
___GOTO(___L9_c_23_varset_2d_intersection)
___DEF_SLBL(2,___L2_c_23_varset_2d_intersection)
___IF(___NOTFALSEP(___R1))
___GOTO(___L13_c_23_varset_2d_intersection)
___END_IF
___SET_R3(___STK(-3))
___SET_R2(___CDR(___STK(-4)))
___SET_R1(___STK(-5))
___SET_R0(___STK(-6))
___ADJFP(-8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_varset_2d_intersection)
___DEF_GLBL(___L9_c_23_varset_2d_intersection)
___IF(___NOT(___NULLP(___R1)))
___GOTO(___L11_c_23_varset_2d_intersection)
___END_IF
___DEF_GLBL(___L10_c_23_varset_2d_intersection)
___SET_R1(___R3)
___SET_R2(___NUL)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_varset_2d_intersection)
___JUMPINT(___SET_NARGS(2),___PRC(439),___L_c_23_varset_2d_reverse_2d_append_21_)
___DEF_GLBL(___L11_c_23_varset_2d_intersection)
___IF(___NULLP(___R2))
___GOTO(___L10_c_23_varset_2d_intersection)
___END_IF
___SET_R4(___CAR(___R1))
___SET_STK(1,___CAR(___R2))
___ADJFP(1)
___IF(___NOT(___EQP(___R4,___STK(0))))
___GOTO(___L12_c_23_varset_2d_intersection)
___END_IF
___SET_R3(___CONS(___R4,___R3))
___SET_R2(___CDR(___R2))
___SET_R1(___CDR(___R1))
___ADJFP(-1)
___CHECK_HEAP(5,4096)
___DEF_SLBL(5,___L5_c_23_varset_2d_intersection)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_varset_2d_intersection)
___GOTO(___L9_c_23_varset_2d_intersection)
___DEF_GLBL(___L12_c_23_varset_2d_intersection)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_STK(4,___R3)
___SET_R2(___STK(0))
___SET_R1(___R4)
___ADJFP(7)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_varset_2d_intersection)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(475),___L_c_23_varset_2d__3c_)
___DEF_GLBL(___L13_c_23_varset_2d_intersection)
___SET_R3(___STK(-3))
___SET_R2(___STK(-4))
___SET_R1(___CDR(___STK(-5)))
___SET_R0(___STK(-6))
___ADJFP(-8)
___POLL(8)
___DEF_SLBL(8,___L8_c_23_varset_2d_intersection)
___GOTO(___L9_c_23_varset_2d_intersection)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_intersects_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 539
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_intersects_3f_)
___DEF_P_HLBL(___L1_c_23_varset_2d_intersects_3f_)
___DEF_P_HLBL(___L2_c_23_varset_2d_intersects_3f_)
___DEF_P_HLBL(___L3_c_23_varset_2d_intersects_3f_)
___DEF_P_HLBL(___L4_c_23_varset_2d_intersects_3f_)
___DEF_P_HLBL(___L5_c_23_varset_2d_intersects_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_intersects_3f_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_varset_2d_intersects_3f_)
___SET_R2(___CDR(___R2))
___SET_R1(___CDR(___R1))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_varset_2d_intersects_3f_)
___GOTO(___L6_c_23_varset_2d_intersects_3f_)
___DEF_SLBL(2,___L2_c_23_varset_2d_intersects_3f_)
___IF(___NOTFALSEP(___R1))
___GOTO(___L9_c_23_varset_2d_intersects_3f_)
___END_IF
___SET_R2(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_varset_2d_intersects_3f_)
___DEF_GLBL(___L6_c_23_varset_2d_intersects_3f_)
___IF(___NULLP(___R1))
___GOTO(___L8_c_23_varset_2d_intersects_3f_)
___END_IF
___IF(___NULLP(___R2))
___GOTO(___L8_c_23_varset_2d_intersects_3f_)
___END_IF
___SET_R3(___CAR(___R1))
___SET_R4(___CAR(___R2))
___IF(___EQP(___R3,___R4))
___GOTO(___L7_c_23_varset_2d_intersects_3f_)
___END_IF
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___R4)
___SET_R1(___R3)
___ADJFP(8)
___POLL(4)
___DEF_SLBL(4,___L4_c_23_varset_2d_intersects_3f_)
___SET_R0(___LBL(2))
___JUMPINT(___SET_NARGS(2),___PRC(475),___L_c_23_varset_2d__3c_)
___DEF_GLBL(___L7_c_23_varset_2d_intersects_3f_)
___SET_R1(___TRU)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L8_c_23_varset_2d_intersects_3f_)
___SET_R1(___FAL)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L9_c_23_varset_2d_intersects_3f_)
___SET_R2(___STK(-5))
___SET_R1(___CDR(___STK(-6)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_varset_2d_intersects_3f_)
___GOTO(___L6_c_23_varset_2d_intersects_3f_)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_varset_2d_union_2d_multi
#undef ___PH_LBL0
#define ___PH_LBL0 546
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_varset_2d_union_2d_multi)
___DEF_P_HLBL(___L1_c_23_varset_2d_union_2d_multi)
___DEF_P_HLBL(___L2_c_23_varset_2d_union_2d_multi)
___DEF_P_HLBL(___L3_c_23_varset_2d_union_2d_multi)
___DEF_P_HLBL(___L4_c_23_varset_2d_union_2d_multi)
___DEF_P_HLBL(___L5_c_23_varset_2d_union_2d_multi)
___DEF_P_HLBL(___L6_c_23_varset_2d_union_2d_multi)
___DEF_P_HLBL(___L7_c_23_varset_2d_union_2d_multi)
___DEF_P_HLBL(___L8_c_23_varset_2d_union_2d_multi)
___DEF_P_HLBL(___L9_c_23_varset_2d_union_2d_multi)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_varset_2d_union_2d_multi)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_varset_2d_union_2d_multi)
___IF(___NULLP(___R1))
___GOTO(___L12_c_23_varset_2d_union_2d_multi)
___END_IF
___GOTO(___L15_c_23_varset_2d_union_2d_multi)
___DEF_SLBL(1,___L1_c_23_varset_2d_union_2d_multi)
___SET_R2(___CONS(___R1,___STK(-5)))
___SET_R1(___CDDR(___STK(-6)))
___SET_R0(___STK(-7))
___ADJFP(-8)
___CHECK_HEAP(2,4096)
___DEF_SLBL(2,___L2_c_23_varset_2d_union_2d_multi)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_varset_2d_union_2d_multi)
___DEF_GLBL(___L10_c_23_varset_2d_union_2d_multi)
___IF(___NULLP(___R1))
___GOTO(___L13_c_23_varset_2d_union_2d_multi)
___END_IF
___SET_R3(___CDR(___R1))
___IF(___NOT(___NULLP(___R3)))
___GOTO(___L14_c_23_varset_2d_union_2d_multi)
___END_IF
___SET_R1(___CAR(___R1))
___SET_R1(___CONS(___R1,___R2))
___CHECK_HEAP(4,4096)
___DEF_SLBL(4,___L4_c_23_varset_2d_union_2d_multi)
___POLL(5)
___DEF_SLBL(5,___L5_c_23_varset_2d_union_2d_multi)
___DEF_GLBL(___L11_c_23_varset_2d_union_2d_multi)
___IF(___NOT(___NULLP(___R1)))
___GOTO(___L15_c_23_varset_2d_union_2d_multi)
___END_IF
___DEF_GLBL(___L12_c_23_varset_2d_union_2d_multi)
___POLL(6)
___DEF_SLBL(6,___L6_c_23_varset_2d_union_2d_multi)
___JUMPINT(___SET_NARGS(0),___PRC(448),___L_c_23_varset_2d_empty)
___DEF_GLBL(___L13_c_23_varset_2d_union_2d_multi)
___SET_R1(___R2)
___POLL(7)
___DEF_SLBL(7,___L7_c_23_varset_2d_union_2d_multi)
___GOTO(___L11_c_23_varset_2d_union_2d_multi)
___DEF_GLBL(___L14_c_23_varset_2d_union_2d_multi)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R2)
___SET_R2(___CADR(___R1))
___SET_R1(___CAR(___R1))
___ADJFP(8)
___POLL(8)
___DEF_SLBL(8,___L8_c_23_varset_2d_union_2d_multi)
___SET_R0(___LBL(1))
___JUMPINT(___SET_NARGS(2),___PRC(516),___L_c_23_varset_2d_union)
___DEF_GLBL(___L15_c_23_varset_2d_union_2d_multi)
___SET_R2(___CDR(___R1))
___IF(___NULLP(___R2))
___GOTO(___L16_c_23_varset_2d_union_2d_multi)
___END_IF
___SET_R2(___NUL)
___POLL(9)
___DEF_SLBL(9,___L9_c_23_varset_2d_union_2d_multi)
___GOTO(___L10_c_23_varset_2d_union_2d_multi)
___DEF_GLBL(___L16_c_23_varset_2d_union_2d_multi)
___SET_R1(___CAR(___R1))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_n_2d_ary
#undef ___PH_LBL0
#define ___PH_LBL0 557
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_FP ___W_R0 ___W_R1 ___W_R2 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_n_2d_ary)
___DEF_P_HLBL(___L1_c_23_n_2d_ary)
___DEF_P_HLBL(___L2_c_23_n_2d_ary)
___DEF_P_HLBL(___L3_c_23_n_2d_ary)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_n_2d_ary)
___IF_NARGS_EQ(3,___NOTHING)
___WRONG_NARGS(0,3,0,0)
___DEF_GLBL(___L_c_23_n_2d_ary)
___IF(___NULLP(___R3))
___GOTO(___L5_c_23_n_2d_ary)
___END_IF
___GOTO(___L4_c_23_n_2d_ary)
___DEF_SLBL(1,___L1_c_23_n_2d_ary)
___SET_R2(___R1)
___SET_R3(___CDR(___STK(-5)))
___SET_R1(___STK(-6))
___SET_R0(___STK(-7))
___ADJFP(-8)
___POLL(2)
___DEF_SLBL(2,___L2_c_23_n_2d_ary)
___IF(___NULLP(___R3))
___GOTO(___L5_c_23_n_2d_ary)
___END_IF
___DEF_GLBL(___L4_c_23_n_2d_ary)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_STK(3,___R3)
___SET_R1(___CAR(___R3))
___SET_STK(4,___R2)
___SET_R2(___R1)
___SET_R1(___STK(4))
___ADJFP(8)
___POLL(3)
___DEF_SLBL(3,___L3_c_23_n_2d_ary)
___SET_R0(___LBL(1))
___JUMPGENNOTSAFE(___SET_NARGS(2),___STK(-6))
___DEF_GLBL(___L5_c_23_n_2d_ary)
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_list_2d__3e_queue
#undef ___PH_LBL0
#define ___PH_LBL0 562
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_FP ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_FP ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_FP ___W_R0 ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_list_2d__3e_queue)
___DEF_P_HLBL(___L1_c_23_list_2d__3e_queue)
___DEF_P_HLBL(___L2_c_23_list_2d__3e_queue)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_list_2d__3e_queue)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_list_2d__3e_queue)
___IF(___PAIRP(___R1))
___GOTO(___L4_c_23_list_2d__3e_queue)
___END_IF
___SET_STK(1,___R1)
___SET_R1(___NUL)
___ADJFP(1)
___GOTO(___L3_c_23_list_2d__3e_queue)
___DEF_SLBL(1,___L1_c_23_list_2d__3e_queue)
___SET_R0(___STK(-7))
___SET_STK(-7,___STK(-6))
___ADJFP(-7)
___DEF_GLBL(___L3_c_23_list_2d__3e_queue)
___SET_R1(___CONS(___STK(0),___R1))
___ADJFP(-1)
___CHECK_HEAP(2,4096)
___DEF_SLBL(2,___L2_c_23_list_2d__3e_queue)
___JUMPPRM(___NOTHING,___R0)
___DEF_GLBL(___L4_c_23_list_2d__3e_queue)
___SET_STK(1,___R0)
___SET_STK(2,___R1)
___SET_R0(___LBL(1))
___ADJFP(8)
___JUMPPRM(___SET_NARGS(1),___PRM_last_2d_pair)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_queue_2d__3e_list
#undef ___PH_LBL0
#define ___PH_LBL0 566
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_queue_2d__3e_list)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_queue_2d__3e_list)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_queue_2d__3e_list)
___SET_R1(___CAR(___R1))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_queue_2d_empty
#undef ___PH_LBL0
#define ___PH_LBL0 568
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_queue_2d_empty)
___DEF_P_HLBL(___L1_c_23_queue_2d_empty)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_queue_2d_empty)
___IF_NARGS_EQ(0,___NOTHING)
___WRONG_NARGS(0,0,0,0)
___DEF_GLBL(___L_c_23_queue_2d_empty)
___SET_R1(___CONS(___NUL,___NUL))
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_queue_2d_empty)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_queue_2d_empty_3f_
#undef ___PH_LBL0
#define ___PH_LBL0 571
#undef ___PD_ALL
#define ___PD_ALL ___D_R0 ___D_R1
#undef ___PR_ALL
#define ___PR_ALL ___R_R0 ___R_R1
#undef ___PW_ALL
#define ___PW_ALL ___W_R1
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_queue_2d_empty_3f_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_queue_2d_empty_3f_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_queue_2d_empty_3f_)
___SET_R1(___CAR(___R1))
___SET_R1(___BOOLEAN(___NULLP(___R1)))
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_queue_2d_get_21_
#undef ___PH_LBL0
#define ___PH_LBL0 573
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R0 ___D_R1 ___D_R2 ___D_R3
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R0 ___R_R1 ___R_R2 ___R_R3
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2 ___W_R3
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_queue_2d_get_21_)
___DEF_P_HLBL(___L1_c_23_queue_2d_get_21_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_queue_2d_get_21_)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_queue_2d_get_21_)
___SET_R2(___CAR(___R1))
___IF(___NOT(___NULLP(___R2)))
___GOTO(___L2_c_23_queue_2d_get_21_)
___END_IF
___SET_R1(___SUB(17))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_queue_2d_get_21_)
___SET_NARGS(1) ___JUMPINT(___NOTHING,___PRC(268),___L0_c_23_compiler_2d_internal_2d_error)
___DEF_GLBL(___L2_c_23_queue_2d_get_21_)
___SET_R2(___CAAR(___R1))
___SET_R3(___CDAR(___R1))
___SETCAR(___R1,___R3)
___SET_R3(___CAR(___R1))
___IF(___NOT(___NULLP(___R3)))
___GOTO(___L3_c_23_queue_2d_get_21_)
___END_IF
___SETCDR(___R1,___NUL)
___DEF_GLBL(___L3_c_23_queue_2d_get_21_)
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_queue_2d_put_21_
#undef ___PH_LBL0
#define ___PH_LBL0 576
#undef ___PD_ALL
#define ___PD_ALL ___D_HEAP ___D_R0 ___D_R1 ___D_R2 ___D_R3 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_HEAP ___R_R0 ___R_R1 ___R_R2 ___R_R3 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_HEAP ___W_R1 ___W_R3 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_queue_2d_put_21_)
___DEF_P_HLBL(___L1_c_23_queue_2d_put_21_)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_queue_2d_put_21_)
___IF_NARGS_EQ(2,___NOTHING)
___WRONG_NARGS(0,2,0,0)
___DEF_GLBL(___L_c_23_queue_2d_put_21_)
___SET_R3(___CONS(___R2,___NUL))
___SET_R4(___CAR(___R1))
___CHECK_HEAP(1,4096)
___DEF_SLBL(1,___L1_c_23_queue_2d_put_21_)
___IF(___NOT(___NULLP(___R4)))
___GOTO(___L2_c_23_queue_2d_put_21_)
___END_IF
___SETCAR(___R1,___R3)
___GOTO(___L3_c_23_queue_2d_put_21_)
___DEF_GLBL(___L2_c_23_queue_2d_put_21_)
___SET_R4(___CDR(___R1))
___SETCDR(___R4,___R3)
___DEF_GLBL(___L3_c_23_queue_2d_put_21_)
___SETCDR(___R1,___R3)
___SET_R1(___R2)
___JUMPPRM(___NOTHING,___R0)
___END_P_SW
___END_P_COD
#undef ___PH_PROC
#define ___PH_PROC ___H_c_23_throw_2d_to_2d_exception_2d_handler
#undef ___PH_LBL0
#define ___PH_LBL0 579
#undef ___PD_ALL
#define ___PD_ALL ___D_FP ___D_R1 ___D_R2 ___D_R4
#undef ___PR_ALL
#define ___PR_ALL ___R_FP ___R_R1 ___R_R2 ___R_R4
#undef ___PW_ALL
#define ___PW_ALL ___W_R1 ___W_R2 ___W_R4
___BEGIN_P_COD
___BEGIN_P_HLBL
___DEF_P_HLBL_INTRO
___DEF_P_HLBL(___L0_c_23_throw_2d_to_2d_exception_2d_handler)
___DEF_P_HLBL(___L1_c_23_throw_2d_to_2d_exception_2d_handler)
___END_P_HLBL
___BEGIN_P_SW
___DEF_SLBL(0,___L0_c_23_throw_2d_to_2d_exception_2d_handler)
___IF_NARGS_EQ(1,___NOTHING)
___WRONG_NARGS(0,1,0,0)
___DEF_GLBL(___L_c_23_throw_2d_to_2d_exception_2d_handler)
___SET_R2(___R1)
___SET_R1(___SUB(18))
___POLL(1)
___DEF_SLBL(1,___L1_c_23_throw_2d_to_2d_exception_2d_handler)
___JUMPGLONOTSAFE(___SET_NARGS(2),100,___G_c_23_fatal_2d_err)
___END_P_SW
___END_P_COD
___END_M_SW
___END_M_COD
___BEGIN_LBL
___DEF_LBL_INTRO(___H___utils_23_,"_utils#",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H___utils_23_,0,-1)
,___DEF_LBL_RET(___H___utils_23_,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H___utils_23_,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_INTRO(___H_c_23_append_2d_lists,"c#append-lists",___REF_FAL,8,0)
,___DEF_LBL_PROC(___H_c_23_append_2d_lists,1,-1)
,___DEF_LBL_RET(___H_c_23_append_2d_lists,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_append_2d_lists,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_append_2d_lists,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_append_2d_lists,___IFD(___RETI,8,0,0x3f0dL))
,___DEF_LBL_RET(___H_c_23_append_2d_lists,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_append_2d_lists,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_append_2d_lists,___IFD(___RETN,5,0,0xdL))
,___DEF_LBL_INTRO(___H_c_23_reverse_2d_append_21_,"c#reverse-append!",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_reverse_2d_append_21_,2,-1)
,___DEF_LBL_RET(___H_c_23_reverse_2d_append_21_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_list_2d_length,"c#list-length",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_c_23_list_2d_length,1,-1)
,___DEF_LBL_RET(___H_c_23_list_2d_length,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d_length,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_make_2d_counter,"c#make-counter",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_c_23_make_2d_counter,1,-1)
,___DEF_LBL_RET(___H_c_23_make_2d_counter,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_PROC(___H_c_23_make_2d_counter,0,1)
,___DEF_LBL_INTRO(___H_c_23_for_2d_each_2d_index,"c#for-each-index",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H_c_23_for_2d_each_2d_index,2,-1)
,___DEF_LBL_RET(___H_c_23_for_2d_each_2d_index,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_for_2d_each_2d_index,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_for_2d_each_2d_index,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_for_2d_each_2d_index,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_INTRO(___H_c_23_map_2d_index,"c#map-index",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H_c_23_map_2d_index,2,-1)
,___DEF_LBL_RET(___H_c_23_map_2d_index,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_map_2d_index,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H_c_23_map_2d_index,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_map_2d_index,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_map_2d_index,___IFD(___RETI,8,1,0x3f1fL))
,___DEF_LBL_RET(___H_c_23_map_2d_index,___IFD(___RETI,1,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_pos_2d_in_2d_list,"c#pos-in-list",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_c_23_pos_2d_in_2d_list,2,-1)
,___DEF_LBL_RET(___H_c_23_pos_2d_in_2d_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_pos_2d_in_2d_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_object_2d_pos_2d_in_2d_list,"c#object-pos-in-list",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_object_2d_pos_2d_in_2d_list,2,-1)
,___DEF_LBL_RET(___H_c_23_object_2d_pos_2d_in_2d_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_object_2d_pos_2d_in_2d_list,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_object_2d_pos_2d_in_2d_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_string_2d_pos_2d_in_2d_list,"c#string-pos-in-list",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_string_2d_pos_2d_in_2d_list,2,-1)
,___DEF_LBL_RET(___H_c_23_string_2d_pos_2d_in_2d_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_string_2d_pos_2d_in_2d_list,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_string_2d_pos_2d_in_2d_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_take,"take",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H_take,2,-1)
,___DEF_LBL_RET(___H_take,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_take,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_take,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_take,___IFD(___RETI,1,0,0x3f1L))
,___DEF_LBL_INTRO(___H_drop,"drop",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_drop,2,-1)
,___DEF_LBL_RET(___H_drop,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_drop,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_pair_2d_up,"c#pair-up",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H_c_23_pair_2d_up,2,-1)
,___DEF_LBL_RET(___H_c_23_pair_2d_up,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_pair_2d_up,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H_c_23_pair_2d_up,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_pair_2d_up,___IFD(___RETI,1,0,0x3f1L))
,___DEF_LBL_INTRO(___H_last_2d_pair,"last-pair",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_last_2d_pair,1,-1)
,___DEF_LBL_RET(___H_last_2d_pair,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_last_2d_pair,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_keep,"c#keep",___REF_FAL,8,0)
,___DEF_LBL_PROC(___H_c_23_keep,2,-1)
,___DEF_LBL_RET(___H_c_23_keep,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_keep,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_keep,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_keep,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_keep,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H_c_23_keep,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_keep,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_every_3f_,"c#every?",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_every_3f_,2,-1)
,___DEF_LBL_RET(___H_c_23_every_3f_,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_every_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_every_3f_,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_INTRO(___H_c_23_remq,"c#remq",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H_c_23_remq,2,-1)
,___DEF_LBL_RET(___H_c_23_remq,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_remq,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_remq,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_remq,___IFD(___RETI,1,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_sort_2d_list,"c#sort-list",___REF_FAL,17,0)
,___DEF_LBL_PROC(___H_c_23_sort_2d_list,2,-1)
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETN,5,0,0xbL))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETI,1,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETN,5,0,0xbL))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETN,9,1,0x22L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETI,2,1,0x3f2L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETN,5,1,0x3L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___IFD(___RETI,2,1,0x3f2L))
,___DEF_LBL_RET(___H_c_23_sort_2d_list,___OFD(___RETI,12,1,0x3f03fL))
,___DEF_LBL_INTRO(___H_c_23_list_2d__3e_vect,"c#list->vect",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H_c_23_list_2d__3e_vect,1,-1)
,___DEF_LBL_RET(___H_c_23_list_2d__3e_vect,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_vect,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_vect,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_vect,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_vect,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_vect_2d__3e_list,"c#vect->list",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_vect_2d__3e_list,1,-1)
,___DEF_LBL_RET(___H_c_23_vect_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_vect_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_vect_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_list_2d__3e_str,"c#list->str",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H_c_23_list_2d__3e_str,1,-1)
,___DEF_LBL_RET(___H_c_23_list_2d__3e_str,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_str,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_str,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_str,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_str,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_str_2d__3e_list,"c#str->list",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_str_2d__3e_list,1,-1)
,___DEF_LBL_RET(___H_c_23_str_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_str_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_str_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_read_2d_line_2a_,"c#read-line*",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H_c_23_read_2d_line_2a_,1,-1)
,___DEF_LBL_RET(___H_c_23_read_2d_line_2a_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_read_2d_line_2a_,___IFD(___RETN,5,1,0x7L))
,___DEF_LBL_RET(___H_c_23_read_2d_line_2a_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_read_2d_line_2a_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_read_2d_line_2a_,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_read_2d_line_2a_,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_make_2d_stretchable_2d_vector,"c#make-stretchable-vector",___REF_FAL,2,
0)
,___DEF_LBL_PROC(___H_c_23_make_2d_stretchable_2d_vector,1,-1)
,___DEF_LBL_RET(___H_c_23_make_2d_stretchable_2d_vector,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_stretchable_2d_vector_2d_length,"c#stretchable-vector-length",___REF_FAL,
1,0)
,___DEF_LBL_PROC(___H_c_23_stretchable_2d_vector_2d_length,1,-1)
,___DEF_LBL_INTRO(___H_c_23_stretchable_2d_vector_2d_ref,"c#stretchable-vector-ref",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_stretchable_2d_vector_2d_ref,2,-1)
,___DEF_LBL_INTRO(___H_c_23_stretchable_2d_vector_2d_set_21_,"c#stretchable-vector-set!",___REF_FAL,3,
0)
,___DEF_LBL_PROC(___H_c_23_stretchable_2d_vector_2d_set_21_,3,-1)
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_set_21_,___IFD(___RETI,8,1,0x3f1eL))
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_set_21_,___IFD(___RETN,5,1,0x1eL))
,___DEF_LBL_INTRO(___H_c_23_stretch_2d_vector,"c#stretch-vector",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H_c_23_stretch_2d_vector,3,-1)
,___DEF_LBL_RET(___H_c_23_stretch_2d_vector,___IFD(___RETN,5,0,0x1fL))
,___DEF_LBL_RET(___H_c_23_stretch_2d_vector,___OFD(___RETI,13,0,0x3f103dL))
,___DEF_LBL_RET(___H_c_23_stretch_2d_vector,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_stretch_2d_vector,___IFD(___RETN,9,0,0x3dL))
,___DEF_LBL_RET(___H_c_23_stretch_2d_vector,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_stretch_2d_vector,___IFD(___RETN,9,0,0x21L))
,___DEF_LBL_INTRO(___H_c_23_stretchable_2d_vector_2d_copy,"c#stretchable-vector-copy",___REF_FAL,5,
0)
,___DEF_LBL_PROC(___H_c_23_stretchable_2d_vector_2d_copy,1,-1)
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_copy,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_copy,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_copy,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_copy,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_stretchable_2d_vector_2d_for_2d_each,"c#stretchable-vector-for-each",___REF_FAL,
5,0)
,___DEF_LBL_PROC(___H_c_23_stretchable_2d_vector_2d_for_2d_each,2,-1)
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_for_2d_each,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_for_2d_each,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_for_2d_each,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d_for_2d_each,___IFD(___RETI,8,1,0x3f1fL))
,___DEF_LBL_INTRO(___H_c_23_stretchable_2d_vector_2d__3e_list,"c#stretchable-vector->list",___REF_FAL,4,
0)
,___DEF_LBL_PROC(___H_c_23_stretchable_2d_vector_2d__3e_list,1,-1)
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_stretchable_2d_vector_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_make_2d_ordered_2d_table,"c#make-ordered-table",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H_c_23_make_2d_ordered_2d_table,1,-1)
,___DEF_LBL_RET(___H_c_23_make_2d_ordered_2d_table,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_make_2d_ordered_2d_table,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_make_2d_ordered_2d_table,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_make_2d_ordered_2d_table,___IFD(___RETI,1,0,0x3f1L))
,___DEF_LBL_INTRO(___H_c_23_ordered_2d_table_2d_length,"c#ordered-table-length",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_ordered_2d_table_2d_length,1,-1)
,___DEF_LBL_INTRO(___H_c_23_ordered_2d_table_2d_index,"c#ordered-table-index",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_ordered_2d_table_2d_index,2,-1)
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d_index,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_ordered_2d_table_2d_lookup,"c#ordered-table-lookup",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_ordered_2d_table_2d_lookup,2,-1)
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d_lookup,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d_lookup,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d_lookup,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_INTRO(___H_c_23_ordered_2d_table_2d_enter,"c#ordered-table-enter",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H_c_23_ordered_2d_table_2d_enter,3,-1)
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d_enter,___IFD(___RETI,8,0,0x3f1fL))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d_enter,___IFD(___RETN,5,0,0x1fL))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d_enter,___IFD(___RETN,5,0,0x17L))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d_enter,___IFD(___RETI,8,0,0x3f09L))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d_enter,___IFD(___RETN,5,0,0x9L))
,___DEF_LBL_INTRO(___H_c_23_ordered_2d_table_2d__3e_list,"c#ordered-table->list",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H_c_23_ordered_2d_table_2d__3e_list,1,-1)
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d__3e_list,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d__3e_list,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_ordered_2d_table_2d__3e_list,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_INTRO(___H_c_23_bits_2d_and,"c#bits-and",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_bits_2d_and,2,-1)
,___DEF_LBL_RET(___H_c_23_bits_2d_and,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_bits_2d_and,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H_c_23_bits_2d_and,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_INTRO(___H_c_23_bits_2d_or,"c#bits-or",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_bits_2d_or,2,-1)
,___DEF_LBL_RET(___H_c_23_bits_2d_or,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_bits_2d_or,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H_c_23_bits_2d_or,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_INTRO(___H_c_23_bits_2d_shl,"c#bits-shl",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_c_23_bits_2d_shl,2,-1)
,___DEF_LBL_RET(___H_c_23_bits_2d_shl,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_bits_2d_shl,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_bits_2d_shr,"c#bits-shr",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_c_23_bits_2d_shr,2,-1)
,___DEF_LBL_RET(___H_c_23_bits_2d_shr,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_bits_2d_shr,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_with_2d_exception_2d_handling,"c#with-exception-handling",___REF_FAL,4,
0)
,___DEF_LBL_PROC(___H_c_23_with_2d_exception_2d_handling,1,-1)
,___DEF_LBL_RET(___H_c_23_with_2d_exception_2d_handling,___IFD(___RETN,5,1,0x3L))
,___DEF_LBL_PROC(___H_c_23_with_2d_exception_2d_handling,2,-1)
,___DEF_LBL_RET(___H_c_23_with_2d_exception_2d_handling,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_compiler_2d_error,"c#compiler-error",___REF_FAL,10,0)
,___DEF_LBL_PROC(___H_c_23_compiler_2d_error,2,-1)
,___DEF_LBL_RET(___H_c_23_compiler_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_error,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_error,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_error,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_error,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_error,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_error,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_error,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_compiler_2d_user_2d_error,"c#compiler-user-error",___REF_FAL,12,0)
,___DEF_LBL_PROC(___H_c_23_compiler_2d_user_2d_error,3,-1)
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETI,8,0,0x3f0dL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETN,5,0,0xdL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETN,5,0,0xdL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETN,5,0,0x9L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_error,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_compiler_2d_user_2d_warning,"c#compiler-user-warning",___REF_FAL,11,0)
,___DEF_LBL_PROC(___H_c_23_compiler_2d_user_2d_warning,3,-1)
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETI,8,0,0x3f0dL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETN,5,0,0xdL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETN,5,0,0xdL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETN,5,0,0x9L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_user_2d_warning,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_compiler_2d_internal_2d_error,"c#compiler-internal-error",___REF_FAL,12,
0)
,___DEF_LBL_PROC(___H_c_23_compiler_2d_internal_2d_error,2,-1)
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_internal_2d_error,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_compiler_2d_limitation_2d_error,"c#compiler-limitation-error",___REF_FAL,
12,0)
,___DEF_LBL_PROC(___H_c_23_compiler_2d_limitation_2d_error,2,-1)
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_compiler_2d_limitation_2d_error,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_compiler_2d_abort,"c#compiler-abort",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_compiler_2d_abort,0,-1)
,___DEF_LBL_RET(___H_c_23_compiler_2d_abort,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_make_2d_gnode,"c#make-gnode",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_make_2d_gnode,2,-1)
,___DEF_LBL_RET(___H_c_23_make_2d_gnode,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_gnode_2d_var,"c#gnode-var",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_gnode_2d_var,1,-1)
,___DEF_LBL_INTRO(___H_c_23_gnode_2d_depvars,"c#gnode-depvars",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_gnode_2d_depvars,1,-1)
,___DEF_LBL_INTRO(___H_c_23_transitive_2d_closure,"c#transitive-closure",___REF_FAL,27,0)
,___DEF_LBL_PROC(___H_c_23_transitive_2d_closure,1,-1)
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,5,0,0xbL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___OFD(___RETI,10,0,0x3f30bL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,9,3,0x1ffL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,2,4,0x3f3L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___OFD(___RETI,12,3,0x3f0ffL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,5,0,0x9L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,1,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,9,3,0xffL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___OFD(___RETI,12,3,0x3f0fbL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,9,3,0xfbL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,9,3,0xffL))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_PROC(___H_c_23_transitive_2d_closure,2,-1)
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_transitive_2d_closure,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_INTRO(___H_c_23_gnode_2d_find_2d_depvars,"c#gnode-find-depvars",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H_c_23_gnode_2d_find_2d_depvars,2,-1)
,___DEF_LBL_RET(___H_c_23_gnode_2d_find_2d_depvars,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_gnode_2d_find_2d_depvars,___IFD(___RETN,9,2,0x7dL))
,___DEF_LBL_RET(___H_c_23_gnode_2d_find_2d_depvars,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_gnode_2d_find_2d_depvars,___IFD(___RETI,1,4,0x3f0L))
,___DEF_LBL_RET(___H_c_23_gnode_2d_find_2d_depvars,___OFD(___RETI,12,2,0x3f07dL))
,___DEF_LBL_RET(___H_c_23_gnode_2d_find_2d_depvars,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_INTRO(___H_c_23_gnodes_2d_remove,"c#gnodes-remove",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H_c_23_gnodes_2d_remove,2,-1)
,___DEF_LBL_RET(___H_c_23_gnodes_2d_remove,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_gnodes_2d_remove,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_gnodes_2d_remove,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H_c_23_gnodes_2d_remove,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_gnodes_2d_remove,___IFD(___RETN,5,0,0x9L))
,___DEF_LBL_RET(___H_c_23_gnodes_2d_remove,___IFD(___RETI,1,0,0x3f1L))
,___DEF_LBL_INTRO(___H_c_23_topological_2d_sort,"c#topological-sort",___REF_FAL,16,0)
,___DEF_LBL_PROC(___H_c_23_topological_2d_sort,1,-1)
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETN,5,0,0x9L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETI,1,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETN,5,0,0x9L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETN,5,0,0xfL))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETI,8,0,0x3f09L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETI,8,0,0x3f0fL))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETN,5,0,0x9L))
,___DEF_LBL_RET(___H_c_23_topological_2d_sort,___IFD(___RETI,1,0,0x3f1L))
,___DEF_LBL_INTRO(___H_c_23_remove_2d_no_2d_depvars,"c#remove-no-depvars",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H_c_23_remove_2d_no_2d_depvars,1,-1)
,___DEF_LBL_RET(___H_c_23_remove_2d_no_2d_depvars,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_remove_2d_no_2d_depvars,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_PROC(___H_c_23_remove_2d_no_2d_depvars,1,-1)
,___DEF_LBL_RET(___H_c_23_remove_2d_no_2d_depvars,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_remove_2d_no_2d_depvars,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_INTRO(___H_c_23_remove_2d_cycle,"c#remove-cycle",___REF_FAL,12,0)
,___DEF_LBL_PROC(___H_c_23_remove_2d_cycle,1,-1)
,___DEF_LBL_RET(___H_c_23_remove_2d_cycle,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_remove_2d_cycle,___IFD(___RETN,5,2,0x1eL))
,___DEF_LBL_RET(___H_c_23_remove_2d_cycle,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_remove_2d_cycle,___IFD(___RETI,8,2,0x3f1fL))
,___DEF_LBL_RET(___H_c_23_remove_2d_cycle,___IFD(___RETI,8,2,0x3f1fL))
,___DEF_LBL_RET(___H_c_23_remove_2d_cycle,___IFD(___RETN,5,2,0x1fL))
,___DEF_LBL_RET(___H_c_23_remove_2d_cycle,___IFD(___RETN,5,2,0x1dL))
,___DEF_LBL_PROC(___H_c_23_remove_2d_cycle,1,1)
,___DEF_LBL_RET(___H_c_23_remove_2d_cycle,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_PROC(___H_c_23_remove_2d_cycle,1,1)
,___DEF_LBL_RET(___H_c_23_remove_2d_cycle,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_ptset_2d_empty,"c#ptset-empty",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_ptset_2d_empty,0,-1)
,___DEF_LBL_RET(___H_c_23_ptset_2d_empty,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_list_2d__3e_ptset,"c#list->ptset",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H_c_23_list_2d__3e_ptset,1,-1)
,___DEF_LBL_RET(___H_c_23_list_2d__3e_ptset,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_ptset,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_ptset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_ptset,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_ptset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_ptset,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_INTRO(___H_c_23_ptset_2d__3e_list,"c#ptset->list",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_ptset_2d__3e_list,1,-1)
,___DEF_LBL_RET(___H_c_23_ptset_2d__3e_list,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_ptset_2d__3e_list,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_ptset_2d__3e_list,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_ptset_2d_size,"c#ptset-size",___REF_FAL,9,0)
,___DEF_LBL_PROC(___H_c_23_ptset_2d_size,1,-1)
,___DEF_LBL_RET(___H_c_23_ptset_2d_size,___IFD(___RETI,4,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_size,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_size,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_size,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_size,___IFD(___RETN,5,0,0x5L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_size,___IFD(___RETI,1,0,0x3f1L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_size,___IFD(___RETN,1,0,0x1L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_size,___IFD(___RETI,4,4,0x3f0L))
,___DEF_LBL_INTRO(___H_c_23_ptset_2d_empty_3f_,"c#ptset-empty?",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_ptset_2d_empty_3f_,1,-1)
,___DEF_LBL_RET(___H_c_23_ptset_2d_empty_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_ptset_2d_member_3f_,"c#ptset-member?",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_c_23_ptset_2d_member_3f_,2,-1)
,___DEF_LBL_RET(___H_c_23_ptset_2d_member_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_ptset_2d_member_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_ptset_2d_adjoin,"c#ptset-adjoin",___REF_FAL,5,0)
,___DEF_LBL_PROC(___H_c_23_ptset_2d_adjoin,2,-1)
,___DEF_LBL_RET(___H_c_23_ptset_2d_adjoin,___IFD(___RETI,8,0,0x3f1fL))
,___DEF_LBL_RET(___H_c_23_ptset_2d_adjoin,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_ptset_2d_adjoin,___IFD(___RETN,5,0,0x1fL))
,___DEF_LBL_RET(___H_c_23_ptset_2d_adjoin,___IFD(___RETI,8,0,0x3f03L))
,___DEF_LBL_INTRO(___H_c_23_ptset_2d_every_3f_,"c#ptset-every?",___REF_FAL,10,0)
,___DEF_LBL_PROC(___H_c_23_ptset_2d_every_3f_,2,-1)
,___DEF_LBL_RET(___H_c_23_ptset_2d_every_3f_,___IFD(___RETI,8,1,0x3f03L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_every_3f_,___IFD(___RETI,8,1,0x3f03L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_every_3f_,___IFD(___RETN,5,1,0x3L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_every_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_ptset_2d_every_3f_,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_every_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_ptset_2d_every_3f_,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_PROC(___H_c_23_ptset_2d_every_3f_,1,1)
,___DEF_LBL_RET(___H_c_23_ptset_2d_every_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_ptset_2d_remove,"c#ptset-remove",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_c_23_ptset_2d_remove,2,-1)
,___DEF_LBL_RET(___H_c_23_ptset_2d_remove,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_ptset_2d_remove,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_reverse_2d_append_21_,"c#varset-reverse-append!",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_reverse_2d_append_21_,2,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_reverse_2d_append_21_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_reverse_2d_append_21_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_wrap,"c#varset-wrap",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_wrap,1,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_wrap,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_unwrap,"c#varset-unwrap",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_unwrap,1,-1)
,___DEF_LBL_INTRO(___H_c_23_varset_2d_empty,"c#varset-empty",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_empty,0,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_empty,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_singleton,"c#varset-singleton",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_singleton,1,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_singleton,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_list_2d__3e_varset,"c#list->varset",___REF_FAL,13,0)
,___DEF_LBL_PROC(___H_c_23_list_2d__3e_varset,1,-1)
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_varset,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_INTRO(___H_c_23_varset_2d__3e_list,"c#varset->list",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d__3e_list,1,-1)
,___DEF_LBL_INTRO(___H_c_23_varset_2d_size,"c#varset-size",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_size,1,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_size,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_empty_3f_,"c#varset-empty?",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_empty_3f_,1,-1)
,___DEF_LBL_INTRO(___H_c_23_varset_2d__3c_,"c#varset-<",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d__3c_,2,-1)
,___DEF_LBL_INTRO(___H_c_23_varset_2d_member_3f_,"c#varset-member?",___REF_FAL,8,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_member_3f_,2,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_member_3f_,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_varset_2d_member_3f_,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_varset_2d_member_3f_,___OFD(___RETI,12,2,0x3f07dL))
,___DEF_LBL_RET(___H_c_23_varset_2d_member_3f_,___IFD(___RETN,9,2,0x7dL))
,___DEF_LBL_RET(___H_c_23_varset_2d_member_3f_,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_varset_2d_member_3f_,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_varset_2d_member_3f_,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_adjoin,"c#varset-adjoin",___REF_FAL,8,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_adjoin,2,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_adjoin,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_varset_2d_adjoin,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_adjoin,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_varset_2d_adjoin,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_varset_2d_adjoin,___IFD(___RETI,1,4,0x3f0L))
,___DEF_LBL_RET(___H_c_23_varset_2d_adjoin,___IFD(___RETI,1,4,0x3f0L))
,___DEF_LBL_RET(___H_c_23_varset_2d_adjoin,___IFD(___RETI,8,1,0x3f1fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_remove,"c#varset-remove",___REF_FAL,7,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_remove,2,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_remove,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_varset_2d_remove,___IFD(___RETN,5,1,0x1fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_remove,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_varset_2d_remove,___IFD(___RETI,1,4,0x3f1L))
,___DEF_LBL_RET(___H_c_23_varset_2d_remove,___IFD(___RETI,8,1,0x3f1fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_remove,___IFD(___RETI,8,8,0x3f00L))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_equal_3f_,"c#varset-equal?",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_equal_3f_,2,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_equal_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_difference,"c#varset-difference",___REF_FAL,9,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_difference,2,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_difference,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_difference,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_difference,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_difference,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_difference,___OFD(___RETI,12,1,0x3f03fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_difference,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_difference,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_difference,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_union,"c#varset-union",___REF_FAL,12,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_union,2,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETN,9,1,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___OFD(___RETI,12,1,0x3f03fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_intersection,"c#varset-intersection",___REF_FAL,9,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_intersection,2,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_intersection,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersection,___IFD(___RETN,5,1,0x1eL))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersection,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersection,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersection,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersection,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersection,___IFD(___RETI,8,1,0x3f1eL))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersection,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_intersects_3f_,"c#varset-intersects?",___REF_FAL,6,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_intersects_3f_,2,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_intersects_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersects_3f_,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersects_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersects_3f_,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H_c_23_varset_2d_intersects_3f_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_varset_2d_union_2d_multi,"c#varset-union-multi",___REF_FAL,10,0)
,___DEF_LBL_PROC(___H_c_23_varset_2d_union_2d_multi,1,-1)
,___DEF_LBL_RET(___H_c_23_varset_2d_union_2d_multi,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_varset_2d_union_2d_multi,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union_2d_multi,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union_2d_multi,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union_2d_multi,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union_2d_multi,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union_2d_multi,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_varset_2d_union_2d_multi,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_RET(___H_c_23_varset_2d_union_2d_multi,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_n_2d_ary,"c#n-ary",___REF_FAL,4,0)
,___DEF_LBL_PROC(___H_c_23_n_2d_ary,3,-1)
,___DEF_LBL_RET(___H_c_23_n_2d_ary,___IFD(___RETN,5,0,0x7L))
,___DEF_LBL_RET(___H_c_23_n_2d_ary,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_RET(___H_c_23_n_2d_ary,___IFD(___RETI,8,0,0x3f07L))
,___DEF_LBL_INTRO(___H_c_23_list_2d__3e_queue,"c#list->queue",___REF_FAL,3,0)
,___DEF_LBL_PROC(___H_c_23_list_2d__3e_queue,1,-1)
,___DEF_LBL_RET(___H_c_23_list_2d__3e_queue,___IFD(___RETN,5,0,0x3L))
,___DEF_LBL_RET(___H_c_23_list_2d__3e_queue,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_queue_2d__3e_list,"c#queue->list",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_queue_2d__3e_list,1,-1)
,___DEF_LBL_INTRO(___H_c_23_queue_2d_empty,"c#queue-empty",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_queue_2d_empty,0,-1)
,___DEF_LBL_RET(___H_c_23_queue_2d_empty,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_queue_2d_empty_3f_,"c#queue-empty?",___REF_FAL,1,0)
,___DEF_LBL_PROC(___H_c_23_queue_2d_empty_3f_,1,-1)
,___DEF_LBL_INTRO(___H_c_23_queue_2d_get_21_,"c#queue-get!",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_queue_2d_get_21_,1,-1)
,___DEF_LBL_RET(___H_c_23_queue_2d_get_21_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_queue_2d_put_21_,"c#queue-put!",___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_queue_2d_put_21_,2,-1)
,___DEF_LBL_RET(___H_c_23_queue_2d_put_21_,___IFD(___RETI,0,0,0x3fL))
,___DEF_LBL_INTRO(___H_c_23_throw_2d_to_2d_exception_2d_handler,0,___REF_FAL,2,0)
,___DEF_LBL_PROC(___H_c_23_throw_2d_to_2d_exception_2d_handler,1,-1)
,___DEF_LBL_RET(___H_c_23_throw_2d_to_2d_exception_2d_handler,___IFD(___RETI,0,0,0x3fL))
___END_LBL
___BEGIN_OFD
___DEF_OFD(___RETI,12,1)
___GCMAP1(0x3f03fL)
,___DEF_OFD(___RETI,13,0)
___GCMAP1(0x3f103dL)
,___DEF_OFD(___RETI,10,0)
___GCMAP1(0x3f30bL)
,___DEF_OFD(___RETI,12,3)
___GCMAP1(0x3f0ffL)
,___DEF_OFD(___RETI,12,3)
___GCMAP1(0x3f0fbL)
,___DEF_OFD(___RETI,12,2)
___GCMAP1(0x3f07dL)
,___DEF_OFD(___RETI,12,2)
___GCMAP1(0x3f07dL)
,___DEF_OFD(___RETI,12,1)
___GCMAP1(0x3f03fL)
,___DEF_OFD(___RETI,12,1)
___GCMAP1(0x3f03fL)
___END_OFD
___BEGIN_MOD_PRM
___DEF_MOD_PRM(0,___G___utils_23_,1)
___DEF_MOD_PRM(1,___G_c_23_append_2d_lists,5)
___DEF_MOD_PRM(57,___G_c_23_reverse_2d_append_21_,14)
___DEF_MOD_PRM(24,___G_c_23_list_2d_length,17)
___DEF_MOD_PRM(25,___G_c_23_make_2d_counter,21)
___DEF_MOD_PRM(13,___G_c_23_for_2d_each_2d_index,25)
___DEF_MOD_PRM(29,___G_c_23_map_2d_index,31)
___DEF_MOD_PRM(38,___G_c_23_pos_2d_in_2d_list,39)
___DEF_MOD_PRM(31,___G_c_23_object_2d_pos_2d_in_2d_list,43)
___DEF_MOD_PRM(67,___G_c_23_string_2d_pos_2d_in_2d_list,48)
___DEF_MOD_PRM(94,___G_take,53)
___DEF_MOD_PRM(92,___G_drop,59)
___DEF_MOD_PRM(37,___G_c_23_pair_2d_up,63)
___DEF_MOD_PRM(93,___G_last_2d_pair,69)
___DEF_MOD_PRM(18,___G_c_23_keep,73)
___DEF_MOD_PRM(12,___G_c_23_every_3f_,82)
___DEF_MOD_PRM(56,___G_c_23_remq,87)
___DEF_MOD_PRM(58,___G_c_23_sort_2d_list,93)
___DEF_MOD_PRM(23,___G_c_23_list_2d__3e_vect,111)
___DEF_MOD_PRM(89,___G_c_23_vect_2d__3e_list,118)
___DEF_MOD_PRM(21,___G_c_23_list_2d__3e_str,123)
___DEF_MOD_PRM(59,___G_c_23_str_2d__3e_list,130)
___DEF_MOD_PRM(53,___G_c_23_read_2d_line_2a_,135)
___DEF_MOD_PRM(28,___G_c_23_make_2d_stretchable_2d_vector,143)
___DEF_MOD_PRM(64,___G_c_23_stretchable_2d_vector_2d_length,146)
___DEF_MOD_PRM(65,___G_c_23_stretchable_2d_vector_2d_ref,148)
___DEF_MOD_PRM(66,___G_c_23_stretchable_2d_vector_2d_set_21_,150)
___DEF_MOD_PRM(60,___G_c_23_stretch_2d_vector,154)
___DEF_MOD_PRM(62,___G_c_23_stretchable_2d_vector_2d_copy,162)
___DEF_MOD_PRM(63,___G_c_23_stretchable_2d_vector_2d_for_2d_each,168)
___DEF_MOD_PRM(61,___G_c_23_stretchable_2d_vector_2d__3e_list,174)
___DEF_MOD_PRM(27,___G_c_23_make_2d_ordered_2d_table,179)
___DEF_MOD_PRM(35,___G_c_23_ordered_2d_table_2d_length,185)
___DEF_MOD_PRM(34,___G_c_23_ordered_2d_table_2d_index,187)
___DEF_MOD_PRM(36,___G_c_23_ordered_2d_table_2d_lookup,190)
___DEF_MOD_PRM(33,___G_c_23_ordered_2d_table_2d_enter,195)
___DEF_MOD_PRM(32,___G_c_23_ordered_2d_table_2d__3e_list,202)
___DEF_MOD_PRM(2,___G_c_23_bits_2d_and,209)
___DEF_MOD_PRM(3,___G_c_23_bits_2d_or,214)
___DEF_MOD_PRM(4,___G_c_23_bits_2d_shl,219)
___DEF_MOD_PRM(5,___G_c_23_bits_2d_shr,223)
___DEF_MOD_PRM(91,___G_c_23_with_2d_exception_2d_handling,227)
___DEF_MOD_PRM(7,___G_c_23_compiler_2d_error,232)
___DEF_MOD_PRM(10,___G_c_23_compiler_2d_user_2d_error,243)
___DEF_MOD_PRM(11,___G_c_23_compiler_2d_user_2d_warning,256)
___DEF_MOD_PRM(8,___G_c_23_compiler_2d_internal_2d_error,268)
___DEF_MOD_PRM(9,___G_c_23_compiler_2d_limitation_2d_error,281)
___DEF_MOD_PRM(6,___G_c_23_compiler_2d_abort,294)
___DEF_MOD_PRM(26,___G_c_23_make_2d_gnode,297)
___DEF_MOD_PRM(16,___G_c_23_gnode_2d_var,300)
___DEF_MOD_PRM(14,___G_c_23_gnode_2d_depvars,302)
___DEF_MOD_PRM(70,___G_c_23_transitive_2d_closure,304)
___DEF_MOD_PRM(15,___G_c_23_gnode_2d_find_2d_depvars,332)
___DEF_MOD_PRM(17,___G_c_23_gnodes_2d_remove,340)
___DEF_MOD_PRM(69,___G_c_23_topological_2d_sort,348)
___DEF_MOD_PRM(55,___G_c_23_remove_2d_no_2d_depvars,365)
___DEF_MOD_PRM(54,___G_c_23_remove_2d_cycle,372)
___DEF_MOD_PRM(41,___G_c_23_ptset_2d_empty,385)
___DEF_MOD_PRM(19,___G_c_23_list_2d__3e_ptset,388)
___DEF_MOD_PRM(39,___G_c_23_ptset_2d__3e_list,396)
___DEF_MOD_PRM(47,___G_c_23_ptset_2d_size,401)
___DEF_MOD_PRM(43,___G_c_23_ptset_2d_empty_3f_,411)
___DEF_MOD_PRM(45,___G_c_23_ptset_2d_member_3f_,414)
___DEF_MOD_PRM(40,___G_c_23_ptset_2d_adjoin,418)
___DEF_MOD_PRM(44,___G_c_23_ptset_2d_every_3f_,424)
___DEF_MOD_PRM(46,___G_c_23_ptset_2d_remove,435)
___DEF_MOD_PRM(82,___G_c_23_varset_2d_reverse_2d_append_21_,439)
___DEF_MOD_PRM(88,___G_c_23_varset_2d_wrap,443)
___DEF_MOD_PRM(87,___G_c_23_varset_2d_unwrap,446)
___DEF_MOD_PRM(75,___G_c_23_varset_2d_empty,448)
___DEF_MOD_PRM(83,___G_c_23_varset_2d_singleton,451)
___DEF_MOD_PRM(22,___G_c_23_list_2d__3e_varset,454)
___DEF_MOD_PRM(72,___G_c_23_varset_2d__3e_list,468)
___DEF_MOD_PRM(84,___G_c_23_varset_2d_size,470)
___DEF_MOD_PRM(76,___G_c_23_varset_2d_empty_3f_,473)
___DEF_MOD_PRM(71,___G_c_23_varset_2d__3c_,475)
___DEF_MOD_PRM(80,___G_c_23_varset_2d_member_3f_,477)
___DEF_MOD_PRM(73,___G_c_23_varset_2d_adjoin,486)
___DEF_MOD_PRM(81,___G_c_23_varset_2d_remove,495)
___DEF_MOD_PRM(77,___G_c_23_varset_2d_equal_3f_,503)
___DEF_MOD_PRM(74,___G_c_23_varset_2d_difference,506)
___DEF_MOD_PRM(85,___G_c_23_varset_2d_union,516)
___DEF_MOD_PRM(78,___G_c_23_varset_2d_intersection,529)
___DEF_MOD_PRM(79,___G_c_23_varset_2d_intersects_3f_,539)
___DEF_MOD_PRM(86,___G_c_23_varset_2d_union_2d_multi,546)
___DEF_MOD_PRM(30,___G_c_23_n_2d_ary,557)
___DEF_MOD_PRM(20,___G_c_23_list_2d__3e_queue,562)
___DEF_MOD_PRM(48,___G_c_23_queue_2d__3e_list,566)
___DEF_MOD_PRM(49,___G_c_23_queue_2d_empty,568)
___DEF_MOD_PRM(50,___G_c_23_queue_2d_empty_3f_,571)
___DEF_MOD_PRM(51,___G_c_23_queue_2d_get_21_,573)
___DEF_MOD_PRM(52,___G_c_23_queue_2d_put_21_,576)
___END_MOD_PRM
___BEGIN_MOD_C_INIT
___END_MOD_C_INIT
___BEGIN_MOD_GLO
___DEF_MOD_GLO(0,___G___utils_23_,1)
___DEF_MOD_GLO(1,___G_c_23_append_2d_lists,5)
___DEF_MOD_GLO(57,___G_c_23_reverse_2d_append_21_,14)
___DEF_MOD_GLO(24,___G_c_23_list_2d_length,17)
___DEF_MOD_GLO(25,___G_c_23_make_2d_counter,21)
___DEF_MOD_GLO(13,___G_c_23_for_2d_each_2d_index,25)
___DEF_MOD_GLO(29,___G_c_23_map_2d_index,31)
___DEF_MOD_GLO(38,___G_c_23_pos_2d_in_2d_list,39)
___DEF_MOD_GLO(31,___G_c_23_object_2d_pos_2d_in_2d_list,43)
___DEF_MOD_GLO(67,___G_c_23_string_2d_pos_2d_in_2d_list,48)
___DEF_MOD_GLO(94,___G_take,53)
___DEF_MOD_GLO(92,___G_drop,59)
___DEF_MOD_GLO(37,___G_c_23_pair_2d_up,63)
___DEF_MOD_GLO(93,___G_last_2d_pair,69)
___DEF_MOD_GLO(18,___G_c_23_keep,73)
___DEF_MOD_GLO(12,___G_c_23_every_3f_,82)
___DEF_MOD_GLO(56,___G_c_23_remq,87)
___DEF_MOD_GLO(58,___G_c_23_sort_2d_list,93)
___DEF_MOD_GLO(23,___G_c_23_list_2d__3e_vect,111)
___DEF_MOD_GLO(89,___G_c_23_vect_2d__3e_list,118)
___DEF_MOD_GLO(21,___G_c_23_list_2d__3e_str,123)
___DEF_MOD_GLO(59,___G_c_23_str_2d__3e_list,130)
___DEF_MOD_GLO(53,___G_c_23_read_2d_line_2a_,135)
___DEF_MOD_GLO(28,___G_c_23_make_2d_stretchable_2d_vector,143)
___DEF_MOD_GLO(64,___G_c_23_stretchable_2d_vector_2d_length,146)
___DEF_MOD_GLO(65,___G_c_23_stretchable_2d_vector_2d_ref,148)
___DEF_MOD_GLO(66,___G_c_23_stretchable_2d_vector_2d_set_21_,150)
___DEF_MOD_GLO(60,___G_c_23_stretch_2d_vector,154)
___DEF_MOD_GLO(62,___G_c_23_stretchable_2d_vector_2d_copy,162)
___DEF_MOD_GLO(63,___G_c_23_stretchable_2d_vector_2d_for_2d_each,168)
___DEF_MOD_GLO(61,___G_c_23_stretchable_2d_vector_2d__3e_list,174)
___DEF_MOD_GLO(27,___G_c_23_make_2d_ordered_2d_table,179)
___DEF_MOD_GLO(35,___G_c_23_ordered_2d_table_2d_length,185)
___DEF_MOD_GLO(34,___G_c_23_ordered_2d_table_2d_index,187)
___DEF_MOD_GLO(36,___G_c_23_ordered_2d_table_2d_lookup,190)
___DEF_MOD_GLO(33,___G_c_23_ordered_2d_table_2d_enter,195)
___DEF_MOD_GLO(32,___G_c_23_ordered_2d_table_2d__3e_list,202)
___DEF_MOD_GLO(2,___G_c_23_bits_2d_and,209)
___DEF_MOD_GLO(3,___G_c_23_bits_2d_or,214)
___DEF_MOD_GLO(4,___G_c_23_bits_2d_shl,219)
___DEF_MOD_GLO(5,___G_c_23_bits_2d_shr,223)
___DEF_MOD_GLO(91,___G_c_23_with_2d_exception_2d_handling,227)
___DEF_MOD_GLO(7,___G_c_23_compiler_2d_error,232)
___DEF_MOD_GLO(10,___G_c_23_compiler_2d_user_2d_error,243)
___DEF_MOD_GLO(11,___G_c_23_compiler_2d_user_2d_warning,256)
___DEF_MOD_GLO(8,___G_c_23_compiler_2d_internal_2d_error,268)
___DEF_MOD_GLO(9,___G_c_23_compiler_2d_limitation_2d_error,281)
___DEF_MOD_GLO(6,___G_c_23_compiler_2d_abort,294)
___DEF_MOD_GLO(26,___G_c_23_make_2d_gnode,297)
___DEF_MOD_GLO(16,___G_c_23_gnode_2d_var,300)
___DEF_MOD_GLO(14,___G_c_23_gnode_2d_depvars,302)
___DEF_MOD_GLO(70,___G_c_23_transitive_2d_closure,304)
___DEF_MOD_GLO(15,___G_c_23_gnode_2d_find_2d_depvars,332)
___DEF_MOD_GLO(17,___G_c_23_gnodes_2d_remove,340)
___DEF_MOD_GLO(69,___G_c_23_topological_2d_sort,348)
___DEF_MOD_GLO(55,___G_c_23_remove_2d_no_2d_depvars,365)
___DEF_MOD_GLO(54,___G_c_23_remove_2d_cycle,372)
___DEF_MOD_GLO(41,___G_c_23_ptset_2d_empty,385)
___DEF_MOD_GLO(19,___G_c_23_list_2d__3e_ptset,388)
___DEF_MOD_GLO(39,___G_c_23_ptset_2d__3e_list,396)
___DEF_MOD_GLO(47,___G_c_23_ptset_2d_size,401)
___DEF_MOD_GLO(43,___G_c_23_ptset_2d_empty_3f_,411)
___DEF_MOD_GLO(45,___G_c_23_ptset_2d_member_3f_,414)
___DEF_MOD_GLO(40,___G_c_23_ptset_2d_adjoin,418)
___DEF_MOD_GLO(44,___G_c_23_ptset_2d_every_3f_,424)
___DEF_MOD_GLO(46,___G_c_23_ptset_2d_remove,435)
___DEF_MOD_GLO(82,___G_c_23_varset_2d_reverse_2d_append_21_,439)
___DEF_MOD_GLO(88,___G_c_23_varset_2d_wrap,443)
___DEF_MOD_GLO(87,___G_c_23_varset_2d_unwrap,446)
___DEF_MOD_GLO(75,___G_c_23_varset_2d_empty,448)
___DEF_MOD_GLO(83,___G_c_23_varset_2d_singleton,451)
___DEF_MOD_GLO(22,___G_c_23_list_2d__3e_varset,454)
___DEF_MOD_GLO(72,___G_c_23_varset_2d__3e_list,468)
___DEF_MOD_GLO(84,___G_c_23_varset_2d_size,470)
___DEF_MOD_GLO(76,___G_c_23_varset_2d_empty_3f_,473)
___DEF_MOD_GLO(71,___G_c_23_varset_2d__3c_,475)
___DEF_MOD_GLO(80,___G_c_23_varset_2d_member_3f_,477)
___DEF_MOD_GLO(73,___G_c_23_varset_2d_adjoin,486)
___DEF_MOD_GLO(81,___G_c_23_varset_2d_remove,495)
___DEF_MOD_GLO(77,___G_c_23_varset_2d_equal_3f_,503)
___DEF_MOD_GLO(74,___G_c_23_varset_2d_difference,506)
___DEF_MOD_GLO(85,___G_c_23_varset_2d_union,516)
___DEF_MOD_GLO(78,___G_c_23_varset_2d_intersection,529)
___DEF_MOD_GLO(79,___G_c_23_varset_2d_intersects_3f_,539)
___DEF_MOD_GLO(86,___G_c_23_varset_2d_union_2d_multi,546)
___DEF_MOD_GLO(30,___G_c_23_n_2d_ary,557)
___DEF_MOD_GLO(20,___G_c_23_list_2d__3e_queue,562)
___DEF_MOD_GLO(48,___G_c_23_queue_2d__3e_list,566)
___DEF_MOD_GLO(49,___G_c_23_queue_2d_empty,568)
___DEF_MOD_GLO(50,___G_c_23_queue_2d_empty_3f_,571)
___DEF_MOD_GLO(51,___G_c_23_queue_2d_get_21_,573)
___DEF_MOD_GLO(52,___G_c_23_queue_2d_put_21_,576)
___END_MOD_GLO
___BEGIN_MOD_SYM_KEY
___DEF_MOD_SYM(0,___S___utils,"_utils")
___DEF_MOD_KEY(0,___K_test,"test")
___END_MOD_SYM_KEY
#endif
|
'use strict';
const blocks = [
['B', 'O'],
['X', 'K'],
['D', 'Q'],
['C', 'P'],
['N', 'A'],
['G', 'T'],
['R', 'E'],
['T', 'G'],
['Q', 'D'],
['F', 'S'],
['J', 'W'],
['H', 'U'],
['V', 'I'],
['A', 'N'],
['O', 'B'],
['E', 'R'],
['F', 'S'],
['L', 'Y'],
['P', 'C'],
['Z', 'M']
];
const findAlphabet = (blocks, alphabet) => {
let indices = []
for(let i = 0; i < blocks.length; i += 1) {
if(blocks[i][0] === alphabet || blocks[i][1] == alphabet) {
indices.push(i);
}
}
return indices;
};
const getBlocksAtIndex = (blocks, indices) => {
let result = [];
for(let i = 0; i < indices.length; i += 1) {
result.push(blocks[indices[i]]);
}
return result;
};
const selectBlock = (blocks, remainingChars, currentChar) => {
for(let i = 0; i < blocks.length; i += 1) {
const one = blocks[i][0] === currentChar && !remainingChars[blocks[i][1]];
const two = blocks[i][1] === currentChar && !remainingChars[blocks[i][0]];
if(one || two) {
return i;
};
}
return 0;
};
const genHash = (arr) => {
const hash = {}
for(let i = 0; i < arr.length; i += 1) {
if(!hash[arr[i]]) {
hash[arr[i]] = 1;
} else {
hash[arr[i]] += 1;
}
}
return hash;
}
const canMakeWord = (blocks, word) => {
const blocksArr = [...blocks];
const charArr = word.split('');
const remainingChars = genHash(charArr);
for(let i = 0; i < charArr.length; i += 1) {
remainingChars[charArr[i]] -= 1;
const indices = findAlphabet(blocksArr, charArr[i]);
const blocksContainingChar = getBlocksAtIndex(blocksArr, indices);
if(blocksContainingChar.length === 0) return false;
const selectedBlockIndex = selectBlock(blocksContainingChar, remainingChars, charArr[i]);
blocksArr.splice(indices[selectedBlockIndex], 1);
};
return true;
};
module.exports = {
blocks,
findAlphabet,
getBlocksAtIndex,
selectBlock,
genHash,
canMakeWord
};
|
# !/bin/sh
# See https://developer.apple.com/library/mac/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Optimizing/Optimizing.html
iconutil -c icns WatchThis.iconset/
|
<reponame>AndySmile/BachelorThesis
/**
* @version 1.3.0 12-Jan-15
* @copyright Copyright (c) 2015 by <NAME>. All rights reserved. (http://andysmiles4games.com)
*/
#include <ImageProcessorHistogramHeightMap.h>
#include <OpenCV/cv.h>
#include <vector>
#include <algorithm>
#ifdef _DEBUG
#include <SimpleLib/Logger.h>
#include <OpenCV/cxcore.h>
#include <OpenCV/highgui.h>
#endif
ImageProcessorHistogramHeightMap::ImageProcessorHistogramHeightMap(void)
{
}
ImageProcessorHistogramHeightMap::~ImageProcessorHistogramHeightMap(void)
{
}
void ImageProcessorHistogramHeightMap::process(HeightMap* map, cv::Mat* image)
{
const int histogramSize = 256;
const int numberOfChannels = 0;
float channelRange[] = {0.0f, 256.0f};
const float* histogramRange = {channelRange};
std::vector<cv::Mat> listChannels;
cv::split(*image, listChannels);
unsigned short numChannels = listChannels.size();
cv::MatND* listHistograms = new cv::MatND[numChannels];
#ifdef _DEBUG
SimpleLib::Logger::writeDebug("Histogram Height Map Processor: number of channels: %d", listChannels.size());
// create a debug window to display the histogram values
cv::Size dimension = image->size();
cv::Mat debugHistogram(400, 256, CV_8UC3, cv::Scalar(0, 0, 0));
cv::namedWindow("Histogram Debug Output", CV_WINDOW_AUTOSIZE);
#endif
for (unsigned short i=0; i < numChannels; ++i) {
cv::calcHist(&listChannels[i], 1, &numberOfChannels, cv::Mat(), listHistograms[i], 1, &histogramSize, &histogramRange, true, false);
//cv::normalize(listHistograms[i], listHistograms[i], 0, 400, cv::NORM_MINMAX, -1, cv::MatND());
}
float* listHeights = new float[histogramSize];
//cv::line(debugHistogram, cv::Point(50, 0), cv::Point(50, dimension.height * dimension.width), cv::Scalar(255, 0, 0), 2);
for (int x=0; x < histogramSize; ++x)
{
for (int i=0; i < numChannels; ++i) {
cv::line(debugHistogram, cv::Point(x, 0), cv::Point(x, listHistograms[i].at<float>(x)), cv::Scalar((i == 0) ? 255 : 0, (i == 1) ? 255 : 0, (i == 2) ? 255 : 0));
}
}
for (int x=0; x < histogramSize; ++x)
{
float currHistogramValueA = listHistograms[0].at<float>(x);
for (int z=0; z < histogramSize; ++z)
{
float currAvgColor = currHistogramValueA;
for (int i=1; i < numChannels; ++i) {
currAvgColor += listHistograms[i].at<float>(z);
}
float currHeight = currAvgColor / numChannels;
// don't cross max height border
/*if (currHeight >= terrain->getHeight()) {
currHeight /= (float)terrain->getHeight();
}*/
listHeights[z] = currHeight;
// interpolate with previous height value
if (z > 0)
{
float minValue = std::min(currHeight, listHeights[z - 1]);
float maxValue = std::max(currHeight, listHeights[z - 1]);
if (minValue > 0.0f && maxValue > 0.0f)
{
float interpolationValue = minValue / maxValue;
currHeight = (listHeights[z - 1] * (1.0f - interpolationValue)) + (currHeight * interpolationValue);
}
}
map->setHeight(currHeight, x, z);
// terrain->setGridNode(x, currHeight, z);
}
}
imshow("Histogram Debug Output", debugHistogram);
delete[] listHeights;
delete[] listHistograms;
}
void ImageProcessorHistogramHeightMap::release(void)
{
}
|
PYTHONPATH=./:../../../
python run_tests.py
|
# Import necessary libraries
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
# Load the data
data = pd.read_csv('data.csv')
# Define features and target
X = data[['page_views', 'clicks', 'time_spent']]
y = data['buy']
# Create the model
model = RandomForestClassifier(n_estimators=100)
model.fit(X, y)
# Make predictions
predictions = model.predict(X)
|
// Generated by script, don't edit it please.
import createSvgIcon from '../../createSvgIcon';
import EnviraSvg from '@rsuite/icon-font/lib/legacy/Envira';
const Envira = createSvgIcon({
as: EnviraSvg,
ariaLabel: 'envira',
category: 'legacy',
displayName: 'Envira'
});
export default Envira;
|
from pendulum_eqns.physiology.muscle_params_BIC_TRI import *
from pendulum_eqns.physiology.musclutendon_equations import *
import numpy as np
from scipy import integrate
"""
################################
########## Parameters ##########
################################
c_{1} &= -\frac{3g}{2L} \\
c_{2} &= \frac{3}{ML^2} \\
c_{3} &= \cos(\rho_1) \\
c_{4} &= \cos(\rho_2)
c_{5} &= \frac{\cos(\alpha_{1})}{m_1} \\
c_{6} &= \frac{\cos^2(\alpha_{1})}{m_1} \\
c_{7} &= \frac{b_{m,1}\cos^2(\alpha_{1})}{m_1} \\
c_{8} &= \tan^2(\alpha_{1}) \\
c_{9} &= \frac{\cos(\alpha_{2})}{m_2} \\
c_{10} &= \frac{\cos^2(\alpha_{2})}{m_2} \\
c_{11} &= \frac{b_{m,2}\cos^2(\alpha_{2})}{m_2} \\
c_{12} &= \tan^2(\alpha_{2}) \\
################################
######## Tension Driven ########
################################
\dot{x}_1 &= x_{2} \\
\dot{x}_2 &= c_{1}\sin(x_{1}) + c_{2}R_{1}u_{1} - c_{2}R_{2}u_{2} \\
u_1 &= T_{1} \\
u_2 &= T_{2} \\
################################
#### Muscle Velocity Driven ####
################################
\dot{x}_1 &= x_{2} \\
\dot{x}_2 &= c_{1}\sin(x_{1}) + c_{2}R_{1}x_{3} - c_{2}R_{2}x_{4} \\
\dot{x}_3 &= K_{T,1}(v_{MTU,1} - c_{3}u_1) \\
\dot{x}_4 &= K_{T,2}(v_{MTU,2} - c_{4}u_2) \\
u_1 &= \dot{l}_{m,1} \\
u_2 &= \dot{l}_{m,2} \\
################################
### Muscle Activation Driven ###
################################
\dot{x}_1 &= x_{2} \\
\dot{x}_2 &= c_{1}\sin(x_{1}) + c_{2}R_{1}x_{3} - c_{2}R_{2}x_{4} \\
\dot{x}_3 &= K_{T,1}(v_{MTU,1} - c_{3}u_1) \\
\dot{x}_4 &= K_{T,2}(v_{MTU,2} - c_{4}u_2) \\
\dot{x}_5 &= x_7 \\
\dot{x}_6 &= x_8 \\
\dot{x}_7 &= c_5x_3 - c_6F_{PE,1}(x_5,x_7) - c_7x_7 + \frac{c_{8}x_7^2}{x_5} - c_6F_{LV,1}(x_5,x_7)u_1 \\
\dot{x}_8 &= c_9x_4 - c_{10}F_{PE,2}(x_6,x_8) - c_{11}x_8 + \frac{c_{12}x_8^2}{x_6} - c_{10}F_{LV,2}(x_6,x_8)u_2 \\
u_1 &= \alpha_{1} \\
u_2 &= \alpha_{2} \\
"""
g,L = 9.80, 0.45 #m/s², m
# g,L = 0, 0.45 #m/s², m REMOVING GRAVITY
M = 1.6 # kg
c1 = -(3*g)/(2*L)
c2 = 3/(M*L**2)
c3 = np.cos(α1)
c4 = np.cos(α2)
c5 = np.cos(α1)/m1
c6 = F_MAX1*np.cos(α1)**2/m1
c7 = F_MAX1*bm1*np.cos(α1)**2/(m1*lo1)
c8 = np.tan(α1)**2
c9 = np.cos(α2)/m2
c10 = F_MAX2*np.cos(α2)**2/m2
c11 = F_MAX2*bm2*np.cos(α2)**2/(m2*lo2)
c12 = np.tan(α2)**2
def dX1_dt(X):
return(X[1])
def d2X1_dt2(X):
return(dX2_dt(X))
def dX2_dt(X,U=None):
if U is None:
return(c1*np.sin(X[0]) + c2*R1(X)*X[2] + c2*R2(X)*X[3])
else:
return(c1*np.sin(X[0]) + c2*R1(X)*U[0] + c2*R2(X)*U[1])
def d2X2_dt2(X):
return(c1*np.cos(X[0])*dX1_dt(X) + c2*dR1_dx1(X)*dX1_dt(X)*X[2] + c2*R1(X)*dX3_dt(X)\
+ c2*dR2_dx1(X)*dX1_dt(X)*X[3] + c2*R2(X)*dX4_dt(X))
v_MTU1 = return_MTU_velocity([dX1_dt,dX2_dt],
[r1,dr1_dθ,d2r1_dθ2])
a_MTU1 = return_MTU_acceleration([dX1_dt,dX2_dt],
[r1,dr1_dθ,d2r1_dθ2])
v_MTU2 = return_MTU_velocity([dX1_dt,dX2_dt],
[r2,dr2_dθ,d2r2_dθ2])
a_MTU2 = return_MTU_acceleration([dX1_dt,dX2_dt],
[r2,dr2_dθ,d2r2_dθ2])
def dX3_dt(X,U=None):
if U is None:
return(KT_1(X)*(v_MTU1(X) - c3*X[6]))
else:
return(KT_1(X)*(v_MTU1(X) - c3*U[0]))
def dX4_dt(X,U=None):
if U is None:
return(KT_2(X)*(v_MTU2(X) - c4*X[7]))
else:
return(KT_2(X)*(v_MTU2(X) - c4*U[1]))
def dX5_dt(X):
return(X[6])
def dX6_dt(X):
return(X[7])
def dX7_dt(X,U):
return(c5*X[2] - c6*F_PE1_1(X) - c7*X[6] + c8*X[6]**2/X[4] - c6*FLV_1(X)*U[0])
def dX8_dt(X,U):
return(c9*X[3] - c10*F_PE1_2(X) - c11*X[7] + c12*X[7]**2/X[5] - c10*FLV_2(X)*U[1])
"""
################################
###### Plotting Functions ######
################################
"""
def plot_states(t,X,**kwargs):
"""
Takes in a numpy.ndarray for time (t) of shape (N,) and the numpy.ndarray for the state space (X) of shape (M,N), where M is the number of states and N is the same length as time t. Returns a plot of the states.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**kwargs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1) Return - must be a bool. Determines if the function returns a function handle. Default is False.
2) InputString - must be a string. Input to the DescriptiveTitle that can be used to personalize the title. Default is None.
"""
import numpy as np
import matplotlib.pyplot as plt
assert (np.shape(X)[0] in [2,4,8]) \
and (np.shape(X)[1] == len(t)) \
and (str(type(X)) == "<class 'numpy.ndarray'>"), \
"X must be a (2,N), (4,N), or (8,N) numpy.ndarray, where N is the length of t."
Return = kwargs.get("Return",False)
assert type(Return)==bool, "Return must be either True or False."
InputString = kwargs.get("InputString",None)
assert InputString is None or type(InputString)==str, "InputString must either be None or a str."
NumStates = np.shape(X)[0]
X[:2,:] = 180*X[:2,:]/np.pi # converting to deg and deg/s
if NumStates!=8:
NumRows = int(np.ceil(NumStates/5))
if NumStates < 5:
NumColumns = NumStates
else:
NumColumns = 5
ColumnNumber = [el%5 for el in np.arange(0,NumStates,1)]
RowNumber = [int(el/5) for el in np.arange(0,NumStates,1)]
Units = ["(Deg)","(Deg/s)","(N)","(N)","(m)","(m)","(m/s)","(m/s)"]
else:
NumRows=2
NumColumns=4
if InputString is None:
DescriptiveTitle = "Plotting States vs. Time"
else:
assert type(InputString)==str, "InputString must be a string"
DescriptiveTitle = InputString + " Driven"
if NumRows == 1:
FigShape = (NumColumns,)
else:
FigShape = (NumRows,NumColumns)
Figure = kwargs.get("Figure",None)
assert (Figure is None) or \
( (type(Figure)==tuple) and \
(str(type(Figure[0]))=="<class 'matplotlib.figure.Figure'>") and\
(np.array([str(type(ax))=="<class 'matplotlib.axes._subplots.AxesSubplot'>" \
for ax in Figure[1].flatten()]).all()) and \
(Figure[1].shape == FigShape)\
),\
("Figure can either be left blank (None) or it must be constructed from data that has the same shape as X.\ntype(Figure) = " + str(type(Figure)) + "\ntype(Figure[0]) = " + str(type(Figure[0])) + "\nFigure[1].shape = " + str(Figure[1].shape) + " instead of (" + str(NumRows) + "," + str(NumColumns) + ")" + "\ntype(Figure[1].flatten()[0]) = " + str(type(Figure[1].flatten()[0])))
if Figure is None:
if NumStates!=8:
fig, axes = plt.subplots(NumRows,NumColumns,figsize=(3*NumColumns,2*NumRows + 2))
plt.subplots_adjust(top=0.85,bottom=0.15,left=0.075,right=0.975)
plt.suptitle(DescriptiveTitle,Fontsize=20,y=0.975)
if NumStates <=5:
for j in range(NumStates):
axes[ColumnNumber[j]].spines['right'].set_visible(False)
axes[ColumnNumber[j]].spines['top'].set_visible(False)
axes[ColumnNumber[j]].plot(t,X[j,:])
if ColumnNumber[j]!=0:
axes[ColumnNumber[j]].set_xticklabels(\
[""]*len(axes[ColumnNumber[j]].get_xticks()))
else:
axes[ColumnNumber[j]].set_xlabel("Time (s)")
axes[ColumnNumber[j]].set_title(r"$x_{" + str(j+1) + "}$ " + Units[j])
else:
for j in range(NumStates):
axes[RowNumber[j],ColumnNumber[j]].spines['right'].set_visible(False)
axes[RowNumber[j],ColumnNumber[j]].spines['top'].set_visible(False)
axes[RowNumber[j],ColumnNumber[j]].plot(t,X[j,:])
if not(RowNumber[j] == RowNumber[-1] and ColumnNumber[j]==0):
axes[RowNumber[j],ColumnNumber[j]].set_xticklabels(\
[""]*len(axes[RowNumber[j],ColumnNumber[j]].get_xticks()))
else:
axes[RowNumber[j],ColumnNumber[j]].set_xlabel("Time (s)")
axes[RowNumber[j],ColumnNumber[j]].set_title(r"$x_{" + str(j+1) + "}$ "+ Units[j])
if NumStates%5!=0:
[fig.delaxes(axes[RowNumber[-1],el]) for el in range(ColumnNumber[-1]+1,5)]
else:
units = [
r"$\theta$ (deg)", r"$\dot{\theta}$ (deg/s)",
r"$f_{T,1}$ (N)", r"$f_{T,2}$ (N)",
r"$l_{m,1}$ (m)", r"$l_{m,2}$ (m)",
r"$v_{m,1}$ (m/s)", r"$v_{m,2}$ (m/s)"
]
fig, axes = plt.subplots(2,4,figsize=(14,7),sharex=True)
plt.subplots_adjust(top=0.85,bottom=0.15,left=0.075,right=0.975)
plt.suptitle(DescriptiveTitle,Fontsize=20,y=0.975)
for ax in axes.flatten():
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
for i in range(2):
for j in range(4):
if i==1 and j==0:
axes[i,j].set_xlabel("Time (s)")
else:
plt.setp(
axes[i,j].get_xticklabels(),
visible=False
)
axes[0,0].plot(t,X[0,:])
axes[0,0].set_title(units[0])
axes[1,0].plot(t,X[1,:])
axes[1,0].set_title(units[1])
axes[0,1].plot(t,X[2,:])
axes[0,1].set_title(units[2])
axes[1,1].plot(t,X[3,:])
axes[1,1].set_title(units[3])
axes[0,2].plot(t,X[4,:])
axes[0,2].set_title(units[4])
axes[1,2].plot(t,X[5,:])
axes[1,2].set_title(units[5])
axes[0,3].plot(t,X[6,:])
axes[0,3].set_title(units[6])
axes[1,3].plot(t,X[7,:])
axes[1,3].set_title(units[7])
else:
fig = Figure[0]
axes = Figure[1]
if NumStates!=8:
for i in range(NumStates):
if NumRows != 1:
axes[RowNumber[i],ColumnNumber[i]].plot(t,X[i,:])
else:
axes[ColumnNumber[i]].plot(t,X[i,:])
else:
axes[0,0].plot(t,X[0,:])
axes[1,0].plot(t,X[1,:])
axes[0,1].plot(t,X[2,:])
axes[1,1].plot(t,X[3,:])
axes[0,2].plot(t,X[4,:])
axes[1,2].plot(t,X[5,:])
axes[0,3].plot(t,X[6,:])
axes[1,3].plot(t,X[7,:])
X[:2,:] = np.pi*X[:2,:]/180
if Return == True:
return((fig,axes))
else:
plt.show()
def plot_inputs(t,U,**kwargs):
"""
Takes in a numpy.ndarray for time (t) of shape (N,) and the numpy.ndarray for the input (U) (NOT NECESSARILY THE SAME LENGTH AS t). Returns a plot of the states.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**kwargs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1) Return - must be a bool. Determines if the function returns a function handle. Default is False.
2) InputString - must be a string. Input to the DescriptiveTitle that can be used to personalize the title. Default is None.
"""
import numpy as np
import matplotlib.pyplot as plt
assert (np.shape(U)[0] == 2) \
and (np.shape(U)[1] == len(t)) \
and (str(type(U)) == "<class 'numpy.ndarray'>"), \
"X must be a (2,N) numpy.ndarray, where N is the length of t."
Return = kwargs.get("Return",False)
assert type(Return)==bool, "Return must be either True or False."
InputString = kwargs.get("InputString",None)
assert InputString is None or type(InputString)==str, "InputString must either be None or a str."
if InputString is None:
DescriptiveTitle = "Plotting Inputs vs. Time"
else:
assert type(InputString)==str, "InputString must be a string"
DescriptiveTitle = InputString + " vs. Time"
Figure = kwargs.get("Figure",None)
assert (Figure is None) or \
( (type(Figure)==tuple) and \
(str(type(Figure[0]))=="<class 'matplotlib.figure.Figure'>") and\
(np.array([str(type(ax))=="<class 'matplotlib.axes._subplots.AxesSubplot'>" \
for ax in Figure[1].flatten()]).all()) and \
(Figure[1].shape == (2,))\
),\
"Figure can either be left blank (None) or it must be constructed from data that has the same shape as U."
if Figure is None:
fig, axes = plt.subplots(1,2,figsize=(13,5))
plt.subplots_adjust(top=0.9,hspace=0.4,bottom=0.1,left=0.075,right=0.975)
plt.suptitle(DescriptiveTitle,Fontsize=20,y=0.975)
axes[0].plot(t,U[0,:],lw=2)
axes[0].plot([-1,t[-1]+1],[0,0],'k--',lw=0.5)
axes[0].set_xlim([t[0],t[-1]])
axes[0].spines['right'].set_visible(False)
axes[0].spines['top'].set_visible(False)
axes[0].set_ylabel(r"$u_1$")
axes[0].set_xlabel("Time (s)")
axes[0].spines['top'].set_visible(False)
axes[0].spines['right'].set_visible(False)
axes[1].plot(t,U[1,:],lw=2)
axes[1].plot([-1,t[-1]+1],[0,0],'k--',lw=0.5)
axes[1].set_xlim([t[0],t[-1]])
axes[1].spines['right'].set_visible(False)
axes[1].spines['top'].set_visible(False)
axes[1].set_ylabel(r"$u_2$")
axes[1].set_xticks(axes[0].get_xticks())
axes[1].set_xticklabels([""]*len(axes[0].get_xticks()))
axes[1].spines['top'].set_visible(False)
axes[1].spines['right'].set_visible(False)
else:
fig = Figure[0]
axes = Figure[1]
axes[0].plot(t,U[0,:],lw=2)
axes[1].plot(t,U[1,:],lw=2)
if Return == True:
return((fig,axes))
else:
plt.show()
def plot_l_m_comparison(t,X,**kwargs):
"""
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**kwargs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1) Return - must be a bool. Determines if the function returns a function handle. Default is False.
2) InputString - must be a string. Input to the DescriptiveTitle that can be used to personalize the title. Default is None.
"""
import numpy as np
import matplotlib.pyplot as plt
assert (np.shape(X)[0] >= 2) \
and (np.shape(X)[1] == len(t)) \
and (str(type(X)) == "<class 'numpy.ndarray'>"), \
"X must be a (M,N) numpy.ndarray, where M is greater than or equal to 2 and N is the length of t."
Return = kwargs.get("Return",False)
assert type(Return)==bool, "Return must be either True or False."
InputString = kwargs.get("InputString",None)
assert InputString is None or type(InputString)==str, "InputString must either be None or a str."
if InputString is None:
DescriptiveTitle = "Muscle vs. Musculotendon Lengths"
else:
DescriptiveTitle = "Muscle vs. Musculotendon Lengths\n" + InputString + " Driven"
L_m = kwargs.get("MuscleLengths",None)
assert (L_m is None) or (str(type(L_m))=="<class 'numpy.ndarray'>" and np.shape(L_m)==(2,len(t))), "L_m must either be a numpy.ndarray of size (2,N) or left as None (Default)."
V_m = kwargs.get("MuscleVelocities",None)
assert (V_m is None) or (str(type(V_m))=="<class 'numpy.ndarray'>" and np.shape(V_m)==(2,len(t))), "V_m must either be a numpy.ndarray of size (2,N) or left as None (Default)."
ReturnError = kwargs.get("ReturnError",False)
assert type(ReturnError)==bool, "ReturnError must be either True or False."
IgnorePennation = kwargs.get("IgnorePennation",True)
assert type(IgnorePennation)==bool, "IgnorePennation must be either True (default) or False."
assert L_m is not None or V_m is not None, "Error! Need to input some length/velocity measurement for the muscles."
if L_m is None:
"""
This is for the muscle velocity driven controller. These values of initial muscle length are estimates taken to be the optimal muscle lengths. We will need to run some sensitivity analysis to ensure that this does not drastically effect the deviations from the MTU estimate.
"""
l_m1 = integrate.cumtrapz(V_m[0,:],t,initial = 0) + np.ones(len(t))*lo1
l_m2 = integrate.cumtrapz(V_m[1,:],t,initial = 0) + np.ones(len(t))*lo2
else:
l_m1 = L_m[0,:]
l_m2 = L_m[1,:]
"""
Note: X must be transposed in order to run through map()
"""
Figure = kwargs.get("Figure",None)
assert (Figure is None) \
or (
(type(Figure)==tuple) and \
(str(type(Figure[0]))=="<class 'matplotlib.figure.Figure'>") and\
(np.array([str(type(ax))=="<class 'matplotlib.axes._subplots.AxesSubplot'>" \
for ax in Figure[1].flatten()]).all()) and \
(Figure[1].shape == (2,2))\
),\
"Figure can either be left blank (None) or it must be constructed from data that has the same shape as X."
if Figure is None:
fig, axes = plt.subplots(2,2,figsize = (14,7))
plt.suptitle(DescriptiveTitle,Fontsize=20,y=0.975)
if IgnorePennation==True:
l_m1_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU1(X),X.T))),\
t,initial=0
) \
+ np.ones(len(t))*l_m1[0]
l_m2_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU2(X),X.T))),\
t,initial=0
) \
+ np.ones(len(t))*l_m2[0]
else:
l_m1_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU1(X),X.T))),\
t,initial=0
)/np.cos(α1) \
+ np.ones(len(t))*l_m1[0]
l_m2_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU2(X),X.T))),\
t,initial=0
)/np.cos(α2) \
+ np.ones(len(t))*l_m2[0]
axes[0,0].plot(t,l_m1_by_MTU_approximation, '0.70')
axes[0,0].plot(t,l_m1)
axes[0,0].set_ylabel(r"$l_{m,1}/l_{MTU,1}$ (m)")
axes[0,0].set_xlabel("Time (s)")
axes[0,0].spines['top'].set_visible(False)
axes[0,0].spines['right'].set_visible(False)
axes[0,1].plot(t,l_m1-l_m1_by_MTU_approximation)
axes[0,1].set_ylabel("Error (m)")
axes[0,1].set_xlabel("Time (s)")
axes[0,1].spines['top'].set_visible(False)
axes[0,1].spines['right'].set_visible(False)
axes[1,0].plot(t,l_m2_by_MTU_approximation, '0.70')
axes[1,0].plot(t,l_m2)
axes[1,0].set_ylabel(r"$l_{m,2}/l_{MTU,2}$ (m)")
axes[1,0].set_xlabel("Time (s)")
axes[1,0].spines['top'].set_visible(False)
axes[1,0].spines['right'].set_visible(False)
axes[1,1].plot(t,l_m2-l_m2_by_MTU_approximation)
axes[1,1].set_ylabel("Error (m)")
axes[1,1].set_xlabel("Time (s)")
axes[1,1].spines['top'].set_visible(False)
axes[1,1].spines['right'].set_visible(False)
else:
fig = Figure[0]
axes = Figure[1]
if IgnorePennation==False:
l_m1_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU1(X),X.T))),\
t,initial=0
) \
+ np.ones(len(t))*l_m1[0]
l_m2_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU2(X),X.T))),\
t,initial=0
) \
+ np.ones(len(t))*l_m2[0]
else:
l_m1_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU1(X),X.T))),\
t,initial=0
)/np.cos(α1) \
+ np.ones(len(t))*l_m1[0]
l_m2_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU2(X),X.T))),\
t,initial=0
)/np.cos(α2) \
+ np.ones(len(t))*l_m2[0]
axes[0,0].plot(t,l_m1_by_MTU_approximation, '0.70')
axes[0,0].plot(t,l_m1)
axes[0,1].plot(t,l_m1-l_m1_by_MTU_approximation)
axes[1,0].plot(t,l_m2_by_MTU_approximation, '0.70')
axes[1,0].plot(t,l_m2)
axes[1,1].plot(t,l_m2-l_m2_by_MTU_approximation)
if Return == True:
if ReturnError == True:
return(
(fig,axes),
[l_m1-l_m1_by_MTU_approximation,l_m2-l_m2_by_MTU_approximation]
)
else:
return((fig,axes))
else:
if ReturnError == True:
plt.show()
return([l_m1-l_m1_by_MTU_approximation,l_m2-l_m2_by_MTU_approximation])
else:
plt.show()
def plot_norm_l_m_comparison(t,X,**kwargs):
"""
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**kwargs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1) Return - must be a bool. Determines if the function returns a function handle. Default is False.
2) InputString - must be a string. Input to the DescriptiveTitle that can be used to personalize the title. Default is None.
"""
import numpy as np
import matplotlib.pyplot as plt
assert (np.shape(X)[0] >= 2) \
and (np.shape(X)[1] == len(t)) \
and (str(type(X)) == "<class 'numpy.ndarray'>"), \
"X must be a (M,N) numpy.ndarray, where M is greater than or equal to 2 and N is the length of t."
Return = kwargs.get("Return",False)
assert type(Return)==bool, "Return must be either True or False."
InputString = kwargs.get("InputString",None)
assert InputString is None or type(InputString)==str, "InputString must either be None or a str."
if InputString is None:
DescriptiveTitle = "Muscle vs. Musculotendon Lengths"
else:
DescriptiveTitle = "Muscle vs. Musculotendon Lengths\n" + InputString + " Driven"
L_m = kwargs.get("MuscleLengths",None)
assert (L_m is None) or (str(type(L_m))=="<class 'numpy.ndarray'>" and np.shape(L_m)==(2,len(t))), "L_m must either be a numpy.ndarray of size (2,N) or left as None (Default)."
V_m = kwargs.get("MuscleVelocities",None)
assert (V_m is None) or (str(type(V_m))=="<class 'numpy.ndarray'>" and np.shape(V_m)==(2,len(t))), "V_m must either be a numpy.ndarray of size (2,N) or left as None (Default)."
ReturnError = kwargs.get("ReturnError",False)
assert type(ReturnError)==bool, "ReturnError must be either True or False."
IgnorePennation = kwargs.get("IgnorePennation",True)
assert type(IgnorePennation)==bool, "IgnorePennation must be either True (default) or False."
assert L_m is not None or V_m is not None, "Error! Need to input some length/velocity measurement for the muscles."
if L_m is None:
"""
This is for the muscle velocity driven controller. These values of initial muscle length are estimates taken to be the optimal muscle lengths. We will need to run some sensitivity analysis to ensure that this does not drastically effect the deviations from the MTU estimate.
"""
l_m1 = integrate.cumtrapz(V_m[0,:],t,initial = 0) + np.ones(len(t))*lo1
l_m2 = integrate.cumtrapz(V_m[1,:],t,initial = 0) + np.ones(len(t))*lo2
else:
l_m1 = L_m[0,:]
l_m2 = L_m[1,:]
"""
Note: X must be transposed in order to run through map()
"""
Figure = kwargs.get("Figure",None)
assert (Figure is None) \
or (
(type(Figure)==tuple) and \
(str(type(Figure[0]))=="<class 'matplotlib.figure.Figure'>") and\
(np.array([str(type(ax))=="<class 'matplotlib.axes._subplots.AxesSubplot'>" \
for ax in Figure[1].flatten()]).all()) and \
(Figure[1].shape == (2,2))\
),\
"Figure can either be left blank (None) or it must be constructed from data that has the same shape as X."
if Figure is None:
fig, axes = plt.subplots(2,2,figsize = (14,7))
plt.suptitle(DescriptiveTitle,Fontsize=20,y=0.975)
if IgnorePennation==True:
l_m1_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU1(X),X.T))),\
t,initial=0
) \
+ np.ones(len(t))*l_m1[0]
l_m2_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU2(X),X.T))),\
t,initial=0
) \
+ np.ones(len(t))*l_m2[0]
else:
l_m1_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU1(X),X.T))),\
t,initial=0
)/np.cos(α1) \
+ np.ones(len(t))*l_m1[0]
l_m2_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU2(X),X.T))),\
t,initial=0
)/np.cos(α2) \
+ np.ones(len(t))*l_m2[0]
axes[0,0].plot(t,l_m1_by_MTU_approximation/lo1, '0.70')
axes[0,0].plot(t,l_m1/lo1)
axes[0,0].set_ylabel(r"$\hat{l}_{m,1}/\hat{l}_{MTU,1}$")
axes[0,0].set_xlabel("Time (s)")
axes[0,0].spines['top'].set_visible(False)
axes[0,0].spines['right'].set_visible(False)
axes[0,1].plot(t,(l_m1-l_m1_by_MTU_approximation)/lo1)
axes[0,1].set_ylabel("Normalized Error")
axes[0,1].set_xlabel("Time (s)")
axes[0,1].spines['top'].set_visible(False)
axes[0,1].spines['right'].set_visible(False)
axes[1,0].plot(t,l_m2_by_MTU_approximation/lo2, '0.70')
axes[1,0].plot(t,l_m2/lo2)
axes[1,0].set_ylabel(r"$\hat{l}_{m,2}/\hat{l}_{MTU,2}$")
axes[1,0].set_xlabel("Time (s)")
axes[1,0].spines['top'].set_visible(False)
axes[1,0].spines['right'].set_visible(False)
axes[1,1].plot(t,(l_m2-l_m2_by_MTU_approximation)/lo2)
axes[1,1].set_ylabel("Normalized Error")
axes[1,1].set_xlabel("Time (s)")
axes[1,1].spines['top'].set_visible(False)
axes[1,1].spines['right'].set_visible(False)
else:
fig = Figure[0]
axes = Figure[1]
if IgnorePennation==False:
l_m1_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU1(X),X.T))),\
t,initial=0
) \
+ np.ones(len(t))*l_m1[0]
l_m2_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU2(X),X.T))),\
t,initial=0
) \
+ np.ones(len(t))*l_m2[0]
else:
l_m1_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU1(X),X.T))),\
t,initial=0
)/np.cos(α1) \
+ np.ones(len(t))*l_m1[0]
l_m2_by_MTU_approximation = integrate.cumtrapz(
np.array(list(map(lambda X: v_MTU2(X),X.T))),\
t,initial=0
)/np.cos(α2) \
+ np.ones(len(t))*l_m2[0]
axes[0,0].plot(t,l_m1_by_MTU_approximation/lo1, '0.70')
axes[0,0].plot(t,l_m1/lo1)
axes[0,1].plot(t,(l_m1-l_m1_by_MTU_approximation)/lo1)
axes[1,0].plot(t,l_m2_by_MTU_approximation/lo2, '0.70')
axes[1,0].plot(t,l_m2/lo2)
axes[1,1].plot(t,(l_m2-l_m2_by_MTU_approximation)/lo2)
if Return == True:
if ReturnError == True:
return(
(fig,axes),
[l_m1-l_m1_by_MTU_approximation,l_m2-l_m2_by_MTU_approximation]
)
else:
return((fig,axes))
else:
if ReturnError == True:
plt.show()
return([l_m1-l_m1_by_MTU_approximation,l_m2-l_m2_by_MTU_approximation])
else:
plt.show()
def plot_norm_v_m_comparison(t,X,**kwargs):
"""
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**kwargs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1) Return - must be a bool. Determines if the function returns a function handle. Default is False.
2) InputString - must be a string. Input to the DescriptiveTitle that can be used to personalize the title. Default is None.
"""
import numpy as np
import matplotlib.pyplot as plt
assert (np.shape(X)[0] >= 2) \
and (np.shape(X)[1] == len(t)) \
and (str(type(X)) == "<class 'numpy.ndarray'>"), \
"X must be a (M,N) numpy.ndarray, where M is greater than or equal to 2 and N is the length of t."
Return = kwargs.get("Return",False)
assert type(Return)==bool, "Return must be either True or False."
InputString = kwargs.get("InputString",None)
assert InputString is None or type(InputString)==str, "InputString must either be None or a str."
if InputString is None:
DescriptiveTitle = "Muscle vs. Musculotendon Velocities\n(Normalized)"
else:
DescriptiveTitle = "Muscle vs. Musculotendon Velocities\n" + InputString + " Driven\n(Normalized)"
ReturnError = kwargs.get("ReturnError",False)
assert type(ReturnError)==bool, "ReturnError must be either True or False."
IgnorePennation = kwargs.get("IgnorePennation",True)
assert type(IgnorePennation)==bool, "IgnorePennation must be either True (default) or False."
v_m1 = X[6,:]
v_m2 = X[7,:]
"""
Note: X must be transposed in order to run through map()
"""
Figure = kwargs.get("Figure",None)
assert (Figure is None) \
or (
(type(Figure)==tuple) and \
(str(type(Figure[0]))=="<class 'matplotlib.figure.Figure'>") and\
(np.array([str(type(ax))=="<class 'matplotlib.axes._subplots.AxesSubplot'>" \
for ax in Figure[1].flatten()]).all()) and \
(Figure[1].shape == (2,2))\
),\
"Figure can either be left blank (None) or it must be constructed from data that has the same shape as X."
if Figure is None:
fig, axes = plt.subplots(2,2,figsize = (14,7))
plt.suptitle(DescriptiveTitle,Fontsize=20,y=0.975)
if IgnorePennation==True:
v_MT1 = np.array(list(map(lambda X: v_MTU1(X),X.T)))
v_MT2 = np.array(list(map(lambda X: v_MTU2(X),X.T)))
else:
v_MT1 = np.array(list(map(lambda X: v_MTU1(X),X.T)))/np.cos(α1)
v_MT2 = np.array(list(map(lambda X: v_MTU2(X),X.T)))/np.cos(α2)
axes[0,0].plot(t,v_MT1/lo1, '0.70')
axes[0,0].plot(t,v_m1/lo1)
axes[0,0].set_ylabel(r"$\hat{v}_{m,1}/\hat{v}_{MT,1}$")
axes[0,0].set_xlabel("Time (s)")
axes[0,0].spines["top"].set_visible(False)
axes[0,0].spines["right"].set_visible(False)
axes[0,1].plot(t,(v_m1-v_MT1)/lo1)
axes[0,1].set_ylabel("Normalized Error")
axes[0,1].set_xlabel("Time (s)")
axes[0,1].spines["top"].set_visible(False)
axes[0,1].spines["right"].set_visible(False)
axes[1,0].plot(t,v_MT2/lo2, '0.70')
axes[1,0].plot(t,v_m2/lo2)
axes[1,0].set_ylabel(r"$\hat{v}_{m,2}/\hat{v}_{MT,2}$")
axes[1,0].set_xlabel("Time (s)")
axes[1,0].spines["top"].set_visible(False)
axes[1,0].spines["right"].set_visible(False)
axes[1,1].plot(t,(v_m2-v_MT2)/lo2)
axes[1,1].set_ylabel("Normalized Error")
axes[1,1].set_xlabel("Time (s)")
axes[1,1].spines["top"].set_visible(False)
axes[1,1].spines["right"].set_visible(False)
else:
fig = Figure[0]
axes = Figure[1]
if IgnorePennation==True:
v_MT1 = np.array(list(map(lambda X: v_MTU1(X),X.T)))
v_MT2 = np.array(list(map(lambda X: v_MTU2(X),X.T)))
else:
v_MT1 = np.array(list(map(lambda X: v_MTU1(X),X.T)))/np.cos(α1)
v_MT2 = np.array(list(map(lambda X: v_MTU2(X),X.T)))/np.cos(α2)
axes[0,0].plot(t,v_MT1/lo1, '0.70')
axes[0,0].plot(t,v_m1/lo1)
axes[0,1].plot(t,(v_m1-v_MT1)/lo1)
axes[1,0].plot(t,v_MT2/lo2, '0.70')
axes[1,0].plot(t,v_m2/lo2)
axes[1,1].plot(t,(v_m2-v_MT2)/lo2)
if Return == True:
if ReturnError == True:
return(
(fig,axes),
[v_m1-v_MT1,v_m2-v_MT2]
)
else:
return((fig,axes))
else:
if ReturnError == True:
plt.show()
return([v_m1-v_MT1,v_m2-v_MT2])
else:
plt.show()
|
#!/usr/bin/env python3
from PyQt5 import QtWidgets
from dsrlib.ui.mixins import MainWindowMixin
from dsrlib.ui.widgets import ButtonListWidget
from dsrlib.domain import commands
from .base import ActionWidgetMixin
class GyroActionButtonListWidget(ButtonListWidget):
def __init__(self, *args, action, **kwargs):
self._action = action
super().__init__(*args, **kwargs)
def isChecked(self, button):
return button in self._action.buttons()
class GyroActionWidget(MainWindowMixin, ActionWidgetMixin, QtWidgets.QWidget):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._buttons = GyroActionButtonListWidget(self, action=self.action())
self.doLayout(self.action().labelFormat(), buttons=self._buttons)
self._buttons.buttonChanged.connect(self._toggleButton)
def reload(self):
self._buttons.reload()
def _toggleButton(self, button, enabled):
buttons = self.action().buttons()
if enabled and button not in buttons:
buttons.append(button)
elif button in buttons and not enabled:
buttons.remove(button)
if buttons != self.action().buttons():
cmd = commands.SetGyroButtonsCommand(action=self.action(), buttons=buttons)
self.history().run(cmd)
|
<reponame>tribock/orbos
package kubernetes
import (
"fmt"
"time"
v1 "k8s.io/api/core/v1"
"github.com/caos/orbos/mntr"
"github.com/caos/orbos/pkg/kubernetes"
)
func maintainNodes(allInitializedMachines initializedMachines, monitor mntr.Monitor, k8sClient *kubernetes.Client, pdf func(mntr.Monitor) error) (done bool, err error) {
// Delete kubernetes nodes for unexisting machines
if k8sClient != nil {
nodes, err := k8sClient.ListNodes()
if err != nil {
return false, err
}
for nodeIdx := range nodes {
node := nodes[nodeIdx]
nodeName := node.GetName()
leave := false
for idx := range allInitializedMachines {
machine := allInitializedMachines[idx]
if machine.infra.ID() == nodeName {
leave = true
break
}
}
if !leave {
for idx := range node.Status.Conditions {
condition := node.Status.Conditions[idx]
if condition.Type == v1.NodeReady && condition.Status == v1.ConditionTrue {
return false, fmt.Errorf("there is no infrastructure machine corresponding to Kubernetes node %s, yet the node is still ready", nodeName)
}
}
if err := k8sClient.DeleteNode(nodeName); err != nil {
return false, err
}
monitor.WithField("node", nodeName).Info("Node deleted")
}
}
}
allInitializedMachines.forEach(monitor, func(machine *initializedMachine, machineMonitor mntr.Monitor) bool {
if err = machine.reconcile(); err != nil {
return false
}
return true
})
if err != nil {
return false, err
}
allInitializedMachines.forEach(monitor, func(machine *initializedMachine, machineMonitor mntr.Monitor) bool {
req, _, unreq := machine.infra.RebootRequired()
if !req {
return true
}
if machine.node != nil {
if err = k8sClient.Drain(machine.currentMachine, machine.node, kubernetes.Rebooting, false); err != nil {
return false
}
}
machine.currentMachine.Rebooting = true
machineMonitor.Info("Requiring reboot")
unreq()
machine.desiredNodeagent.RebootRequired = time.Now().Truncate(time.Minute)
err = pdf(monitor.WithField("reason", "remove machine from reboot list"))
return false
})
if err != nil {
return false, err
}
done = true
allInitializedMachines.forEach(monitor, func(machine *initializedMachine, machineMonitor mntr.Monitor) bool {
if !machine.currentMachine.FirewallIsReady {
done = false
machineMonitor.Info("Node agent is not ready yet")
}
return true
})
return done, nil
}
|
<reponame>JesseeMeadows/Fury-Fighter<gh_stars>1-10
import java.awt.image.BufferedImage;
import java.awt.Rectangle;
import javax.imageio.ImageIO;
import java.io.File;
import java.io.IOException;
import java.awt.*;
public class Bullet {
private float VELOCITY;
protected boolean toBeDeleted;
protected int xPos; // x-Coordinate of bullet
protected int yPos; // y-Coordinate of bullet
private int direction;
private int millisecDelay;
private int height;
private int width;
protected int power; // bullet's damage
protected float velocity; // bullet's speed
BufferedImage bulletImage;
Bullet(int x, int y, int direction) {
xPos = x;
yPos = y;
millisecDelay = 10;
this.direction = direction;
velocity = 0.5f;
power = 1;
toBeDeleted = false;
// loads bullet's image -- should be cached instead
try {
this.bulletImage = ImageIO.read(new File("assets/bulletImage.png"));
}
catch (IOException e) {
e.printStackTrace();
}
height = bulletImage.getHeight();
width = bulletImage.getWidth();
}
// Checks if bullets contacts passed in object's hitbox
public boolean collidesWith(Rectangle boundingBox) {
Rectangle bulletBox = getBoundingBox();
return Utils.boxCollision(bulletBox, boundingBox);
}
// Gets hit box of bullet
public Rectangle getBoundingBox() {
return new Rectangle(this.xPos, this.yPos, this.bulletImage.getWidth(), this.bulletImage.getHeight());
}
// Updates the bullets position based on the bullets velocity and direction
public int update(float dt) {
switch (direction) {
case 0: yPos -= velocity * dt;
break;
case 1: xPos += velocity * dt;
yPos -= velocity * dt;
break;
case 2: xPos += velocity * dt;
break;
case 3: xPos += velocity * dt;
yPos += velocity * dt;
break;
case 4: yPos += velocity * dt;
break;
case 5: xPos -= this.velocity * dt;
yPos += this.velocity * dt;
break;
case 6: xPos -= velocity * dt;
break;
case 7: xPos -= velocity * dt;
yPos -= velocity * dt;
break;
}
return 0;
}
// returns true if bullet of off screen
/* TODO: I don't trust the screen edge logic in this method, but its the best we have with no documentation. */
public boolean shouldDelete() {
if (xPos + width >= ViewController.SCREEN_WIDTH || xPos < 0 || yPos + height >= ViewController.SCREEN_HEIGHT - (64) || yPos < 0) {
return true;
}
else if (toBeDeleted == true) {
return true;
}
else {
return false;
}
}
public int getMillisecDelay() {
return this.millisecDelay;
}
public int getDirection() {
return direction;
}
public int getPower() {
return this.power;
}
public void render(Graphics2D g2, float rw, float rh) {
g2.drawImage(this.bulletImage, this.xPos, this.yPos, (int) rw * this.bulletImage.getWidth(), (int) rh * this.bulletImage.getHeight(), null);
}
}
|
#!/bin/bash -eu
function main() {
local cwd
cwd="${1}"
local version
version="$(cat om-version/version)"
export GOPATH="${cwd}/go"
pushd "${GOPATH}/src/github.com/pivotal-cf/om" > /dev/null
for OS in darwin linux windows; do
local name
name="om-${OS}"
echo "building $OS"
if [[ "${OS}" == "windows" ]]; then
name="${name}.exe"
fi
CGO_ENABLED=0 \
GOOS=${OS} \
GOARCH=amd64 \
go build \
-ldflags "-X main.version=${version}" \
-o "${cwd}/binaries/${name}" \
main.go
done
popd > /dev/null
}
main "${PWD}"
|
#/usr/bin/env bash
#Menu do formulário
dados=$(zenity --forms \
--title='Formulario' \
--text='Formulario para criação de usuario' \
--add-entry='Nome' \
--add-entry='Sobre-nome' \
--add-password='Senha' \
--separator=',' \
--ok-label='Enviar'
)
if [ "$?" -eq '1' ]; then
exit 0
fi
nome_sobrenome=$(cut -d ',' -f 1 ,2 <<< "$dados" | sed 's/,/ /g')
senha=$(cut -d ',' -f 3 <<< "$dados")
if [ -z "$senha" ]; then
zenity --error --text="O campo senha esta NULO."
fi
zenity --info --title="Campos de informação." --text="O seu nome é: $nome_sobrenome\nA sua senha é: $senha"
|
#!/bin/sh
set -e
UNSIGNED=$1
SIGNATURE=$2
ARCH=x86_64
ROOTDIR=dist
BUNDLE=${ROOTDIR}/unity-Qt.app
TEMPDIR=signed.temp
OUTDIR=signed-app
if [ -z "$UNSIGNED" ]; then
echo "usage: $0 <unsigned app> <signature>"
exit 1
fi
if [ -z "$SIGNATURE" ]; then
echo "usage: $0 <unsigned app> <signature>"
exit 1
fi
rm -rf ${TEMPDIR} && mkdir -p ${TEMPDIR}
tar -C ${TEMPDIR} -xf ${UNSIGNED}
tar -C ${TEMPDIR} -xf ${SIGNATURE}
if [ -z "${PAGESTUFF}" ]; then
PAGESTUFF=${TEMPDIR}/pagestuff
fi
if [ -z "${CODESIGN_ALLOCATE}" ]; then
CODESIGN_ALLOCATE=${TEMPDIR}/codesign_allocate
fi
for i in `find ${TEMPDIR} -name "*.sign"`; do
SIZE=`stat -c %s ${i}`
TARGET_FILE=`echo ${i} | sed 's/\.sign$//'`
echo "Allocating space for the signature of size ${SIZE} in ${TARGET_FILE}"
${CODESIGN_ALLOCATE} -i ${TARGET_FILE} -a ${ARCH} ${SIZE} -o ${i}.tmp
OFFSET=`${PAGESTUFF} ${i}.tmp -p | tail -2 | grep offset | sed 's/[^0-9]*//g'`
if [ -z ${QUIET} ]; then
echo "Attaching signature at offset ${OFFSET}"
fi
dd if=$i of=${i}.tmp bs=1 seek=${OFFSET} count=${SIZE} 2>/dev/null
mv ${i}.tmp ${TARGET_FILE}
rm ${i}
echo "Success."
done
mv ${TEMPDIR}/${ROOTDIR} ${OUTDIR}
rm -rf ${TEMPDIR}
echo "Signed: ${OUTDIR}"
|
/*
* Copyright [2020-2030] [https://www.stylefeng.cn]
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Guns采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
*
* 1.请不要删除和修改根目录下的LICENSE文件。
* 2.请不要删除和修改Guns源码头部的版权声明。
* 3.请保留源码和相关描述文件的项目出处，作者声明等。
* 4.分发源码时候，请注明软件出处 https://gitee.com/stylefeng/guns
* 5.在修改包名，模块名称，项目代码等时，请注明软件出处 https://gitee.com/stylefeng/guns
* 6.若您的项目无法满足以上几点，可申请商业授权
*/
package cn.stylefeng.roses.kernel.system.modular.user.controller;
import cn.stylefeng.roses.kernel.auth.api.context.LoginContext;
import cn.stylefeng.roses.kernel.auth.api.pojo.login.LoginUser;
import cn.stylefeng.roses.kernel.db.api.pojo.page.PageResult;
import cn.stylefeng.roses.kernel.rule.annotation.BusinessLog;
import cn.stylefeng.roses.kernel.rule.pojo.dict.SimpleDict;
import cn.stylefeng.roses.kernel.rule.pojo.request.BaseRequest;
import cn.stylefeng.roses.kernel.rule.pojo.response.ResponseData;
import cn.stylefeng.roses.kernel.rule.pojo.response.SuccessResponseData;
import cn.stylefeng.roses.kernel.scanner.api.annotation.ApiResource;
import cn.stylefeng.roses.kernel.scanner.api.annotation.GetResource;
import cn.stylefeng.roses.kernel.scanner.api.annotation.PostResource;
import cn.stylefeng.roses.kernel.system.api.pojo.user.SysUserDTO;
import cn.stylefeng.roses.kernel.system.api.pojo.user.UserSelectTreeNode;
import cn.stylefeng.roses.kernel.system.api.pojo.user.request.SysUserRequest;
import cn.stylefeng.roses.kernel.system.modular.user.entity.SysUserRole;
import cn.stylefeng.roses.kernel.system.modular.user.service.SysUserRoleService;
import cn.stylefeng.roses.kernel.system.modular.user.service.SysUserService;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 用户管理控制器
*
* @author luojie
* @date 2020/11/6 09:47
*/
@RestController
@ApiResource(name = "用户管理")
public class SysUserController {
@Resource
private SysUserService sysUserService;
@Resource
private SysUserRoleService sysUserRoleService;
/**
* 增加用户
*
* @author luojie
* @date 2020/11/6 13:50
*/
@PostResource(name = "系统用户_增加", path = "/sysUser/add")
@BusinessLog
public ResponseData<?> add(@RequestBody @Validated(BaseRequest.add.class) SysUserRequest sysUserRequest) {
sysUserService.add(sysUserRequest);
return new SuccessResponseData<>();
}
/**
* 删除系统用户
*
* @author luojie
* @date 2020/11/6 13:50
*/
@PostResource(name = "系统用户_删除", path = "/sysUser/delete")
@BusinessLog
public ResponseData<?> delete(@RequestBody @Validated(SysUserRequest.delete.class) SysUserRequest sysUserRequest) {
sysUserService.del(sysUserRequest);
return new SuccessResponseData<>();
}
/**
* 批量删除系统用户
*
* @author fengshuonan
* @date 2021/4/7 16:12
*/
@PostResource(name = "系统用户_批量删除系统用户", path = "/sysUser/batchDelete")
@BusinessLog
public ResponseData<?> batchDelete(@RequestBody @Validated(SysUserRequest.batchDelete.class) SysUserRequest sysUserRequest) {
sysUserService.batchDelete(sysUserRequest);
return new SuccessResponseData<>();
}
/**
* 编辑系统用户
*
* @author luojie
* @date 2020/11/6 13:50
*/
@PostResource(name = "系统用户_编辑", path = "/sysUser/edit")
@BusinessLog
public ResponseData<?> edit(@RequestBody @Validated(SysUserRequest.edit.class) SysUserRequest sysUserRequest) {
sysUserService.edit(sysUserRequest);
return new SuccessResponseData<>();
}
/**
* 修改状态
*
* @author luojie
* @date 2020/11/6 13:50
*/
@PostResource(name = "系统用户_修改状态", path = "/sysUser/changeStatus")
@BusinessLog
public ResponseData<?> changeStatus(@RequestBody @Validated(SysUserRequest.changeStatus.class) SysUserRequest sysUserRequest) {
sysUserService.editStatus(sysUserRequest);
return new SuccessResponseData<>();
}
/**
* 重置密码
*
* @author luojie
* @date 2020/11/6 13:48
*/
@PostResource(name = "系统用户_重置密码", path = "/sysUser/resetPwd")
@BusinessLog
public ResponseData<?> resetPwd(@RequestBody @Validated(SysUserRequest.resetPwd.class) SysUserRequest sysUserRequest) {
sysUserService.resetPassword(sysUserRequest);
return new SuccessResponseData<>();
}
/**
* 授权角色
*
* @author luojie
* @date 2020/11/6 13:50
*/
@PostResource(name = "系统用户_授权角色", path = "/sysUser/grantRole")
@BusinessLog
public ResponseData<?> grantRole(@RequestBody @Validated(SysUserRequest.grantRole.class) SysUserRequest sysUserRequest) {
sysUserService.grantRole(sysUserRequest);
return new SuccessResponseData<>();
}
/**
* 授权数据
*
* @author luojie
* @date 2020/11/6 13:50
*/
@PostResource(name = "系统用户_授权数据", path = "/sysUser/grantData")
@BusinessLog
public ResponseData<?> grantData(@RequestBody @Validated(SysUserRequest.grantData.class) SysUserRequest sysUserRequest) {
sysUserService.grantData(sysUserRequest);
return new SuccessResponseData<>();
}
/**
* 查看系统用户
*
* @author luojie
* @date 2020/11/6 13:50
*/
@GetResource(name = "系统用户_查看", path = "/sysUser/detail")
public ResponseData<SysUserDTO> detail(@Validated(SysUserRequest.detail.class) SysUserRequest sysUserRequest) {
return new SuccessResponseData<>(sysUserService.detail(sysUserRequest));
}
/**
* 获取当前登录用户的信息
*
* @author fengshuonan
* @date 2021/1/1 19:01
*/
@GetResource(name = "获取当前登录用户的信息", path = "/sysUser/currentUserInfo", requiredPermission = false)
public ResponseData<SysUserDTO> currentUserInfo() {
LoginUser loginUser = LoginContext.me().getLoginUser();
SysUserRequest sysUserRequest = new SysUserRequest();
sysUserRequest.setUserId(loginUser.getUserId());
return new SuccessResponseData<>(sysUserService.detail(sysUserRequest));
}
/**
* 查询系统用户
*
* @author luojie
* @date 2020/11/6 13:49
*/
@GetResource(name = "系统用户_查询", path = "/sysUser/page")
public ResponseData<PageResult<SysUserDTO>> page(SysUserRequest sysUserRequest) {
return new SuccessResponseData<>(sysUserService.findPage(sysUserRequest));
}
/**
* 导出用户
*
* @author luojie
* @date 2020/11/6 13:57
*/
@GetResource(name = "系统用户_导出", path = "/sysUser/export")
@BusinessLog
public void export(HttpServletResponse response) {
sysUserService.export(response);
}
/**
* 获取用户选择树数据（用在系统通知，选择发送人的时候）
*
* @author liuhanqing
* @date 2021/1/15 8:28
*/
@GetResource(name = "获取用户选择树数据（用在系统通知，选择发送人的时候）", path = "/sysUser/getUserSelectTree")
public ResponseData<List<UserSelectTreeNode>> getUserTree() {
return new SuccessResponseData<>(this.sysUserService.userSelectTree(new SysUserRequest()));
}
/**
* 获取用户数据范围列表
*
* @author luojie
* @date 2020/11/6 13:51
*/
@GetResource(name = "系统用户_获取用户数据范围列表", path = "/sysUser/getUserDataScope")
public ResponseData<List<Long>> ownData(@Validated(SysUserRequest.detail.class) SysUserRequest sysUserRequest) {
List<Long> userBindDataScope = sysUserService.getUserBindDataScope(sysUserRequest.getUserId());
return new SuccessResponseData<>(userBindDataScope);
}
/**
* 获取用户的角色列表
*
* @author luojie
* @date 2020/11/6 13:50
*/
@GetResource(name = "系统用户_获取用户的角色列表", path = "/sysUser/getUserRoles")
public ResponseData<List<SysUserRole>> ownRole(@Validated(SysUserRequest.detail.class) SysUserRequest sysUserRequest) {
Long userId = sysUserRequest.getUserId();
return new SuccessResponseData<>(sysUserRoleService.findListByUserId(userId));
}
/**
* 用户下拉列表，可以根据姓名搜索
*
* @param sysUserRequest 请求参数：name 姓名(可选)
* @return 返回除超级管理员外的用户列表
* @author luojie
* @date 2020/11/6 09:49
*/
@GetResource(name = "系统用户_选择器", path = "/sysUser/selector")
public ResponseData<List<SimpleDict>> selector(SysUserRequest sysUserRequest) {
return new SuccessResponseData<>(sysUserService.selector(sysUserRequest));
}
/**
* 获取所有用户ID和名称列表
*
* @author majianguo
* @date 2022/1/17 14:24
**/
@GetResource(name = "获取所有用户ID和名称列表", path = "/sysUser/getAllUserIdList")
public ResponseData<List<SysUserRequest>> getAllUserIdList() {
return new SuccessResponseData<>(sysUserService.getAllUserIdList());
}
/**
* 运维平台接口检测
*
* @author majianguo
* @date 2022/1/27 14:29
**/
@GetResource(name = "运维平台接口检测", path = "/sysUser/devopsApiCheck", requiredLogin = false, requiredPermission = false)
public ResponseData<Integer> devopsApiCheck(SysUserRequest sysUserRequest) {
return new SuccessResponseData<>(sysUserService.devopsApiCheck(sysUserRequest));
}
/**
* 根据用户主键获取用户对应的token
*
* @author majianguo
* @date 2022/1/17 14:24
**/
@GetResource(name = "根据用户主键获取用户对应的token", path = "/sysUser/getTokenByUserId")
public ResponseData<String> getTokenByUserId(Long userId) {
return new SuccessResponseData<>(sysUserService.getTokenByUserId(userId));
}
}
|
#!/usr/bin/env bash
set -x
pFlag=0
rFlag=0
nFlag=0
zFlag=0
CreateZipFile(){
rm -rf package
mkdir -p package
pip install -r requirements.txt --target package/
cd package
zip -r9 ../${ZIP_NAME}.zip .
cd ../
zip -g ${ZIP_NAME}.zip appflow_ga.py
}
UsageMessage(){
echo "usage : packager -p <aws profile> -r <aws_region> -n <name of the function> -z <zipname>"
}
while getopts "p:r:n:z:" option
do
case ${option} in
"p" ) AWS_PROFILE=${OPTARG}
pFlag=1
;;
"r" ) AWS_REGION=${OPTARG}
rFlag=1
;;
"n" ) FUNCTION_NAME=${OPTARG}
nFlag=1
;;
"z" ) ZIP_NAME=${OPTARG}
zFlag=1
;;
\? ) UsageMessage
exit 4
;;
esac
done
if [ ${pFlag} -eq 0 ] || [ ${rFlag} -eq 0 ] || [ ${nFlag} -eq 0 ] || [ ${zFlag} -eq 0 ]; then
UsageMessage
exit 4
fi
CreateZipFile
function_name_cli=`aws lambda get-function --function-name ${FUNCTION_NAME} --profile ${AWS_PROFILE} --region=${AWS_REGION} | jq -r '.Configuration | .FunctionName'`
if [ ${function_name_cli} == ${FUNCTION_NAME} ]; then
echo "Found the function. Ready to update."
aws lambda update-function-code --function-name ${FUNCTION_NAME} --zip-file fileb://${ZIP_NAME}.zip --profile ${AWS_PROFILE} --region=${AWS_REGION}
aws lambda update-function-configuration --function-name ${FUNCTION_NAME} --profile ${AWS_PROFILE} --region=${AWS_REGION}
else
echo "Unable to find the function. We will create the function for you."
ACCOUNTID=`aws sts get-caller-identity --region=${AWS_REGION} --profile=${AWS_PROFILE} | jq -r '.Account'`
ROLEARN=`aws iam get-role --role-name lambda-cli-role --region=${AWS_REGION} --profile=${AWS_PROFILE} | jq -r '.Role | .Arn'`
if [ -z ${ROLEARN} ]; then
echo "The lambda role does not exist. Please ask your admin to create the role with the AWSLambdaBasicExecutionRole policy."
else
aws lambda create-function --function-name ${FUNCTION_NAME} --zip-file fileb://${ZIP_NAME}.zip --handler appflow_ga.lambda_handler --runtime python3.7 --role arn:aws:iam::${ACCOUNTID}:role/lambda-cli-role --profile ${AWS_PROFILE} --region=${AWS_REGION}
aws lambda update-function-configuration --function-name ${FUNCTION_NAME} --profile ${AWS_PROFILE} --region=${AWS_REGION}
fi
fi
|
import React from "react"
import { FaFacebook, FaInstagram, FaEnvelope, FaWhatsapp } from "react-icons/fa"
export default [
{
icon: <FaFacebook />,
url: "https://www.facebook.com/contactodnlomas/",
title: "facebook",
},
{
icon: <FaInstagram />,
url: "https://www.instagram.com/dnlomasoficial/",
title: "instagram",
},
{ icon: <FaEnvelope />, url: "mailto:<EMAIL>", title: "mail" },
{ icon: <FaWhatsapp />, url: "tel:5591712105", title: "WhatsApp" },
]
|
<reponame>taekbari/WebDevCurriculum
class Desktop {
/* TODO: Desktop 클래스는 어떤 멤버함수와 멤버변수를 가져야 할까요? */
constructor( iconList, target ) {}
// 전달받은 아이콘 목록으로 객체 및 화면 구성.
makeIconList() {}
};
class Icon {
/* TODO: Icon 클래스는 어떤 멤버함수와 멤버변수를 가져야 할까요? */
constructor( templateTarget, name, imgInfo ) {}
set name( name ) {}
get name() {}
set imgInfo( imgInfo ) {}
get imgInfo() {}
initialize() {}
setIconMoveEvent() {}
};
class Folder {
/* TODO: Folder 클래스는 어떤 멤버함수와 멤버변수를 가져야 할까요? */
constructor( templateTarget, name, imgInfo, iconList ) {}
set name( name ) {}
get name() {}
set imgInfo( imgInfo ) {}
get imgInfo() {}
initialize() {}
setFolderMoveEvent() {}
setWindowOpenEvent() {}
};
class Window {
/* TODO: Window 클래스는 어떤 멤버함수와 멤버변수를 가져야 할까요? */
constructor( folderName, iconList ) {}
set width( width ) {}
get width() {}
set height( height ) {}
get height() {}
initialize() {}
setWindowMoveEvent() {}
setWindowCloseEvent() {}
};
|
<reponame>alphagov/locations-api<filename>spec/lib/os_places_api/client_spec.rb
require "spec_helper"
RSpec.describe OsPlacesApi::Client do
describe "#locations_for_postcode" do
let(:client) do
described_class.new(instance_double("AccessTokenManager", access_token: "some token"))
end
let(:postcode) { "E18QS" }
let(:api_endpoint) { "https://api.os.uk/search/places/v1/postcode?output_srs=WGS84&postcode=#{postcode}" }
let(:successful_response) do
{
"header": {
"uri": api_endpoint,
"query": "postcode=#{postcode}",
"offset": 0,
"totalresults": 1, # really 12, but we've omitted the other 11 in `results` above
"format": "JSON",
"dataset": "DPA",
"lr": "EN,CY",
"maxresults": 100,
"epoch": "87",
"output_srs": "WGS84",
},
"results": os_places_api_results,
}
end
let(:os_places_api_results) do
[
{
"DPA" => {
"UPRN" => "6714279",
"UDPRN" => "54673874",
"ADDRESS" => "1, WHITECHAPEL HIGH STREET, LONDON, E1 8QS",
"BUILDING_NUMBER" => "1",
"THOROUGHFARE_NAME" => "WHITECHAPEL HIGH STREET",
"POST_TOWN" => "LONDON",
"POSTCODE" => "E1 8QS",
"RPC" => "2",
"X_COORDINATE" => 533_813.0,
"Y_COORDINATE" => 181_262.0,
"LNG" => -0.0729933,
"LAT" => 51.5144547,
"STATUS" => "APPROVED",
"LOGICAL_STATUS_CODE" => "1",
"CLASSIFICATION_CODE" => "CO01",
"CLASSIFICATION_CODE_DESCRIPTION" => "Office / Work Studio",
"LOCAL_CUSTODIAN_CODE" => 5900,
"LOCAL_CUSTODIAN_CODE_DESCRIPTION" => "TOWER HAMLETS",
"POSTAL_ADDRESS_CODE" => "D",
"POSTAL_ADDRESS_CODE_DESCRIPTION" => "A record which is linked to PAF",
"BLPU_STATE_CODE" => "1",
"BLPU_STATE_CODE_DESCRIPTION" => "Under construction",
"TOPOGRAPHY_LAYER_TOID" => "osgb1000006035651",
"LAST_UPDATE_DATE" => "17/06/2017",
"ENTRY_DATE" => "17/02/2017",
"BLPU_STATE_DATE" => "17/02/2017",
"LANGUAGE" => "EN",
"MATCH" => 1.0,
"MATCH_DESCRIPTION" => "EXACT",
},
},
# subsequent results omitted for brevity
]
end
let(:location) do
Location.new(address: "1, WHITECHAPEL HIGH STREET, LONDON, E1 8QS",
latitude: 51.5144547,
local_custodian_code: 5900,
longitude: -0.0729933,
postcode: "E1 8QS")
end
context "the postcode doesn't exist in the database" do
before :each do
Postcode.where(postcode: postcode).map(&:destroy)
end
it "should query OS Places API and return results" do
stub_request(:get, api_endpoint)
.to_return(status: 200, body: successful_response.to_json)
expect(client.locations_for_postcode(postcode).as_json).to eq([location].as_json)
end
it "should cache the response from a successful request" do
stub_request(:get, api_endpoint)
.to_return(status: 200, body: successful_response.to_json)
expect(Postcode.where(postcode: postcode).count).to eq(0)
client.locations_for_postcode(postcode)
expect(Postcode.where(postcode: postcode).count).to eq(1)
end
it "raises an exception if the access token has expired" do
api_response = {
"fault": {
"faultstring": "Access Token expired",
"detail": {
"errorcode": "keymanagement.service.access_token_expired",
},
},
}
stub_request(:get, api_endpoint).to_return(status: 401, body: api_response.to_json)
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::ExpiredAccessToken)
end
it "raises an exception if the request is forbidden" do
stub_request(:get, api_endpoint).to_return(status: 403)
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::RequestForbidden)
end
it "raises an exception if the request cannot resolve" do
stub_request(:get, api_endpoint).to_return(status: 404)
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::RequestNotFound)
end
it "raises an exception if the request method is not allowed" do
stub_request(:get, api_endpoint).to_return(status: 405)
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::MethodNotAllowed)
end
it "raises an exception if rate limit exceeded" do
stub_request(:get, api_endpoint).to_return(status: 429)
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::RateLimitExceeded)
end
it "raises an exception if OS Places API has an internal server error" do
api_response = {
"error": {
"statuscode": 500,
"message": "The provided request resulted in an internal server error.",
},
}
stub_request(:get, api_endpoint).to_return(status: 500, body: api_response.to_json)
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::InternalServerError)
end
it "raises an exception if the OS Places API service is unavailable" do
stub_request(:get, api_endpoint).to_return(status: 503)
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::ServiceUnavailable)
end
it "raises an exception if the response isn't in the structure we expect" do
stub_request(:get, api_endpoint).to_return(status: 200, body: "foo")
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::UnexpectedResponse)
stub_request(:get, api_endpoint).to_return(status: 200, body: "{}")
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::UnexpectedResponse)
end
end
context "the postcode exists in the database" do
before do
Postcode.create(postcode: postcode, results: os_places_api_results)
end
it "should return the cached data" do
expect(a_request(:get, api_endpoint)).not_to have_been_made
expect(client.locations_for_postcode(postcode)).to eq([location])
end
end
context "there are two simultaneous requests for the same (new) postcode" do
it "should not attempt to create the postcode twice" do
existing_record = Postcode.create(postcode: postcode, results: os_places_api_results)
n = 0 # make the first call to `find_by` return `nil`; subsequent calls should work correctly
allow(Postcode).to receive(:find_by) { (n += 1) == 1 ? nil : existing_record }
stub_request(:get, api_endpoint)
.to_return(status: 200, body: successful_response.to_json)
expect(Postcode).not_to receive(:create!)
expect(client.locations_for_postcode(postcode)).to eq([location])
end
end
context "the postcode is invalid" do
let(:postcode) { "foo" }
it "raises an exception if an invalid postcode is supplied" do
api_response = {
"error": {
"statuscode": 400,
"message": "Requested postcode must contain a minimum of the sector plus 1 digit of the district e.g. SO1. Requested postcode was sausage",
},
}
stub_request(:get, api_endpoint).to_return(status: 400, body: api_response.to_json)
expect { client.locations_for_postcode(postcode) }.to raise_error(OsPlacesApi::InvalidPostcodeProvided)
end
end
end
end
|
import java.util.HashSet;
import java.util.Set;
/**
* Created on: Aug 31, 2020
* Questions: https://www.algoexpert.io/questions/Numbers%20In%20Pi
*/
public class NumbersInPi {
public static void main(String[] args) {
}
public static int numbersInPi(String pi, String[] numbers) {
int len = pi.length();
Set<String> set = new HashSet<>();
for (String num : numbers) {
set.add(num);
}
Integer[] dp = new Integer[len + 1];
int result = helper(pi, 0, set, dp);
return result == Integer.MAX_VALUE ? -1 : result - 1;
}
private static int helper(String pi, int idx, Set<String> set, Integer[] dp) {
if (idx == pi.length()) return 0;
if (dp[idx] != null) return dp[idx];
int curBreaks = Integer.MAX_VALUE;
String cur = "";
for (int i = idx; i < pi.length(); i++) {
cur += pi.charAt(i);
if (set.contains(cur)) {
int next = helper(pi, i + 1, set, dp);
if (next != Integer.MAX_VALUE) curBreaks = Math.min(curBreaks, next + 1);
}
}
return dp[idx] = curBreaks;
}
}
|
//
// ofxTMPSequence.h
//
// Created by ISHII 2bit on 2016/04/28.
//
//
#pragma once
namespace ofx {
namespace TMP {
namespace sequences {
template <typename type, type ... ns>
struct integer_sequence {
using value_type = type;
static constexpr std::size_t size = sizeof...(ns);
};
namespace detail {
template <typename integer_type, integer_type n, integer_type ... ns>
struct make_integer_sequence {
struct sequence_wrapper { using type = integer_sequence<integer_type, ns ...>; };
using type = get_type<conditional<
n == 0,
sequence_wrapper,
detail::make_integer_sequence<integer_type, n - 1, n - 1, ns ...>
>>;
};
};
template <typename type, type n>
using make_integer_sequence = detail::make_integer_sequence<type, n>;
template <std::size_t ... ns>
using index_sequence = integer_sequence<std::size_t, ns ...>;
template <std::size_t n>
using make_index_sequence = make_integer_sequence<std::size_t, n>;
template <typename... types>
using index_sequence_for = make_index_sequence<sizeof...(types)>;
};
using namespace sequences;
};
};
|
<filename>src/instructions/conversions/f2x.go
package conversions
import (
"instructions/base"
"rtda"
)
type F2D struct{ base.NoOperandsInstruction }
type F2I struct{ base.NoOperandsInstruction }
type F2L struct{ base.NoOperandsInstruction }
// Convert float to double
func (self *F2D) Execute(frame *rtda.Frame) {
stack := frame.OperandStack()
x := stack.PopFloat()
y := float64(x)
stack.PushDouble(y)
}
// Convert float to int
func (self *F2I) Execute(frame *rtda.Frame) {
stack := frame.OperandStack()
x := stack.PopFloat()
y := int32(x)
stack.PushInt(y)
}
// Convert float to long
func (self *F2L) Execute(frame *rtda.Frame) {
stack := frame.OperandStack()
x := stack.PopFloat()
y := int64(x)
stack.PushLong(y)
}
|
<filename>2015/day_05_part1.py<gh_stars>0
#!/usr/bin/env python3
import re
def is_nice_string(s):
# contains at three vowels
vowel_count = 0
for vowel in 'aeiou':
vowel_count += s.count(vowel)
if vowel_count < 3: return False
m = re.search(r"([a-zA-Z])\1", s)
if not m:
return False
bad_strings = ['ab', 'cd', 'pq', 'xy']
for bs in bad_strings:
if bs in s:
return False
return True
#############################################################
nice_count = 0
for line in open('day_05.data'):
if is_nice_string(line):
nice_count += 1
print("INFO: {0} of the strings are nice".format(nice_count))
|
#include "util.h"
#include <sys/time.h>
static struct timeval tic_timestart;
void tic(void) {
gettimeofday(&tic_timestart, NULL);
}
double tocq(void) {
struct timeval tic_timestop;
gettimeofday(&tic_timestop, NULL);
//coneOS_printf("time: %8.4f seconds.\n", (float)(tic_timestop - tic_timestart));
double time = tic_timestop.tv_sec*1e3 + tic_timestop.tv_usec/1e3 - tic_timestart.tv_sec*1e3 - tic_timestart.tv_usec/1e3;
return time;
}
double toc(void) {
double time = tocq();
coneOS_printf("time: %8.4f milli-seconds.\n", time);
return time;
}
void printConeData(Cone * k){
int i;
coneOS_printf("num zeros = %i\n",k->f);
coneOS_printf("num LP = %i\n",k->l);
coneOS_printf("num SOCs = %i\n",k->qsize);
coneOS_printf("soc array:\n");
for ( i=0;i<k->qsize;i++){
coneOS_printf("%i\n",k->q[i]);
}
coneOS_printf("num SDCs = %i\n",k->ssize);
coneOS_printf("sdc array:\n");
for ( i=0;i<k->ssize;i++){
coneOS_printf("%i\n",k->s[i]);
}
}
void printData(Data * d){
coneOS_printf("d->n is %i\n",d->n);
coneOS_printf("d->m is %i\n",d->m);
coneOS_printf("d->b[0] is %4f\n",d->b[0]);
coneOS_printf("d->c[0] is %4f\n",d->c[0]);
coneOS_printf("d->Ax[0] is %4f\n",d->Ax[0]);
coneOS_printf("d->MAX_ITERS is %i\n",d->MAX_ITERS);
coneOS_printf("d->VERBOSE is %i\n",d->VERBOSE);
coneOS_printf("d->NORMALIZE is %i\n",d->VERBOSE);
coneOS_printf("d->ALPH is %6f\n",d->ALPH);
coneOS_printf("d->EPS_ABS is %6f\n",d->EPS_ABS);
coneOS_printf("d->EPS_ABS is %6f\n",d->EPS_ABS);
coneOS_printf("d->UNDET_TOL is %6f\n",d->UNDET_TOL);
}
void printAll(Data * d, Work * w){
int i;
coneOS_printf("\n u_t is \n");
for( i=0;i<w->l;i++){
coneOS_printf("%f\n",w->u_t[i]);
}
coneOS_printf("\n u is \n");
for( i=0;i<w->l;i++){
coneOS_printf("%f\n",w->u[i]);
}
coneOS_printf("\n v is \n");
for( i=0;i<w->l;i++){
coneOS_printf("%f\n",w->v[i]);
}
}
|
#/bin/bash
clear
echo " Change the directory"
cd /home
echo " You are in `pwd`"
echo
set -r
echo " ====>GOD MODE ENABLED<===="
echo
read -p " What do you want to find? " w
echo
read -p " Where? " f
echo
read -p " How many strings? " n
echo
# main
function func {
grep "$w" "$f" | head -n "$n" | sort | cat -n
}
# check $w
if [[ -z "$w" ]]
then echo "error: You didn't write what do you want to find!"
else echo
fi
# check $f
if [[ -z "$f" ]]
then echo "error: You didn't write the path of the file!"
else echo
fi
# check $n and run main
if ( echo "$n" | grep -E -q "^?[0-9]+$" )
then func
else echo "error: Not a number in How many strings do you want to see?!"
fi
|
package rbd
import (
"encoding/json"
"errors"
"os/exec"
"strings"
"time"
)
// Dev is an rbd device, a snapshot or an image
type Dev interface {
FullName() string
ImageName() string
Name() string
Pool() *Pool
Info() (*DevInfo, error)
IsMountedAt(string) (bool, error)
Map(...string) (string, error)
Mount(string, string, uintptr, string) error
Unmount(string) error
Unmap() error
MapAndMount(string, string, uintptr, string, ...string) error
UnmountAndUnmap(string) error
Device() (string, error)
Remove() error
FileSystem() (string, error)
cmdArgs(...string) []string
}
func devFullName(d Dev) string {
return d.Pool().Name() + "/" + d.ImageName()
}
func device(d Dev) (string, error) {
mapped, err := mappedNBDs()
if err != nil {
return "", err
}
for _, m := range mapped {
switch v := d.(type) {
case *Image:
if m.Snapshot == "-" && m.Name == v.Name() && m.Pool == v.Pool().Name() {
return m.Device, nil
}
case *Snapshot:
if m.Snapshot == v.Name() && m.Name == v.Image().Name() && m.Pool == v.Pool().Name() {
return m.Device, nil
}
}
}
return "", nil
}
// ErrNotMapped is returned if a rbd is not mapped
var ErrNotMapped = errors.New("not mapped")
func mustDevice(d Dev) (string, error) {
blk, err := device(d)
if err == nil && blk == "" {
err = ErrNotMapped
}
return blk, err
}
func devFileSystem(d Dev) (string, error) {
blk, err := mustDevice(d)
if err != nil {
return blk, err
}
return getFs(blk)
}
func devIsMountedAt(d Dev, mountPoint string) (bool, error) {
blk, err := device(d)
if err != nil || blk == "" {
return false, err
}
return isMountedAt(blk, mountPoint)
}
// ErrExclusiveLockNotEnabled is returned when an rbd volume does not have exclusive-locks feature enabled
var ErrExclusiveLockNotEnabled = errors.New("exclusive-lock not enabled")
// ErrExclusiveLockTaken is returned when this client cannot get an exclusive-lock
var ErrExclusiveLockTaken = errors.New("exclusive-lock is held by another client")
func devMapErrors(err *exec.ExitError) error {
if err.ExitCode() == 22 {
stdErr := string(err.Stderr)
if strings.Contains(stdErr, "failed to request exclusive lock: (30) Read-only file system") {
return ErrExclusiveLockTaken
}
if strings.Contains(stdErr, "exclusive-lock feature is not enabled") {
return ErrExclusiveLockNotEnabled
}
}
return err
}
func devMap(d Dev, args ...string) (string, error) {
nbd, err := device(d)
if err != nil || nbd != "" {
return nbd, err
}
args = append([]string{"nbd", "map"}, args...)
args = d.cmdArgs(args...)
return cmdOut(devMapErrors, args...)
}
func devMapAndMount(d Dev, mountPoint, fs string, flags uintptr, data string, mapF func() (string, error)) error {
err := d.Mount(mountPoint, fs, flags, data)
if errors.Is(err, ErrNotMapped) {
blk, err := mapF()
if err != nil {
return wrapErr(err, "error calling map function on %v", d.FullName())
}
return wrapErr(mount(blk, mountPoint, fs, flags, data), "error mounting %v to %v after mapping to %v", d.FullName(), mountPoint, blk)
}
return wrapErr(err, "error mounting %v to %v", d.FullName(), mountPoint)
}
func devMount(d Dev, mountPoint, fs string, flags uintptr, data string) error {
blk, err := mustDevice(d)
if err != nil {
return err
}
return mount(blk, mountPoint, fs, flags, data)
}
func devUnmount(d Dev, mountPoint string) error {
blk, err := device(d)
if err != nil || blk == "" {
return err
}
return unmount(blk, mountPoint)
}
// devUnmountAndUnmap safely unmounts and unmaps checking for would-be orphan mounts first
func devUnmountAndUnmap(d Dev, mountPoint string) error {
blk, err := device(d)
if err != nil || blk == "" {
return err
}
if err = isMountedElsewhere(blk, mountPoint); err != nil {
return err
}
if err = unmount(blk, mountPoint); err != nil {
return err
}
return unmap(blk)
}
// ErrDeviceBusy is returned if the device is busy
var ErrDeviceBusy = errors.New("device busy")
var unmapErrors = exitCodeToErrMap(map[int]error{
16: ErrDeviceBusy,
})
func unmap(blk string) error {
return cmdRun(unmapErrors, "nbd", "unmap", blk)
}
func devUnmap(d Dev) error {
blk, err := device(d)
if err != nil || blk == "" {
return err
}
return unmap(blk)
}
// DevInfo contains information about the image or snapshot
type DevInfo struct {
Name string `json:"name"`
Size int64 `json:"size"`
Objects int `json:"objects"`
Order int `json:"order"`
ObjectSize int `json:"object_size"`
BlockNamePrefix string `json:"block_name_prefix"`
Format int `json:"format"`
Features []string `json:"features"`
Flags []interface{} `json:"flags"`
CreateTimestamp CreateTimestamp `json:"create_timestamp"`
Protected bool `json:"protected,string"`
}
// CreateTimestamp is the creation timestamp for an image or snapshot
type CreateTimestamp time.Time
// UnmarshalJSON unmarshals CreateTimestamp
func (j *CreateTimestamp) UnmarshalJSON(b []byte) error {
s := strings.Trim(string(b), "\"")
t, err := time.ParseInLocation(time.ANSIC, s, time.Local)
if err != nil {
return err
}
*j = CreateTimestamp(t)
return nil
}
// MarshalJSON marshals CreateTimestamp
func (j CreateTimestamp) MarshalJSON() ([]byte, error) {
return json.Marshal(time.Time(j).Format(time.ANSIC))
}
func devInfo(d Dev) (*DevInfo, error) {
i := &DevInfo{}
return i, cmdJSON(i, imageErrs, d.cmdArgs("info")...)
}
|
set -xe
LATTELIB="lattelib.c"
TEST_TEMPLATE="${TMPDIR}latteXXX"
TEST_DIR=`mktemp -d "$TEST_TEMPLATE"`
input_file="$1"
BASENAME=`basename "$input_file" .lat`
LLFILE="$TEST_DIR/${BASENAME}.ll"
CLANG_OUT="$TEST_DIR/${BASENAME}.out"
LLVM_ANS="$TEST_DIR/${BASENAME}.llans"
CORRECT_ANS="examples/my_good/${BASENAME}.output"
stack exec compile "$input_file" > $LLFILE
clang -Wall -Werror "$LLFILE" "$LATTELIB" -o "$CLANG_OUT"
$CLANG_OUT
# rm -rf "$TEST_DIR"
|
/** OpenSensorHub feature results classes. */
package io.opensphere.osh.results.features;
|
<gh_stars>0
/*
* Copyright (C) 2018-2019 <NAME> (www.helger.com)
* philip[at]helger[dot]com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.helger.aufnahme.simple;
import com.helger.xml.microdom.IMicroElement;
import com.helger.xml.microdom.MicroElement;
import com.helger.xml.microdom.convert.IMicroTypeConverter;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
/**
* <p>Default MicroTypeConverter implementation of {@link com.helger.aufnahme.simple.IBiotopbaumDecompositionDegree}</p>
* <p>This class was initially automatically created</p>
*
*
* @author JDMCodeGenerator
*/
public class BiotopbaumDecompositionDegreeMicroTypeConverter
implements IMicroTypeConverter<BiotopbaumDecompositionDegree>
{
private static final String ATTR_TYPE = "type";
private static final String ATTR_ENABLED = "enabled";
private static final String ATTR_LENGTH = "length";
private static final String ATTR_BHD = "bhd";
@Nonnull
public IMicroElement convertToMicroElement(@Nonnull final BiotopbaumDecompositionDegree aValue, @Nullable final String sNamespaceURI, @Nonnull final String sTagName) {
final IMicroElement aElement = new MicroElement(sNamespaceURI, sTagName);
aElement.setAttribute(ATTR_TYPE, aValue.getType().getID());
aElement.setAttribute(ATTR_ENABLED, aValue.isEnabled());
aElement.setAttribute(ATTR_LENGTH, aValue.getLength());
aElement.setAttribute(ATTR_BHD, aValue.getBHD());
return aElement;
}
@Nonnull
public BiotopbaumDecompositionDegree convertToNative(@Nonnull final IMicroElement aElement) {
final EDecompositionDegreeClass eType = EDecompositionDegreeClass.getFromIDOrNull(aElement.getAttributeValue(ATTR_TYPE));
final boolean bEnabled = aElement.getAttributeValueAsBool(ATTR_ENABLED, false);
final int nLength = aElement.getAttributeValueAsInt(ATTR_LENGTH, -1);
final int nBHD = aElement.getAttributeValueAsInt(ATTR_BHD, -1);
return new BiotopbaumDecompositionDegree(eType, bEnabled, nLength, nBHD);
}
}
|
def bubble_sort(nums):
'''Takes in a list of numbers and sorts them in ascending order using bubble sort'''
# Iterate through all numbers
for i in range(len(nums)):
# Last i elements are already in place
for j in range(0, len(nums)-i-1):
# Swap numbers if the element is greater than the next element
if nums[j] > nums[j+1] :
nums[j], nums[j+1] = nums[j+1], nums[j]
return nums
|
#! /bin/sh
# /etc/init.d/InSightsXLDeployAgent
### BEGIN INIT INFO
# Provides: Runs a Python script on startup
# Required-Start: BootPython start
# Required-Stop: BootPython stop
# Default-Start: 2 3 4 5
# Default-stop: 0 1 6
# Short-Description: Simple script to run python program at boot
# Description: Runs a python program at boot
### END INIT INFO
#export INSIGHTS_AGENT_HOME=/home/ec2-user/insightsagents
source /etc/profile
case "$1" in
start)
if [[ $(ps aux | grep '[d]eployment.xldeploy.XLDeployAgent' | awk '{print $2}') ]]; then
echo "InSightsXLDeployAgent already running"
else
echo "Starting InSightsXLDeployAgent"
cd $INSIGHTS_AGENT_HOME/PlatformAgents/xldeploy
python -c "from com.cognizant.devops.platformagents.agents.deployment.xldeploy.XLDeployAgent import XLDeployAgent; XLDeployAgent()" &
fi
if [[ $(ps aux | grep '[d]eployment.xldeploy.XLDeployAgent' | awk '{print $2}') ]]; then
echo "InSightsXLDeployAgent Started Sucessfully"
else
echo "InSightsXLDeployAgent Failed to Start"
fi
;;
stop)
echo "Stopping InSightsXLDeployAgent"
if [[ $(ps aux | grep '[d]eployment.xldeploy.XLDeployAgent' | awk '{print $2}') ]]; then
sudo kill -9 $(ps aux | grep '[d]eployment.xldeploy.XLDeployAgent' | awk '{print $2}')
else
echo "InSIghtsXLDeployAgent already in stopped state"
fi
if [[ $(ps aux | grep '[d]eployment.xldeploy.XLDeployAgent' | awk '{print $2}') ]]; then
echo "InSightsXLDeployAgent Failed to Stop"
else
echo "InSightsXLDeployAgent Stopped"
fi
;;
restart)
echo "Restarting InSightsXLDeployAgent"
if [[ $(ps aux | grep '[d]eployment.xldeploy.XLDeployAgent' | awk '{print $2}') ]]; then
echo "InSightsXLDeployAgent stopping"
sudo kill -9 $(ps aux | grep '[d]eployment.xldeploy.XLDeployAgent' | awk '{print $2}')
echo "InSightsXLDeployAgent stopped"
echo "InSightsXLDeployAgent starting"
cd $INSIGHTS_AGENT_HOME/PlatformAgents/xldeploy
python -c "from com.cognizant.devops.platformagents.agents.deployment.xldeploy.XLDeployAgent import XLDeployAgent; XLDeployAgent()" &
echo "InSightsXLDeployAgent started"
else
echo "InSightsXLDeployAgent already in stopped state"
echo "InSightsXLDeployAgent starting"
cd $INSIGHTS_AGENT_HOME/PlatformAgents/xldeploy
python -c "from com.cognizant.devops.platformagents.agents.deployment.xldeploy.XLDeployAgent import XLDeployAgent; XLDeployAgent()" &
echo "InSightsXLDeployAgent started"
fi
;;
status)
echo "Checking the Status of InSightsXLDeployAgent"
if [[ $(ps aux | grep '[d]eployment.xldeploy.XLDeployAgent' | awk '{print $2}') ]]; then
echo "InSightsXLDeployAgent is running"
else
echo "InSightsXLDeployAgent is stopped"
fi
;;
*)
echo "Usage: /etc/init.d/InSightsXLDeployAgent {start|stop|restart|status}"
exit 1
;;
esac
exit 0
|
#!/bin/bash
set -eux
aws s3 sync --exclude '*/dataset/*' --exclude '*/cache/*' --exclude 'iteration_*.pth' --exclude '*_optim.pth' "${S3_MODEL_DIR}" ./model
genienlp kfserver --path ./model $@
|
<reponame>rubenqba/gearman-java<gh_stars>0
package net.johnewart.gearman.server.web;
import net.johnewart.gearman.server.storage.JobManager;
import net.johnewart.gearman.server.util.JobQueueMonitor;
public class SystemStatusView extends StatusView {
public SystemStatusView(JobQueueMonitor jobQueueMonitor, JobManager jobManager)
{
super(jobQueueMonitor, jobManager);
}
}
|
#!/usr/bin/env bash
java -cp target/translator-0.1.0-standalone.jar translator.main $@
|
import _ from 'lodash';
import React, { Component, PropTypes } from 'react';
import { connect } from 'react-redux';
import CreateHelper from '~/components/CreateHelper';
import { showModal, hideModal } from '~/actions/modal';
import { Button } from 'linode-components/buttons';
import { setError } from '~/actions/errors';
import { tokens } from '~/api';
import PersonalAccessToken from '../components/PersonalAccessToken';
import CreatePersonalAccessToken from '../components/CreatePersonalAccessToken';
export class PersonalAccessTokensPage extends Component {
static async preload({ dispatch }) {
try {
await dispatch(tokens.all());
} catch (response) {
if (!response.json) {
// eslint-disable-next-line no-console
return console.error(response);
}
dispatch(setError(response));
}
}
renderCreatePersonalAccessToken = () => {
const { dispatch } = this.props;
dispatch(showModal('Create a Personal Access Token', (
<CreatePersonalAccessToken
dispatch={dispatch}
close={() => dispatch(hideModal())}
/>
)));
}
renderGroup = (group, i, groups) => {
const { dispatch } = this.props;
const _renderGroup = group.map(client =>
<div className="col-lg-6" key={client.id}>
<PersonalAccessToken
type="token"
label={client.label}
id={client.id}
scopes={client.scopes}
expires={client.expiry}
secret={client.token}
dispatch={dispatch}
/>
</div>
);
if (i === groups.length - 1) {
return <div className="row">{_renderGroup}</div>;
}
return <section className="row">{_renderGroup}</section>;
}
render() {
const clients = Object.values(this.props.tokens.tokens).filter(
token => token.type === 'personal_access_token');
return (
<div>
<header className="NavigationHeader clearfix">
<Button onClick={this.renderCreatePersonalAccessToken} className="float-sm-right">
Create a Personal Access Token
</Button>
</header>
{clients.length ? _.chunk(clients, 2).map(this.renderGroup) : (
<CreateHelper
label="tokens"
onClick={this.renderCreatePersonalAccessToken}
linkText="Create a Personal Access Token"
/>
)}
</div>
);
}
}
PersonalAccessTokensPage.propTypes = {
dispatch: PropTypes.func.isRequired,
tokens: PropTypes.object.isRequired,
};
function select(state) {
return {
tokens: state.api.tokens,
};
}
export default connect(select)(PersonalAccessTokensPage);
|
"""This is an example module to test reconstructable pipeline loading."""
from .bar import bar_pipeline # pylint: disable=import-error
|
#!/bin/sh
set -e
set -u
set -o pipefail
if [ -z ${FRAMEWORKS_FOLDER_PATH+x} ]; then
# If FRAMEWORKS_FOLDER_PATH is not set, then there's nowhere for us to copy
# frameworks to, so exit 0 (signalling the script phase was successful).
exit 0
fi
echo "mkdir -p ${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
mkdir -p "${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
COCOAPODS_PARALLEL_CODE_SIGN="${COCOAPODS_PARALLEL_CODE_SIGN:-false}"
SWIFT_STDLIB_PATH="${DT_TOOLCHAIN_DIR}/usr/lib/swift/${PLATFORM_NAME}"
# Used as a return value for each invocation of `strip_invalid_archs` function.
STRIP_BINARY_RETVAL=0
# This protects against multiple targets copying the same framework dependency at the same time. The solution
# was originally proposed here: https://lists.samba.org/archive/rsync/2008-February/020158.html
RSYNC_PROTECT_TMP_FILES=(--filter "P .*.??????")
# Copies and strips a vendored framework
install_framework()
{
if [ -r "${BUILT_PRODUCTS_DIR}/$1" ]; then
local source="${BUILT_PRODUCTS_DIR}/$1"
elif [ -r "${BUILT_PRODUCTS_DIR}/$(basename "$1")" ]; then
local source="${BUILT_PRODUCTS_DIR}/$(basename "$1")"
elif [ -r "$1" ]; then
local source="$1"
fi
local destination="${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
if [ -L "${source}" ]; then
echo "Symlinked..."
source="$(readlink "${source}")"
fi
# Use filter instead of exclude so missing patterns don't throw errors.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${source}\" \"${destination}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${destination}"
local basename
basename="$(basename -s .framework "$1")"
binary="${destination}/${basename}.framework/${basename}"
if ! [ -r "$binary" ]; then
binary="${destination}/${basename}"
fi
# Strip invalid architectures so "fat" simulator / device frameworks work on device
if [[ "$(file "$binary")" == *"dynamically linked shared library"* ]]; then
strip_invalid_archs "$binary"
fi
# Resign the code if required by the build settings to avoid unstable apps
code_sign_if_enabled "${destination}/$(basename "$1")"
# Embed linked Swift runtime libraries. No longer necessary as of Xcode 7.
if [ "${XCODE_VERSION_MAJOR}" -lt 7 ]; then
local swift_runtime_libs
swift_runtime_libs=$(xcrun otool -LX "$binary" | grep --color=never @rpath/libswift | sed -E s/@rpath\\/\(.+dylib\).*/\\1/g | uniq -u && exit ${PIPESTATUS[0]})
for lib in $swift_runtime_libs; do
echo "rsync -auv \"${SWIFT_STDLIB_PATH}/${lib}\" \"${destination}\""
rsync -auv "${SWIFT_STDLIB_PATH}/${lib}" "${destination}"
code_sign_if_enabled "${destination}/${lib}"
done
fi
}
# Copies and strips a vendored dSYM
install_dsym() {
local source="$1"
if [ -r "$source" ]; then
# Copy the dSYM into a the targets temp dir.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${source}\" \"${DERIVED_FILES_DIR}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${DERIVED_FILES_DIR}"
local basename
basename="$(basename -s .framework.dSYM "$source")"
binary="${DERIVED_FILES_DIR}/${basename}.framework.dSYM/Contents/Resources/DWARF/${basename}"
# Strip invalid architectures so "fat" simulator / device frameworks work on device
if [[ "$(file "$binary")" == *"Mach-O dSYM companion"* ]]; then
strip_invalid_archs "$binary"
fi
if [[ $STRIP_BINARY_RETVAL == 1 ]]; then
# Move the stripped file into its final destination.
echo "rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${DERIVED_FILES_DIR}/${basename}.framework.dSYM\" \"${DWARF_DSYM_FOLDER_PATH}\""
rsync --delete -av "${RSYNC_PROTECT_TMP_FILES[@]}" --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${DERIVED_FILES_DIR}/${basename}.framework.dSYM" "${DWARF_DSYM_FOLDER_PATH}"
else
# The dSYM was not stripped at all, in this case touch a fake folder so the input/output paths from Xcode do not reexecute this script because the file is missing.
touch "${DWARF_DSYM_FOLDER_PATH}/${basename}.framework.dSYM"
fi
fi
}
# Signs a framework with the provided identity
code_sign_if_enabled() {
if [ -n "${EXPANDED_CODE_SIGN_IDENTITY}" -a "${CODE_SIGNING_REQUIRED:-}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
# Use the current code_sign_identitiy
echo "Code Signing $1 with Identity ${EXPANDED_CODE_SIGN_IDENTITY_NAME}"
local code_sign_cmd="/usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS:-} --preserve-metadata=identifier,entitlements '$1'"
if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
code_sign_cmd="$code_sign_cmd &"
fi
echo "$code_sign_cmd"
eval "$code_sign_cmd"
fi
}
# Strip invalid architectures
strip_invalid_archs() {
binary="$1"
# Get architectures for current target binary
binary_archs="$(lipo -info "$binary" | rev | cut -d ':' -f1 | awk '{$1=$1;print}' | rev)"
# Intersect them with the architectures we are building for
intersected_archs="$(echo ${ARCHS[@]} ${binary_archs[@]} | tr ' ' '\n' | sort | uniq -d)"
# If there are no archs supported by this binary then warn the user
if [[ -z "$intersected_archs" ]]; then
echo "warning: [CP] Vendored binary '$binary' contains architectures ($binary_archs) none of which match the current build architectures ($ARCHS)."
STRIP_BINARY_RETVAL=0
return
fi
stripped=""
for arch in $binary_archs; do
if ! [[ "${ARCHS}" == *"$arch"* ]]; then
# Strip non-valid architectures in-place
lipo -remove "$arch" -output "$binary" "$binary" || exit 1
stripped="$stripped $arch"
fi
done
if [[ "$stripped" ]]; then
echo "Stripped $binary of architectures:$stripped"
fi
STRIP_BINARY_RETVAL=1
}
if [[ "$CONFIGURATION" == "Debug" ]]; then
install_framework "${BUILT_PRODUCTS_DIR}/Alamofire/Alamofire.framework"
install_framework "${BUILT_PRODUCTS_DIR}/AutoInsetter/AutoInsetter.framework"
install_framework "${BUILT_PRODUCTS_DIR}/Pageboy/Pageboy.framework"
install_framework "${BUILT_PRODUCTS_DIR}/Tabman/Tabman.framework"
install_framework "${BUILT_PRODUCTS_DIR}/Toast-Swift/Toast_Swift.framework"
fi
if [[ "$CONFIGURATION" == "Release" ]]; then
install_framework "${BUILT_PRODUCTS_DIR}/Alamofire/Alamofire.framework"
install_framework "${BUILT_PRODUCTS_DIR}/AutoInsetter/AutoInsetter.framework"
install_framework "${BUILT_PRODUCTS_DIR}/Pageboy/Pageboy.framework"
install_framework "${BUILT_PRODUCTS_DIR}/Tabman/Tabman.framework"
install_framework "${BUILT_PRODUCTS_DIR}/Toast-Swift/Toast_Swift.framework"
fi
if [ "${COCOAPODS_PARALLEL_CODE_SIGN}" == "true" ]; then
wait
fi
|
#!/bin/sh
set -e
mkdir -p build
mkdir -p images
NAME=amd64.ubuntu.focal
# create
echo "[$NAME] Creating ..."
mkdir images/$NAME
debootstrap focal images/$NAME http://archive.ubuntu.com/ubuntu/
# test
echo "[$NAME] Testing ..."
[ "$(chroot images/$NAME uname)" = "Linux" ] || echo "🔴 Something went wrong in $NAME!"
# package
echo "[$NAME] Packaging ..."
cd images/$NAME
tar cf ../../build/$NAME.tar .
cd ../..
xz -v -T0 -9 build/$NAME.tar
mv build/$NAME.tar.xz build/$NAME.txz
|
#include <stdio.h>
#include <iostream>
#include <omp.h>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/ml/ml.hpp>
#include <opencv2/photo/photo.hpp>
#include <cmath>
#include <random>
using namespace cv;
using namespace cv::ml;
using namespace std;
#define BUFFER_SIZE 1000
#define USE_SAMPLING 1
class ShadowRemover {
public:
// Constructors and destructor
ShadowRemover(char* in);
~ShadowRemover();
// Primary function of the ShadowRemover class. Start here
void RemoveShadow(char* out);
// Returns the block centered around (x,y).
bool GetBlock(int x, int y, Mat& block, Mat& dsImage);
// Performs the local clustering using GMM at the block and saves the result in clusterMu
void ClusterBlock(Mat& block, Mat& clusterMu, int* randInd);
// Identifies the local cluster belonging to the background and saves it in the shadow map
// Currently uses max cluster mean.
void CalculatePaperStatistics(int x, int y, Mat& clusterMu);
// Finds the block that best represents the background region. Used for constructing the
// shadow map (gain map)
void FindReferenceIndex(int& refInd, Mat& dsImage, Vec3f& ref);
// Upsample shadow map by stride
void UpsampleShadowMap();
// Divide each local region by the reference
void NormalizeShadowMap(int refIndex, Vec3f& ref);
// Apply per pixel gain to do the actual shadow removal
void ApplyShadowMap();
// Save the output and the shadow map
void SaveResults(char* out);
// Converts x and y index to access downsampled images (xhat = x and
// yhat = y when stride is 1)
void ConvertIndex(int x, int y, int& xHat, int& yHat);
// Wrappers for opencv utilities to read, write, and display images
int ReadImage(Mat& img, char* filename);
void DisplayImage(Mat img);
void WriteImage(Mat img, char* filename, bool isNormalized = false);
void SaveTiming(float val, char* out);
// Getters
Mat* GetImage();
Mat* GetShadowMap();
int GetWidth();
int GetHeight();
int GetChannels();
int GetStride();
int GetBlockSize();
int GetNumOfClusters();
int GetNumOfClustersRef();
int GetMaxIters();
float GetEps();
// Setters
void SetImage(Mat* image);
void SetShadowMap(Mat* shadowMap);
void SetWidth(int w);
void SetHeight(int h);
void SetChannels(int c);
void SetStride(int s);
void SetBlockSize(int b);
void SetNumOfClusters(int c);
void SetNumOfClustersRef(int c);
void SetMaxIters(int iters);
void SetEps(float eps);
private:
// Input image, shadow map (gain map), and mask of image regions
Mat* image;
Mat* shadowMap;
// Full width, height, and number of channels
int width;
int height;
int channels;
// Number of pixels to skip when performing local analysis
int stride;
// Size of overlapping blocks in local analysis
int blockSize;
// Number of clusters used for local analysis (i.e., 2)
int numOfClusters;
// Number of clusters used for global analysis (i.e., 3)
int numOfClustersRef;
// Maximum number of iterations and epsilon threshold used as stopping condition for GMM clustering
int maxIters;
float emEps;
// Amount of downsampling to be used on the original image (for speedup)
float dsFactor;
// Number of local and global samples in the block and image, respectively (Default is 150 and 1000)
int numOfLocalSamples;
int numOfGlobalSamples;
};
|
#include <iostream>
using namespace std;
void changeSomething(double &value) {
value = 123.4;
}
int main() {
int value1 = 8;
int &value2 = value1;
value2 = 10;
cout << "Value1: " << value1 << endl;
cout << "Value2: " << value2 << endl;
double value = 4.321;
changeSomething(value);
cout << value << endl;
return 0;
}
|
<reponame>AnantLabs/google-enterprise-connector-ldap
// Copyright 2010 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.enterprise.connector.ldap;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Maps;
import com.google.enterprise.connector.ldap.LdapConstants.AuthType;
import com.google.enterprise.connector.ldap.LdapConstants.ConfigName;
import com.google.enterprise.connector.ldap.LdapConstants.ErrorMessages;
import com.google.enterprise.connector.ldap.LdapConstants.LdapConnectionError;
import com.google.enterprise.connector.ldap.LdapConstants.Method;
import com.google.enterprise.connector.ldap.LdapHandler.LdapConnectionSettings;
import com.google.enterprise.connector.ldap.LdapHandler.LdapRule;
import com.google.enterprise.connector.ldap.LdapSchemaFinder.SchemaResult;
import com.google.enterprise.connector.spi.ConfigureResponse;
import com.google.enterprise.connector.spi.ConnectorFactory;
import com.google.enterprise.connector.spi.ConnectorType;
import com.google.enterprise.connector.util.connectortype.ConnectorFields.AbstractField;
import com.google.enterprise.connector.util.connectortype.ConnectorFields.EnumField;
import com.google.enterprise.connector.util.connectortype.ConnectorFields.IntField;
import com.google.enterprise.connector.util.connectortype.ConnectorFields.MultiCheckboxField;
import com.google.enterprise.connector.util.connectortype.ConnectorFields.SingleLineField;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.NamingException;
/**
* {@link ConnectorType} implementation for the Ldap Connector. Implemented
* using the {@link ConnectorFields} class.
*/
public class LdapConnectorType implements ConnectorType {
private static final Logger LOG = Logger.getLogger(LdapConnectorType.class.getName());
private final LdapHandlerI ldapHandler;
public LdapConnectorType(LdapHandlerI ldapHandler) {
this.ldapHandler = ldapHandler;
}
public static final String RESOURCE_BUNDLE_NAME =
"com/google/enterprise/connector/ldap/config/" +
"LdapConnectorResources";
public static String makeDisplayPassword(String password) {
String displayPassword;
if (password == null) {
displayPassword = "<PASSWORD>";
} else if (password.length() < 1) {
displayPassword = "<<PASSWORD>>";
} else {
displayPassword = "####";
}
return displayPassword;
}
/**
* Holder object for managing the private state for a single configuration
* request.
*/
private class FormManager {
/**
* The maximum results examined to construct a schema
*/
private static final int MAX_SCHEMA_RESULTS = 1000;
private final ImmutableList<AbstractField> fields;
private final SingleLineField hostField, userField, passwordField, baseDnField,
filterField;
private final IntField portField;
private final EnumField<AuthType> authTypeField;
private final EnumField<Method> methodField;
private final MultiCheckboxField schemaField;
private final ResourceBundle bundle;
private final Map<String, String> config;
ConfigureResponse configureResponse = null;
private static final String SCHEMA_INSTRUCTIONS = "schema_instructions";
private static final String
SCHEMA_APPENDER_FUNCTION_NAME = "appendToSchema";
private static final String
GET_INDEXOF_FUNCTION_NAME = "getIndexOf";
private static final String
ONCLICK_FUNCTION_CALL = SCHEMA_APPENDER_FUNCTION_NAME + "(this)";
// HTML code allowing insertion of javascript
private static final String
SCRIPT_START = "<script type=\"text/javascript\">//<![CDATA[\n";
private static final String SCRIPT_END = "//]]></script>\n";
/** Sets field values from config that came from HTML form. */
FormManager(Map<String, String> configMap, ResourceBundle bundle) {
this.config = Maps.newHashMap(configMap);
hostField =
new SingleLineField(ConfigName.HOSTNAME.toString(), true, false);
portField = new IntField(ConfigName.PORT.toString(), false, 389);
authTypeField =
new EnumField<AuthType>(ConfigName.AUTHTYPE.toString(), true,
AuthType.class,
AuthType.ANONYMOUS);
userField =
new SingleLineField(ConfigName.USERNAME.toString(), false, false);
passwordField =
new SingleLineField(ConfigName.PASSWORD.toString(), false, true);
methodField =
new EnumField<Method>(ConfigName.METHOD.toString(), true,
Method.class, Method.STANDARD);
baseDnField =
new SingleLineField(ConfigName.BASEDN.toString(), false, false);
filterField =
new SingleLineField(ConfigName.FILTER.toString(), true, false);
schemaField =
new MultiCheckboxField(ConfigName.SCHEMA.toString(), false, null,
SCHEMA_INSTRUCTIONS, new MultiCheckboxField.Callback() {
@Override public Map<String, String> getAttributes(String key) {
Map<String, String> attributes = Maps.newHashMap();
attributes.put("onclick", ONCLICK_FUNCTION_CALL);
if (key.equalsIgnoreCase(LdapHandler.DN_ATTRIBUTE)) {
attributes.put("disabled", "disabled");
}
return attributes;
}
});
fields = ImmutableList.<AbstractField> of(
hostField,
portField,
authTypeField,
userField,
passwordField,
methodField,
baseDnField,
filterField,
schemaField);
// TODO(Max): remove traces of the schemaKey field that used to exist
// delaying this for now because it's close to release and I don't want
// to destabilize the code-base
for (AbstractField field: fields) {
field.setBoldLabel(false);
}
this.bundle = bundle;
LdapConnectorConfig ldapConnectorConfig = new LdapConnectorConfig(config);
String hostname = ldapConnectorConfig.getHostname();
LOG.fine("hostname " + hostname);
hostField.setValueFromString(hostname);
int port = ldapConnectorConfig.getPort();
LOG.fine("port " + port);
portField.setValueFromInt(port);
AuthType authtype = ldapConnectorConfig.getAuthtype();
LOG.fine("authtype " + authtype);
authTypeField.setValue(authtype);
String username = ldapConnectorConfig.getUsername();
LOG.fine("username " + username);
userField.setValueFromString(username);
String password = <PASSWORD>();
String displayPassword = makeDisplayPassword(password);
LOG.fine("password " + displayPassword);
passwordField.setValueFromString(password);
Method method = ldapConnectorConfig.getMethod();
LOG.fine("method " + method);
methodField.setValue(method);
String basedn = ldapConnectorConfig.getBasedn();
LOG.fine("basedn " + basedn);
baseDnField.setValueFromString(basedn);
String filter = ldapConnectorConfig.getFilter();
LOG.fine("filter " + filter);
filterField.setValueFromString(filter);
Set<String> selectedAttributes = ldapConnectorConfig.getSchema();
if (LOG.isLoggable(Level.INFO)) {
String string = dumpKeysToString(selectedAttributes);
LOG.info("FormManager selectedAttributes size:" + selectedAttributes.size()
+ " contents:" + string);
}
schemaField.setSelectedKeys(selectedAttributes);
LdapConnectionSettings settings = ldapConnectorConfig.getSettings();
// Note: we ignore connection errors here, because we just want to
// set up the state in the way it was when it was saved
try {
ldapHandler.setLdapConnectionSettings(settings);
} catch (Throwable t) {
// FIXME These errors are getting lost if not caught here. They need to
// be logged for debugging purposes and also need to allow the
// configuration to proceed even if there is any sort of connection
// error. May be revisited/removed once the internal logic is fool
// proof.
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
t.printStackTrace(pw);
LOG
.info("Error while trying set the connection in FormManager constructor using settings :"
+ settings + sw.toString());
}
LdapRule rule = ldapConnectorConfig.getRule();
if (rule != null) {
try {
getSchema(rule);
} catch (IllegalStateException e) {
reportError(e);
}
}
}
private void reportError(IllegalStateException e) {
Throwable cause = e.getCause();
if (cause == null) {
String errorName = e.getMessage();
ErrorMessages errorMessage = ErrorMessages.safeValueOf(errorName);
if (errorMessage != null) {
// we know this error
LOG.log(Level.WARNING, "Error getting schema for existing connector: "
+ errorMessage.toString());
return;
}
} else {
// cause != null
if (cause instanceof NamingException) {
// There was some kind of jndi problem - expected here
LOG.log(Level.WARNING, "Exception thrown getting schema for existing connector: " +
cause.getClass().getSimpleName());
// log stack trace for debugging
LOG.log(Level.FINE, "Stack trace:", e);
} else if (cause instanceof IOException) {
LOG.log(Level.WARNING, "Exception thrown getting schema for existing connector: " +
cause.getClass().getSimpleName());
// log stack trace for debugging
LOG.log(Level.FINE, "Stack trace:", e);
}
}
// fallback
LOG.log(Level.WARNING, "Unexpected Exception thrown getting schema for existing connector:",
e);
}
String getFormRows(Collection<String> errorKeys) {
StringBuilder buf = new StringBuilder();
// Insert the "preview" label
buf.append("<tr><td><br/><b>");
buf.append(bundle.getString(LdapConstants.LDAP_CONNECTOR_CONFIG));
String format = bundle.getString(LdapConstants.PREVIEW_HTML);
Object[] arguments = new Object[] {bundle.getString(LdapConstants.PREVIEW_TAG)};
String message = MessageFormat.format(format, arguments);
buf.append(message);
buf.append("</b></td></tr>\n");
// Note: Immutable lists are guaranteed to return the fields in the order
// they were specified, so this order is deterministic
for (AbstractField field : fields) {
String name = field.getName();
boolean highlightError = (errorKeys == null) ? false : errorKeys.contains(name);
buf.append(field.getSnippet(bundle, highlightError));
buf.append("\n");
}
// schemavalue hidden variable is used to get all the selected attributes
// from the UI as one json string.
String schemaValue = LdapConnectorConfig.
getSchemaValueFromConfig(config);
// hidden field for 'configured'
buf.append("<tr style='display: none'><td>\n");
buf.append("<input type = 'hidden' id = '");
buf.append(ConfigName.CONFIGURED).append("'");
buf.append(" name = '").append(ConfigName.CONFIGURED);
buf.append("' value = '");
buf.append(isConfigured());
buf.append("' />");
buf.append("</td></tr>\n");
// hidden field for 'schemavalue'
buf.append("<tr style='display: none'><td>\n");
buf.append("<input type = 'hidden' id = 'schemavalue'");
buf.append(" name = 'schemavalue' value = '").append(schemaValue);
buf.append("' />");
buf.append(SCRIPT_START);
buf.append(getIndexOfJavaScript());
buf.append(getSchemaAppenderJavaScript());
buf.append(SCRIPT_END);
buf.append("</td></tr>\n");
return buf.toString();
}
private void validateNotNull(Object o, String name) {
// convenience routine for checking and reporting on things that "should never happen"
if (o != null) {
return;
}
LOG.warning(ErrorMessages.UNKNOWN_CONNECTION_ERROR.name() + " null " + name);
configureResponse =
new ConfigureResponse(bundle.getString(ErrorMessages.MISSING_FIELDS.name()),
getFormRows(null));
}
private void getSchema(LdapRule rule) {
ldapHandler.setQueryParameters(rule, null, LdapHandler.DN_ATTRIBUTE, MAX_SCHEMA_RESULTS);
LdapSchemaFinder schemaFinder = new LdapSchemaFinder(ldapHandler);
validateNotNull(schemaFinder, "schemaFinder");
if (configureResponse != null) {
return;
}
SchemaResult schemaResult = schemaFinder.find(MAX_SCHEMA_RESULTS);
validateNotNull(schemaResult, "schemaResult");
//check if schema result fields are returned, display error of there are none
if (schemaResult.getResultCount() <= 0) {
configureResponse =
new ConfigureResponse(bundle.getString(ErrorMessages.NO_RESULTS_FOR_GIVEN_SEARCH_STRING
.name()), getFormRows(null));
}
if (configureResponse != null) {
return;
}
Set<String> foundSchema = schemaResult.getSchema().keySet();
validateNotNull(foundSchema, "foundSchema");
if (configureResponse != null) {
return;
}
schemaField.setKeys(foundSchema);
}
ConfigureResponse validateConfig(ConnectorFactory factory) {
configureResponse = null;
Collection<String> errorKeys = assureAllMandatoryFieldsPresent();
if (errorKeys.size() != 0) {
return new ConfigureResponse(bundle.getString(ErrorMessages.MISSING_FIELDS.name()),
getFormRows(errorKeys));
}
LOG.fine("Required fields validated");
// special validation for authentication type "simple"
LOG.fine("Validating fields for Simple Authentication");
String authtypeString = config.get(ConfigName.AUTHTYPE.toString()).trim();
if (authtypeString.equals(AuthType.SIMPLE.toString())) {
String username = config.get(ConfigName.USERNAME.toString()).trim();
String password = config.get(ConfigName.PASSWORD.toString()).trim();
Collection<String> simpleAuthnFieldNameErrorKeys = new ArrayList<String>();
LOG.fine("Validating Simple Authentication username ["+username+"] and password");
// validate each field - username and password are required
if (username.length() == 0) {
simpleAuthnFieldNameErrorKeys.add(ConfigName.USERNAME.toString());
LOG.info("Username is empty");
}
if (password.length() == 0) {
simpleAuthnFieldNameErrorKeys.add(ConfigName.PASSWORD.toString());
LOG.info("Password is empty");
}
// return errors
if (simpleAuthnFieldNameErrorKeys.size() != 0) {
LOG.info("Simple Authentication validation failed");
return new ConfigureResponse(bundle.getString(ErrorMessages.MISSING_FIELDS.name()),
getFormRows(simpleAuthnFieldNameErrorKeys));
}
}
LOG.fine("Simple Authentication validation successful!");
LdapConnectorConfig ldapConnectorConfig = new LdapConnectorConfig(config);
LdapConnectionSettings settings = ldapConnectorConfig.getSettings();
ldapHandler.setLdapConnectionSettings(settings);
// report any connection errors
Map<LdapConnectionError, Throwable> errors = ldapHandler.getErrors();
if (errors.size() > 0) {
String errorMessage = "";
for (LdapConnectionError e : errors.keySet()) {
errorMessage += bundle.getString(e.name());
}
return new ConfigureResponse(errorMessage, getFormRows(errorKeys));
}
ConfigureResponse failed = null;
// TODO: check for empty schema found
LdapRule rule = ldapConnectorConfig.getRule();
getSchema(rule);
// the above call sets the configureResponse non-null if there was an error
// and sets puts the schema found in the schemaField
if (configureResponse != null) {
// report the error
return configureResponse;
}
// look at the config again, using the new schema
ldapConnectorConfig = new LdapConnectorConfig(config);
schemaField.setSelectedKeys(ldapConnectorConfig.getSchema());
if (!schemaField.hasValue()) {
if (!schemaField.isEmpty()) {
HashSet<String> selectDnKey = new HashSet<String>();
selectDnKey.add(LdapHandler.DN_ATTRIBUTE);
schemaField.setSelectedKeys(selectDnKey);
}
return new ConfigureResponse(null, getFormRows(null));
}
if (!isConfigured()) {
config.put(ConfigName.CONFIGURED.toString(), "true");
return new ConfigureResponse(null, getFormRows(null), config);
}
ensureConfigIsComplete(config);
String errorMessageHtml;
// If we have been given a factory, try to instantiate a connector.
try {
if (factory != null) {
factory.makeConnector(config);
}
LOG.info("Successfully instantiated Ldap Connector");
HashMap<String, String> configData = Maps.newHashMap(config);
return new ConfigureResponse(null, null, configData);
} catch (Exception e) {
// We should perform sufficient validation so instantiation succeeds.
LOG.log(Level.SEVERE, "failed to instantiate Ldap Connector ", e);
return new ConfigureResponse(bundle.getString(ErrorMessages.CONNECTOR_INSTANTIATION_FAILED
.name()), getFormRows(null));
}
}
/**
* Returns true if the connector has been configured
*/
private boolean isConfigured() {
return Boolean.parseBoolean(config.get(ConfigName.CONFIGURED.toString()));
}
/**
* Checks to make sure all required fields are set.
*
* @return a collection of missing field names.
*/
private Collection<String> assureAllMandatoryFieldsPresent() {
List<String> missing = new ArrayList<String>();
for (AbstractField field : fields) {
if (field.isMandatory() && (!field.hasValue())) {
missing.add(field.getName());
}
}
return missing;
}
/**
* This method generates a String representation of a javascript function
* that gets called on 'onclick' event of all the checkboxes representing
* the LDAP server attributs.
* Following javascript gets generated by this method.
*
* <script type="text/javascript">
* var schemaList = new Array();
* function appendToSchema(chkbox) {
* if (chkbox.checked) {
* schemaList.push(chkbox.value);
* } else {
* schemaList.splice(schemaList.indexOf(chkbox.value),1);
* }
* document.getElementById('schemavalue').value = JSON.stringify(schemaList);
* }
* </script>
*
* @return String representation of a javascript function.
*/
private String getSchemaAppenderJavaScript() {
StringBuilder buf = new StringBuilder();
buf.append("var schemaList = new Array();")
.append("function ")
.append(SCHEMA_APPENDER_FUNCTION_NAME).append("(chkbox) {")
.append("if (schemaList.length == 0) {")
.append("schemaList = JSON.parse(document.getElementById('schemavalue').value);")
.append("}")
.append("if (chkbox.checked) {")
.append("schemaList.push(chkbox.value);")
.append("document.getElementById('schemavalue').value")
.append(" = JSON.stringify(schemaList);")
.append("}")
.append("else {")
.append("if(" + GET_INDEXOF_FUNCTION_NAME + "(schemaList,chkbox.value) >= 0) {")
.append("schemaList.splice(" + GET_INDEXOF_FUNCTION_NAME + "(schemaList,chkbox.value),1);")
.append("document.getElementById('schemavalue').value")
.append(" = JSON.stringify(schemaList);")
.append("}}}");
return buf.toString();
}
/**
* This method generates a String representation of a JavaScript function getIndexOf.
* The java script function returns the index of the value in array object. If the value
* is not found in array -1 is returned.
* This method is added as workaround to HtmlUnit failing on JS indexOf function.
* Following java script gets generated by this method.
*
* function getIndexOf(arr, value) {
* for(var i=0; i< arr.length; i++){
* if(arr[i] == value)
* return i;
* }
* return -1;
* }
*
* @return String representation of a JavaScript function.
*/
private String getIndexOfJavaScript() {
StringBuilder buf = new StringBuilder();
buf.append("function ")
.append(GET_INDEXOF_FUNCTION_NAME)
.append("(arr, value) {")
.append("for(var i=0; i< arr.length; i++){")
.append("if(arr[i] == value)")
.append("return i;")
.append("}")
.append("return -1;")
.append("}");
return buf.toString();
}
}
@VisibleForTesting
public ResourceBundle getResourceBundle(Locale locale) {
ResourceBundle resourceBundle = ResourceBundle.getBundle(RESOURCE_BUNDLE_NAME, locale);
return resourceBundle;
}
@Override
public ConfigureResponse getConfigForm(Locale locale) {
ConfigureResponse configureResponse;
ResourceBundle resourceBundle = getResourceBundle(locale);
HashMap<String, String> configMap = Maps.newHashMap();
FormManager formManager = new FormManager(configMap, resourceBundle);
configureResponse = new ConfigureResponse("", formManager.getFormRows(null));
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("getConfigForm form:\n" + configureResponse.getFormSnippet());
}
return configureResponse;
}
@Override
public ConfigureResponse getPopulatedConfigForm(Map<String, String> config, Locale locale) {
if (LOG.isLoggable(Level.FINE)) {
String string = dumpConfigToString(config);
LOG.fine("getPopulatedConfigForm config:" + string);
}
FormManager formManager = new FormManager(config, getResourceBundle(locale));
ConfigureResponse res = new ConfigureResponse("", formManager.getFormRows(null));
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("getPopulatedConfigForm form:\n" + res.getFormSnippet());
}
return res;
}
@Override
public ConfigureResponse validateConfig(Map<String, String> config, Locale locale,
ConnectorFactory factory) {
if (LOG.isLoggable(Level.FINE)) {
String string = dumpConfigToString(config);
LOG.fine("validateConfig config:" + string);
}
LOG.fine("Creating FormManager for validating LDAP connector config");
FormManager formManager = null;
try {
formManager = new FormManager(config, getResourceBundle(locale));
} catch (Throwable t) {
// FIXME These errors are getting lost if not caught here. They need to
// be logged for debugging purposes and also need to allow the
// configuration to proceed even if there is any sort of connection
// error. May be revisited/removed once the internal logic is fool
// proof.
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
t.printStackTrace(pw);
LOG.severe("Error in FormManager Constructor " + t.toString() + sw.toString());
}
LOG.fine("Calling validate for FormManager");
ConfigureResponse res = null;
try {
res = formManager.validateConfig(factory);
} catch (Throwable t) {
// FIXME These errors are getting lost if not caught here. They need to
// be logged for debugging purposes and also need to allow the
// configuration to proceed even if there is any sort of connection
// error. May be revisited/removed once the internal logic is fool
// proof.
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
t.printStackTrace(pw);
LOG.severe("Error in Validate config " + t.toString() + sw.toString());
}
LOG.fine("FormManager validate successful");
if (res == null) {
LOG.info("validateConfig form: success - returning null");
} else if (res.getMessage() == null && res.getFormSnippet() == null) {
LOG.info("validateConfig form: success - returning new config");
if (LOG.isLoggable(Level.FINE)) {
String string = dumpConfigToString(res.getConfigData());
LOG.fine("validateConfig outconfig:" + string);
}
} else {
LOG.info("validateConfig returning message: " + res.getMessage());
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("validateConfig returning message: " + res.getMessage());
LOG.fine("validateConfig returning new form:\n" + res.getFormSnippet());
}
}
return res;
}
/**
* For logging
*/
private static String dumpConfigToString(Map<String, String> config) {
StringBuilder sb = new StringBuilder();
for (String key : config.keySet()) {
sb.append("\n");
sb.append("Key ");
sb.append(key);
sb.append(" Value \"");
String value = config.get(key);
if ("password".equals(key)) {
value = makeDisplayPassword(value);
}
sb.append(value);
sb.append("\"");
}
String string = sb.toString();
return string;
}
/**
* For logging
*/
private static String dumpKeysToString(Set<String> keys) {
StringBuilder sb = new StringBuilder();
for (String key : keys) {
sb.append("\n");
sb.append("Key ");
sb.append(key);
}
String string = sb.toString();
return string;
}
/**
* In order to avoid problems during instantiation, a stored config should
* contain a clue for each element referenced in the connectorInstance.xml.
* This makes sure that the config map is complete in that sense, by adding
* default values for any missing keys.
*/
private static void ensureConfigIsComplete(Map<String, String> config) {
// set known defaults
setDefaultIfNecessary(config, ConfigName.METHOD.toString(),
Method.getDefault().toString());
setDefaultIfNecessary(config, ConfigName.AUTHTYPE.toString(),
AuthType.getDefault().toString());
setDefaultIfNecessary(config, ConfigName.PORT.toString(),
Integer.toString(LdapConstants.DEFAULT_PORT));
for (ConfigName cn : ConfigName.values()) {
// Schema and SchemaKey are treated specially below
if (ConfigName.SCHEMA == cn
|| ConfigName.SCHEMA_KEY == cn) {
continue;
}
setDefaultIfNecessary(config, cn.toString(), " ");
}
setDefaultIfNecessary(config, ConfigName.SCHEMA_KEY.toString(),
LdapHandler.DN_ATTRIBUTE);
}
private static void setDefaultIfNecessary(Map<String, String> config, String key,
String defaultValue) {
if (config.containsKey(key)) {
return;
}
config.put(key, defaultValue);
}
}
|
import { Pool } from 'pg';
import "@babel/polyfill";
require('dotenv').config();
const pool = new Pool({
host: process.env.DB_HOST,
port: process.env.DB_PORT,
database: process.env.DB_DEFAULT_DATABASE,
user: process.env.DB_USERNAME,
password: <PASSWORD>
})
const databaseConnectionHandler = {
testConnection() {
}
}
export default databaseConnectionHandler;
|
package com.yuansfer.paysdk.okhttp;
import java.io.IOException;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import okio.Buffer;
import okio.BufferedSink;
import okio.ForwardingSink;
import okio.Okio;
import okio.Sink;
public class ProgressRequestBody extends RequestBody {
private IResponseHandler mResponseHandler;
private RequestBody mRequestBody;
private BufferedSink mBufferedSink;
public ProgressRequestBody(RequestBody requestBody, IResponseHandler responseHandler) {
this.mResponseHandler = responseHandler;
this.mRequestBody = requestBody;
}
public MediaType contentType() {
return this.mRequestBody.contentType();
}
public long contentLength() throws IOException {
return this.mRequestBody.contentLength();
}
public void writeTo(BufferedSink sink) throws IOException {
if (this.mBufferedSink == null) {
this.mBufferedSink = Okio.buffer(this.sink(sink));
}
this.mRequestBody.writeTo(this.mBufferedSink);
this.mBufferedSink.flush();
}
private Sink sink(Sink sink) {
return new ForwardingSink(sink) {
long bytesWritten = 0L;
long contentLength = 0L;
public void write(Buffer source, long byteCount) throws IOException {
super.write(source, byteCount);
if (this.contentLength == 0L) {
this.contentLength = ProgressRequestBody.this.contentLength();
}
this.bytesWritten += byteCount;
ProgressRequestBody.this.mResponseHandler.onProgress(this.bytesWritten, this.contentLength);
}
};
}
}
|
#!/bin/bash
mkdir -p logs
mkdir -p pids
# run_program (nodefile, pidfile, logfile)
run_program ()
{
nodefile=$1
pidfile=$2
logfile=$3
if [ -e "$pidfile" ]
then
echo "$nodefile is already running. Run 'npm stop' if you wish to restart."
return 0
fi
nohup node $nodefile >> $logfile 2>&1 &
PID=$!
if [ $? -eq 0 ]
then
echo "Successfully started $nodefile. PID=$PID. Logs are at $logfile"
echo $PID > $pidfile
return 0
else
echo "Could not start $nodefile - check logs at $logfile"
exit 1
fi
}
run_program ./ts_build/messagebroker/messagebroker.js pids/messagebroker.pid logs/messagebroker.log
run_program ./ts_build/bcmonitor/bcmonitor.js pids/bcmonitor.pid logs/bcmonitor.log
run_program ./ts_build/emailservice/emailservice.js pids/emailservice.pid logs/emailservice.log
run_program ./ts_build/pushnotificationsservice/pushnotificationsservice.js pids/pushnotificationsservice.pid logs/pushnotificationsservice.log
run_program ./ts_build/fiatrateservice/fiatrateservice.js pids/fiatrateservice.pid logs/fiatrateservice.log
run_program ./ts_build/bws.js pids/bws.pid logs/bws.log
|
<filename>index.js
'use strict';
var parse = require('./lib/parse.js');
module.exports = function (str, options = {}) {
const ast = parse(str);
const minFontSize = options.minFontSize || 10;
const peferredFontSize = options.peferredFontSize || 24;
const fontLevel = ast.getFontLevel();
const topLevelFontSize = Math.max(peferredFontSize, minFontSize + (fontLevel * 8));
return ast.render(0, 0, topLevelFontSize);
};
|
package com.networknt.eventuate.test.domain;
import com.networknt.eventuate.common.Snapshot;
import java.math.BigDecimal;
public class AccountSnapshot implements Snapshot {
private BigDecimal balance;
public AccountSnapshot() {
}
public AccountSnapshot(BigDecimal balance) {
this.balance = balance;
}
public BigDecimal getBalance() {
return balance;
}
}
|
<reponame>Bradenbertrand/WordleLeaderboards<filename>commands/points.js
const User = require('../models/user');
module.exports.run = async (bot, message, args) => {
console.log("Points has been run")
let userid = message.author.id
//Finds a user based on userId
User.findOne({ userId: userid}, function (err, currentUser) {
if (err) {
console.log("Theres been an error finding a user")
message.channel.send("Theres been an error contact big daddy braden pls :)")
}
//If user does not exist, send a error. This should never happen.
if (!currentUser) {
console.log("User does not exist")
message.channel.send("You don't exist or something. That's pretty weird.")
} else {
//Send a message with the username and the points of the user
message.channel.send("User " +
message.author.username + " has " +
currentUser.points + " points.")
}
})
}
module.exports.config = {
command: "points"
}
|
<gh_stars>0
const router = require("express").Router();
const db = require('../models')
//add more here
router.get("/api/workouts", (req , res) => {
//console.log("message")
db.Workout.aggregate([
{
$addFields: {
totalDuration: {
$sum: "$exercises.duration"
}
}
}
])
.then (data => {
res.json(data);
})
.catch (error => {
res.json(error)
})
});
router.post ("/api/workouts", ({body}, res) => {
db.Workout.create(body)
.then (data => {
res.json(data);
})
.catch (error => {
res.json(error)
})
});
router.put("/api/workouts/:id", (req, res) => {
db.Workout.findOneAndUpdate(
{_id: req.params.id },
{ $push: { exercises: req.body }},
{ new: true })
.then (data => {
res.json(data);
})
.catch (error => {
res.json(error)
})
});
// Range
router.get("/api/workouts/range", (req, res) => {
db.Workout.aggregate([
{
$addFields: {
totalDuration: {
$sum: "$exercises.duration"
}
}
}
])
.sort({_id: -1})
.limit(7)
.then(data => {
res.json(data);
})
.catch (error => {
res.json(error)
})
});
module.exports = router;
|
/*
* Copyright 2020 Red Hat
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.apicurio.hub.core.editing.events;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.databind.JsonNode;
import io.apicurio.hub.core.editing.ops.BaseOperation;
import io.apicurio.hub.core.editing.ops.JoinLeaveOperation;
import io.apicurio.hub.core.editing.ops.OperationFactory;
import io.apicurio.hub.core.util.JsonUtil;
import java.util.List;
/**
* @author <NAME>
*/
@JsonIgnoreProperties(ignoreUnknown = true)
public class EventAction {
private ActionType type;
private String id;
private byte[] op;
private List<JoinLeaveOperation> ops;
public EventAction() {
}
private EventAction(ActionType type, String id, BaseOperation op, List<JoinLeaveOperation> ops) {
this.type = type;
this.id = id;
this.op = JsonUtil.toJsonBytes(op);
this.ops = ops;
}
public static EventAction close(String uuid) {
return new EventAction(ActionType.CLOSE, uuid, null, null);
}
public static EventAction rollup(String uuid) {
return new EventAction(ActionType.ROLLUP, uuid, null, null);
}
public static EventAction sendToOthers(BaseOperation op, String excludedContextId) {
return new EventAction(ActionType.SEND_TO_OTHERS, excludedContextId, op, null);
}
public static EventAction sendToList(String toContextId) {
return new EventAction(ActionType.SEND_TO_LIST, toContextId, null, null);
}
public static EventAction sendToExecute(List<JoinLeaveOperation> ops, String toContextId) {
return new EventAction(ActionType.SEND_TO_EXECUTE, toContextId, null, ops);
}
@Override
public String toString() {
return String.format("EventAction: %s", type);
}
public BaseOperation toBaseOperation() {
JsonNode jsonNode = JsonUtil.toJsonTree(op);
return OperationFactory.operation(jsonNode);
}
public ActionType getType() {
return type;
}
public void setType(ActionType type) {
this.type = type;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public byte[] getOp() {
return op;
}
public void setOp(byte[] op) {
this.op = op;
}
public List<JoinLeaveOperation> getOps() {
return ops;
}
public void setOps(List<JoinLeaveOperation> ops) {
this.ops = ops;
}
}
|
#!/bin/bash
#
# This file is part of arduino-preprocessor.
#
# Copyright 2017 ARDUINO AG
#
# arduino-preprocessor is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
# As a special exception, you may use this file as part of a free software
# library without restriction. Specifically, if other files instantiate
# templates or use macros or inline functions from this file, or you compile
# this file and link it with other files to produce an executable, this
# file does not by itself cause the resulting executable to be covered by
# the GNU General Public License. This exception does not however
# invalidate any other reasons why the executable file might be covered by
# the GNU General Public License.
#
source term.sh
test_preprocessor() {
rm -rf tmp
mkdir tmp
TEST=$1
say "@cyan[[Testing preprocessor on @b$TEST]]"
../arduino-preprocessor/arduino-preprocessor $TEST -- -std=gnu++11 > tmp/preproc.cpp
if [ $? -ne 0 ]; then
fail "Error running arduino-preprocessor"
return 1
fi
say "@cyan[[Running compiler...]]"
g++ -std=gnu++11 -c tmp/preproc.cpp -o tmp/preproc.o
if [ $? -ne 0 ]; then
# if the test fails output the preprocessed source code
echo ""
say "@cyan[[Preprocessor output with debugging enabled:]]"
echo ""
../arduino-preprocessor/arduino-preprocessor -debug $TEST -- -std=gnu++11
fail $TEST
return 1
fi
pass $TEST
return 0
}
# Try to build all sources in testdata
hr
FAILS=0
TOTAL=0
for TEST in `find testdata -name "test_*.cpp"`; do
test_preprocessor $TEST
FAILS=$(($FAILS+$?))
TOTAL=$(($TOTAL+1))
hr
done
echo $TOTAL tests run
echo $FAILS tests failed
exit $FAILS
|
package poemstar.beans;
import java.util.ArrayList;
/**
* Verses of poem
* @author xinway
*/
public class Verses {
public void addVerse(String s) {
contents_.add(s);
}
public int getCount() {
return contents_.size();
}
public String getAt(int pos) {
if ((pos < 0) || (pos >= getCount())) {
return "";
}
return contents_.get(pos);
}
ArrayList<String> contents_ = new ArrayList<>();
}
|
(page,done) =>
{
let that = this;
let lable = "PLZ";
let msg = 'Wohoo, more than 1000 active users! So, so cool! But only <a href="https://chrome.google.com/webstore/detail/full-stack-optimization-l/jbnaibigcohjfefpfocphcjeliohhold?hl=en" target="_blank">6 reviews</a> 😢. <b>Please <span style="background: linear-gradient(to right, red, orange, green, cyan, blue, violet); -webkit-background-clip: text;-webkit-text-fill-color: transparent;">review</span> this app in the <a href="https://chrome.google.com/webstore/detail/full-stack-optimization-l/jbnaibigcohjfefpfocphcjeliohhold" target="_blank">Google Chrome Store</a>!</b> 👍 Thx! <br> You can disable this message in the <a href="'+that.getGlobals().rulesUrl+'" target="_blank" >Settings</a>.';
let type = "promotion";
let what = "";
done(that.createResult(lable, msg, type, what));return;
}
|
<reponame>nikolabebic95/PIAZadaci
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package beans;
import java.util.ArrayList;
/**
*
* @author Nikola
*/
public class ExamsListBean {
private ArrayList<ExamBean> list = new ArrayList<>();
public ArrayList<ExamBean> getList() {
return list;
}
public void setList(ArrayList<ExamBean> list) {
this.list = list;
}
public void add(ExamBean examBean) {
list.add(examBean);
}
}
|
package k8s
import (
"testing"
cond_v1 "github.com/atlassian/ctrl/apis/condition/v1"
"github.com/stretchr/testify/require"
)
func TestCalculateConditionAny(t *testing.T) {
t.Parallel()
t.Run("returns false on empty conditions", func(t *testing.T) {
require.Equal(t, cond_v1.ConditionFalse, CalculateConditionAny([]cond_v1.Condition{}))
})
t.Run("returns true if any trues", func(t *testing.T) {
conditions := []cond_v1.Condition{
{
Status: cond_v1.ConditionFalse,
},
{
Status: cond_v1.ConditionFalse,
},
{
Status: cond_v1.ConditionTrue,
},
}
require.Equal(t, cond_v1.ConditionTrue, CalculateConditionAny(conditions))
})
t.Run("returns unknown if no trues and has unknown", func(t *testing.T) {
conditions := []cond_v1.Condition{
{
Status: cond_v1.ConditionFalse,
},
{
Status: cond_v1.ConditionUnknown,
},
{
Status: cond_v1.ConditionFalse,
},
}
require.Equal(t, cond_v1.ConditionUnknown, CalculateConditionAny(conditions))
})
t.Run("returns false if only falses", func(t *testing.T) {
conditions := []cond_v1.Condition{
{
Status: cond_v1.ConditionFalse,
},
{
Status: cond_v1.ConditionFalse,
},
{
Status: cond_v1.ConditionFalse,
},
}
require.Equal(t, cond_v1.ConditionFalse, CalculateConditionAny(conditions))
})
}
func TestCalculateConditionAll(t *testing.T) {
t.Parallel()
t.Run("returns unknown on empty conditions", func(t *testing.T) {
require.Equal(t, cond_v1.ConditionUnknown, CalculateConditionAll([]cond_v1.Condition{}))
})
t.Run("returns false if any false", func(t *testing.T) {
conditions := []cond_v1.Condition{
{
Status: cond_v1.ConditionFalse,
},
{
Status: cond_v1.ConditionTrue,
},
{
Status: cond_v1.ConditionTrue,
},
}
require.Equal(t, cond_v1.ConditionFalse, CalculateConditionAll(conditions))
})
t.Run("returns unknown if any unknown", func(t *testing.T) {
conditions := []cond_v1.Condition{
{
Status: cond_v1.ConditionFalse,
},
{
Status: cond_v1.ConditionTrue,
},
{
Status: cond_v1.ConditionUnknown,
},
}
require.Equal(t, cond_v1.ConditionUnknown, CalculateConditionAll(conditions))
})
t.Run("returns false if no unknowns and has false", func(t *testing.T) {
conditions := []cond_v1.Condition{
{
Status: cond_v1.ConditionFalse,
},
{
Status: cond_v1.ConditionTrue,
},
{
Status: cond_v1.ConditionTrue,
},
}
require.Equal(t, cond_v1.ConditionFalse, CalculateConditionAll(conditions))
})
t.Run("returns true if only trues", func(t *testing.T) {
conditions := []cond_v1.Condition{
{
Status: cond_v1.ConditionTrue,
},
{
Status: cond_v1.ConditionTrue,
},
{
Status: cond_v1.ConditionTrue,
},
}
require.Equal(t, cond_v1.ConditionTrue, CalculateConditionAll(conditions))
})
}
func TestString(t *testing.T) {
t.Parallel()
condition := cond_v1.Condition{}
require.NotEmpty(t, condition.String())
}
|
class Swagger::Schema::Factory
attr_reader :name, :fields, :specification
def initialize(name, fields, specification)
@name = name
@fields = fields
@specification = specification
end
def call
if fields.key?('$ref')
Swagger::Reference.new(name, fields, specification)
elsif fields.key?('allOf')
Swagger::Schema::AllOf.new(name, fields, specification)
else
other_schema_by_type
end
end
private
def other_schema_by_type
fail "Unhandled property type: #{fields.inspect}" unless valid_type?
typed_schema_element
end
def typed_schema_element
array_class || string || number || boolean || array || object
end
def string
return unless type == 'string'
Swagger::Schema::String.new(name, fields, specification)
end
def number
return unless number_type?
Swagger::Schema::Number.new(name, fields, specification)
end
def boolean
return unless type == 'boolean'
Swagger::Schema::Boolean.new(name, fields, specification)
end
def array
return unless type == 'array'
Swagger::Schema::Array.new(name, fields, specification)
end
def object
return if !(type == 'object') && !type.nil?
Swagger::Schema::Object.new(name, fields, specification)
end
def type
fields['type']
end
def valid_type?
array_class? ||
['string', 'integer', 'number', 'boolean', 'boolean', 'array', 'object', nil].include?(type)
end
def number_type?
type == 'integer' || type == 'number'
end
def array_class?
type.class == ::Array
end
def array_class
return unless array_class?
fail "Unhandled array type: #{fields.inspect}" unless valid_array_class?
recurse_for_array
end
def valid_array_class?
type.size == 2 && type.last == 'null'
end
def recurse_for_array
self.class.new(name, fields.merge('nullable' => true, 'type' => type.first), specification).call
end
end
|
<filename>app/components/support_interface/application_api_representation_component.rb
module SupportInterface
class ApplicationAPIRepresentationComponent < ViewComponent::Base
include APIDocsHelper
def initialize(application_choice:)
@application_choice = application_choice
end
private
def application_json
AllowedCrossNamespaceUsage::VendorAPISingleApplicationPresenter.new(@application_choice).as_json
end
end
end
|
<filename>app/src/main/java/com/smartalgorithms/getit/Place/PlaceContract.java
package com.smartalgorithms.getit.Place;
import android.content.DialogInterface;
import com.smartalgorithms.getit.Models.Local.ReverseGeoResponse;
import java.util.List;
/**
* Contact <EMAIL>
* Created by <NAME> on 2017/12/06.
* Updated by <NAME> on 2017/12/06.
*/
public class PlaceContract {
public interface UIListener {
void onAddressRecieved(String formatted_address);
void onAdapterCreated(PlaceImageAdapter imageLinks);
void updateUI(String title, String info, String link_phone, String checkins);
void showMessage(String title, String message, DialogInterface.OnClickListener ok_listener, DialogInterface.OnClickListener cancel_listener, boolean has_cancel, String positive_text, String negative_text);
//void transitionOn(Class<?> toClass, finis)
}
public interface PresenterListener {
void onGetAddress(ReverseGeoResponse reverseGeoResponse);
void onGetImageUrlsComplete(List<String> urls);
void getUIStrings();
void requestAddress();
}
}
|
#!/bin/bash
set -ex
function install_92 {
echo "Installing CUDA 9.2 and CuDNN"
# install CUDA 9.2 in the same container
wget -q https://developer.nvidia.com/compute/cuda/9.2/Prod2/local_installers/cuda_9.2.148_396.37_linux -O setup
chmod +x setup
./setup --silent --no-opengl-libs --toolkit
rm -f setup
# patch 1
wget -q https://developer.nvidia.com/compute/cuda/9.2/Prod2/patches/1/cuda_9.2.148.1_linux -O setup
chmod +x setup
./setup -s --accept-eula
rm -f setup
# install CUDA 9.2 CuDNN
# cuDNN license: https://developer.nvidia.com/cudnn/license_agreement
mkdir tmp_cudnn && cd tmp_cudnn
wget -q http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/libcudnn7-dev_7.6.3.30-1+cuda9.2_amd64.deb -O cudnn-dev.deb
wget -q http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/libcudnn7_7.6.3.30-1+cuda9.2_amd64.deb -O cudnn.deb
ar -x cudnn-dev.deb && tar -xvf data.tar.xz
ar -x cudnn.deb && tar -xvf data.tar.xz
mkdir -p cuda/include && mkdir -p cuda/lib64
cp -a usr/include/x86_64-linux-gnu/cudnn_v7.h cuda/include/cudnn.h
cp -a usr/lib/x86_64-linux-gnu/libcudnn* cuda/lib64
mv cuda/lib64/libcudnn_static_v7.a cuda/lib64/libcudnn_static.a
ln -s libcudnn.so.7 cuda/lib64/libcudnn.so
chmod +x cuda/lib64/*.so
cp -a cuda/include/* /usr/local/cuda/include/
cp -a cuda/lib64/* /usr/local/cuda/lib64/
cd ..
rm -rf tmp_cudnn
ldconfig
}
function install_100 {
echo "Installing CUDA 10.0 and CuDNN"
# install CUDA 10.0 in the same container
wget -q https://developer.nvidia.com/compute/cuda/10.0/Prod/local_installers/cuda_10.0.130_410.48_linux
chmod +x cuda_10.0.130_410.48_linux
./cuda_10.0.130_410.48_linux --silent --no-opengl-libs --toolkit
rm -f cuda_10.0.130_410.48_linux
# install CUDA 10.0 CuDNN
# cuDNN license: https://developer.nvidia.com/cudnn/license_agreement
mkdir tmp_cudnn && cd tmp_cudnn
wget -q http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/libcudnn7-dev_7.6.3.30-1+cuda10.0_amd64.deb -O cudnn-dev.deb
wget -q http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/libcudnn7_7.6.3.30-1+cuda10.0_amd64.deb -O cudnn.deb
ar -x cudnn-dev.deb && tar -xvf data.tar.xz
ar -x cudnn.deb && tar -xvf data.tar.xz
mkdir -p cuda/include && mkdir -p cuda/lib64
cp -a usr/include/x86_64-linux-gnu/cudnn_v7.h cuda/include/cudnn.h
cp -a usr/lib/x86_64-linux-gnu/libcudnn* cuda/lib64
mv cuda/lib64/libcudnn_static_v7.a cuda/lib64/libcudnn_static.a
ln -s libcudnn.so.7 cuda/lib64/libcudnn.so
chmod +x cuda/lib64/*.so
cp -a cuda/include/* /usr/local/cuda/include/
cp -a cuda/lib64/* /usr/local/cuda/lib64/
cd ..
rm -rf tmp_cudnn
ldconfig
}
function install_101 {
echo "Installing CUDA 10.1 and CuDNN"
rm -rf /usr/local/cuda-10.1 /usr/local/cuda
# # install CUDA 10.1 in the same container
wget -q http://developer.download.nvidia.com/compute/cuda/10.1/Prod/local_installers/cuda_10.1.243_418.87.00_linux.run
chmod +x cuda_10.1.243_418.87.00_linux.run
./cuda_10.1.243_418.87.00_linux.run --extract=/tmp/cuda
rm -f cuda_10.1.243_418.87.00_linux.run
mv /tmp/cuda/cuda-toolkit /usr/local/cuda-10.1
rm -rf /tmp/cuda
rm -f /usr/local/cuda && ln -s /usr/local/cuda-10.1 /usr/local/cuda
# install CUDA 10.1 CuDNN
# cuDNN license: https://developer.nvidia.com/cudnn/license_agreement
mkdir tmp_cudnn && cd tmp_cudnn
wget -q http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/libcudnn7-dev_7.6.3.30-1+cuda10.1_amd64.deb -O cudnn-dev.deb
wget -q http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/libcudnn7_7.6.3.30-1+cuda10.1_amd64.deb -O cudnn.deb
ar -x cudnn-dev.deb && tar -xvf data.tar.xz
ar -x cudnn.deb && tar -xvf data.tar.xz
mkdir -p cuda/include && mkdir -p cuda/lib64
cp -a usr/include/x86_64-linux-gnu/cudnn_v7.h cuda/include/cudnn.h
cp -a usr/lib/x86_64-linux-gnu/libcudnn* cuda/lib64
mv cuda/lib64/libcudnn_static_v7.a cuda/lib64/libcudnn_static.a
ln -s libcudnn.so.7 cuda/lib64/libcudnn.so
chmod +x cuda/lib64/*.so
cp -a cuda/include/* /usr/local/cuda/include/
cp -a cuda/lib64/* /usr/local/cuda/lib64/
cd ..
rm -rf tmp_cudnn
ldconfig
}
function prune_92 {
echo "Pruning CUDA 9.2 and CuDNN"
#####################################################################################
# CUDA 9.2 prune static libs
#####################################################################################
export NVPRUNE="/usr/local/cuda-9.2/bin/nvprune"
export CUDA_LIB_DIR="/usr/local/cuda-9.2/lib64"
export GENCODE="-gencode arch=compute_35,code=sm_35 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_70,code=sm_70"
export GENCODE_CUDNN="-gencode arch=compute_35,code=sm_35 -gencode arch=compute_37,code=sm_37 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_61,code=sm_61 -gencode arch=compute_70,code=sm_70"
# all CUDA libs except CuDNN and CuBLAS (cudnn and cublas need arch 3.7 included)
grep "\.a" $CUDA_LIB_DIR/* | grep -v "culibos" | grep -v "cudart" | grep -v "cudnn" | grep -v "cublas" | grep -v "cusolver" \
| xargs -I {} bash -c \
"echo {} && $NVPRUNE $GENCODE $CUDA_LIB_DIR/{} -o $CUDA_LIB_DIR/{}"
# prune CuDNN and CuBLAS
$NVPRUNE "$GENCODE_CUDNN" $CUDA_LIB_DIR/libcudnn_static.a -o $CUDA_LIB_DIR/libcudnn_static.a
$NVPRUNE "$GENCODE_CUDNN" $CUDA_LIB_DIR/libcublas_static.a -o $CUDA_LIB_DIR/libcublas_static.a
$NVPRUNE "$GENCODE_CUDNN" $CUDA_LIB_DIR/libcublas_device.a -o $CUDA_LIB_DIR/libcublas_device.a
}
function prune_100 {
echo "Pruning CUDA 10.0 and CuDNN"
#####################################################################################
# CUDA 10.0 prune static libs
#####################################################################################
export NVPRUNE="/usr/local/cuda-10.0/bin/nvprune"
export CUDA_LIB_DIR="/usr/local/cuda-10.0/lib64"
export GENCODE="-gencode arch=compute_35,code=sm_35 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_70,code=sm_70 -gencode arch=compute_75,code=sm_75"
export GENCODE_CUDNN="-gencode arch=compute_35,code=sm_35 -gencode arch=compute_37,code=sm_37 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_61,code=sm_61 -gencode arch=compute_70,code=sm_70 -gencode arch=compute_75,code=sm_75"
# all CUDA libs except CuDNN and CuBLAS (cudnn and cublas need arch 3.7 included)
# curand cannot be pruned, as there's a bug in 10.0 + curand_static + nvprune. Filed with nvidia at 2460767
grep "\.a" $CUDA_LIB_DIR/* | grep -v "culibos" | grep -v "cudart" | grep -v "cudnn" | grep -v "cublas" | grep -v "metis" | grep -v "curand" \
| xargs -I {} bash -c \
"echo {} && $NVPRUNE $GENCODE $CUDA_LIB_DIR/{} -o $CUDA_LIB_DIR/{}"
# prune CuDNN and CuBLAS
$NVPRUNE "$GENCODE_CUDNN" $CUDA_LIB_DIR/libcudnn_static.a -o $CUDA_LIB_DIR/libcudnn_static.a
$NVPRUNE "$GENCODE_CUDNN" $CUDA_LIB_DIR/libcublas_static.a -o $CUDA_LIB_DIR/libcublas_static.a
}
function prune_101 {
echo "Pruning CUDA 10.1 and CuDNN"
#####################################################################################
# CUDA 10.1 prune static libs
#####################################################################################
export NVPRUNE="/usr/local/cuda-10.1/bin/nvprune"
export CUDA_LIB_DIR="/usr/local/cuda-10.1/lib64"
export GENCODE="-gencode arch=compute_35,code=sm_35 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_70,code=sm_70 -gencode arch=compute_75,code=sm_75"
export GENCODE_CUDNN="-gencode arch=compute_35,code=sm_35 -gencode arch=compute_37,code=sm_37 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_61,code=sm_61 -gencode arch=compute_70,code=sm_70 -gencode arch=compute_75,code=sm_75"
# all CUDA libs except CuDNN and CuBLAS (cudnn and cublas need arch 3.7 included)
grep "\.a" $CUDA_LIB_DIR/* | grep -v "culibos" | grep -v "cudart" | grep -v "cudnn" | grep -v "cublas" | grep -v "metis" \
| xargs -I {} bash -c \
"echo {} && $NVPRUNE $GENCODE $CUDA_LIB_DIR/{} -o $CUDA_LIB_DIR/{}"
# prune CuDNN and CuBLAS
$NVPRUNE "$GENCODE_CUDNN" $CUDA_LIB_DIR/libcudnn_static.a -o $CUDA_LIB_DIR/libcudnn_static.a
$NVPRUNE "$GENCODE_CUDNN" $CUDA_LIB_DIR/libcublas_static.a -o $CUDA_LIB_DIR/libcublas_static.a
$NVPRUNE "$GENCODE_CUDNN" $CUDA_LIB_DIR/libcublasLt_static.a -o $CUDA_LIB_DIR/libcublasLt_static.a
}
# idiomatic parameter and option handling in sh
while test $# -gt 0
do
case "$1" in
9.2) install_92; prune_92
;;
10.0) install_100; prune_100
;;
10.1) install_101; prune_101
;;
*) echo "bad argument $1"; exit 1
;;
esac
shift
done
|
#!/bin/bash
function docker_tag_exists() {
EXISTS=$(curl -s https://hub.docker.com/v2/repositories/$1/tags/?page_size=10000 | jq -r "[.results | .[] | .name == \"$2\"] | any")
test $EXISTS = true
}
if docker_tag_exists svenruppert/maven-3.2.5-adopt 1.8.0-192; then
echo skip building, image already existing - svenruppert/maven-3.2.5-adopt 1.8.0-192
else
echo start building the images
docker build -t svenruppert/maven-3.2.5-adopt .
docker tag svenruppert/maven-3.2.5-adopt:latest svenruppert/maven-3.2.5-adopt:1.8.0-192
docker push svenruppert/maven-3.2.5-adopt:1.8.0-192
fi
docker image rm svenruppert/maven-3.2.5-adopt:latest
docker image rm svenruppert/maven-3.2.5-adopt:1.8.0-192
|
export interface IUserBoxComponentState {
/**
* Create new circle button is disabled {true} or not {false}
*
* @type {boolean}
* @memberof IUserBoxComponentState
*/
disabledCreateCircle: boolean
/**
* The button of add user in a circle is disabled {true} or not {false}
*
* @type {boolean}
* @memberof IUserBoxComponentState
*/
disabledAddToCircle: boolean
/**
* Circle name
*
* @type {string}
* @memberof IUserBoxComponentState
*/
circleName: string
/**
* Keep element
*
* @type {*}
* @memberof IUserBoxComponentState
*/
anchorEl?: any
/**
* Whether current user changed the selected circles for referer user
*
*/
disabledDoneCircles: boolean
/**
* Whether user created circle which already existed
*
*/
disableAlert: boolean
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.