text
stringlengths 27
775k
|
|---|
module Main where
main :: IO ()
main = do
contents <- readFile "input1"
let strings = lines contents
nums = map (read :: String -> Int) strings
part1 = sum $ launch <$> nums
part2 = sum $ concatMap (\x -> drop 1 $ takeWhile (> 0) $ iterate launch x) nums
print part1
print part2
launch n = (floor $ fromIntegral (n `div` 3)) - 2
|
using System;
namespace SampleLibrary1 {
public class Entity1 {
public string Data1 { get; set; }
}
}
|
import React from "react";
import ReactTypingEffect from 'react-typing-effect';
const typewriter = () => {
return (
<ReactTypingEffect
text={["Full Stack Developer.", "Budding coder", "Innovative creator"]}
cursorRenderer={cursor => <h1>{cursor}</h1>}
style={{color: "#f15bb5", fontSize: "2em", fontWeight:"bolder"}}
/>
);
};
export default typewriter;
|
package eu.gir.girsignals.blocks.signals;
import eu.gir.girsignals.EnumSignals.HP;
import eu.gir.girsignals.EnumSignals.MAST_SIGN;
import eu.gir.girsignals.EnumSignals.VR;
import eu.gir.girsignals.EnumSignals.ZS32;
import eu.gir.girsignals.SEProperty;
import eu.gir.girsignals.SEProperty.ChangeableStage;
import eu.gir.girsignals.blocks.Signal;
import eu.gir.girsignals.init.GIRItems;
import net.minecraft.block.state.IBlockState;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.IBlockAccess;
public class SignalHV extends Signal {
public SignalHV() {
super(builder(GIRItems.PLACEMENT_TOOL, "HV").height(6).signHeight(2.775f).build());
}
public static final SEProperty<HP> STOPSIGNAL = SEProperty.of("stopsignal", HP.OFF);
public static final SEProperty<VR> DISTANTSIGNAL = SEProperty.of("distantsignal", VR.OFF);
public static final SEProperty<Boolean> VR_LIGHT = SEProperty.of("vrlight", false);
public static final SEProperty<Boolean> NE2 = SEProperty.of("ne2", false, ChangeableStage.GUISTAGE);
public static final SEProperty<MAST_SIGN> MASTSIGN = SEProperty.of("mastsign", MAST_SIGN.OFF,
ChangeableStage.GUISTAGE);
public static final SEProperty<ZS32> ZS3 = SEProperty.of("zs3", ZS32.OFF);
public static final SEProperty<ZS32> ZS3V = SEProperty.of("zs3v", ZS32.OFF);
public static final SEProperty<Boolean> ZS1 = SEProperty.of("zs1", false);
public static final SEProperty<Boolean> ZS7 = SEProperty.of("zs7", false);
@Override
public boolean hasCostumColor() {
return true;
}
@Override
public int colorMultiplier(IBlockState state, IBlockAccess worldIn, BlockPos pos, int tintIndex) {
return tintIndex == 1 ? 0xFF9323 : 0xFFFFFF;
}
}
|
namespace Hierarchy02
{
class ContractEmployee : Employee
{
private float payPerHour;
private string contractPeriod;
public ContractEmployee(int id, string name, float payPerHour, string contractPeriod) : base(id, name)
{
this.payPerHour = payPerHour;
this.contractPeriod = contractPeriod;
}
public override string ToString()
{
return $"Id: {id} \nName: {name} \nPay Per Hour: {payPerHour} \nContract Period: {contractPeriod}";
}
}
}
|
/**
* @license
* Copyright 2016 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.
*/
goog.provide('shaka.offline.StorageEngineFactory');
goog.require('shaka.offline.DBEngine');
goog.require('shaka.offline.IStorageEngine');
goog.require('shaka.util.Error');
/**
* @namespace shaka.offline.StorageEngineFactory
*/
/**
* @const{string}
* @private
*/
shaka.offline.StorageEngineFactory.NAME_ = 'shaka_offline_db';
/**
* Determines if this platform supports any form of storage engine.
* @return {boolean}
*/
shaka.offline.StorageEngineFactory.isSupported = function() {
return shaka.offline.DBEngine.isSupported();
};
/**
* Create a new instance of the supported storage engine. The created instance
* will be initialized.
* @return {!Promise<!shaka.offline.IStorageEngine>}
*/
shaka.offline.StorageEngineFactory.createStorageEngine = function() {
const name = shaka.offline.StorageEngineFactory.NAME_;
return shaka.offline.StorageEngineFactory.ensureSupport().then(() => {
let engine = new shaka.offline.DBEngine(name);
return engine.init().then(() => engine);
});
};
/**
* Delete the storage engine and all its contents. This operation is
* non-reversible.
* @return {!Promise}
*/
shaka.offline.StorageEngineFactory.deleteStorage = function() {
const name = shaka.offline.StorageEngineFactory.NAME_;
return shaka.offline.StorageEngineFactory.ensureSupport().then(() => {
return shaka.offline.DBEngine.deleteDatabase(name);
});
};
/** @return {!Promise} */
shaka.offline.StorageEngineFactory.ensureSupport = function() {
// Use our method to check in case it was replaced.
let support = shaka.offline.StorageEngineFactory.isSupported();
if (support) {
return Promise.resolve();
} else {
return Promise.reject(new shaka.util.Error(
shaka.util.Error.Severity.CRITICAL,
shaka.util.Error.Category.STORAGE,
shaka.util.Error.Code.STORAGE_NOT_SUPPORTED));
}
};
|
(INSERT-OF-RKEYS-OF-SET-FIELD-SAME
(73 4 (:REWRITE SET::INSERT-IDENTITY))
(73 1 (:DEFINITION SET::DELETE))
(49 1 (:REWRITE IN-OF-IF))
(35 2 (:REWRITE SET::DELETE-NONMEMBER-CANCEL))
(31 31 (:TYPE-PRESCRIPTION SET::IN-TYPE))
(28 8 (:REWRITE SET::IN-TAIL))
(27 2 (:REWRITE SET::DELETE-IN))
(24 24 (:TYPE-PRESCRIPTION SET::EMPTY-TYPE))
(23 1 (:REWRITE SET::IN-INSERT))
(20 20 (:REWRITE SET::SUBSET-IN))
(15 5 (:REWRITE JVM::IN-OF-RKEYS-WHEN-G-REV))
(15 1 (:REWRITE EQUAL-EQUAL-A-HEAD-HACK))
(14 7 (:REWRITE G-WHEN-NOT-IN-RKEYS-CHEAP))
(14 4 (:REWRITE SET::INSERT-WHEN-EMPTY))
(12 4 (:REWRITE INSERT-WHEN-EMPTY))
(11 4 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(8 4 (:REWRITE SET::TAIL-WHEN-EMPTY))
(7 2 (:REWRITE SET::NEVER-IN-EMPTY))
(6 2 (:REWRITE SET::DELETE-PRESERVES-EMPTY))
(6 1 (:REWRITE S-SAME-G-STRONG))
(5 5 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-TWO))
(5 5 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-MAIN))
(5 5 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-ALT))
(5 5 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL))
(5 5 (:REWRITE JVM::IN-OF-RKEYS-WHEN-G))
(4 4 (:TYPE-PRESCRIPTION BOOLEANP))
(4 4 (:REWRITE SET::SUBSET-IN-2))
(4 4 (:REWRITE CLR-DIFFERENTIAL))
(4 1 (:REWRITE SET-FIELD-OF-GET-FIELD-SAME-ERIC-2))
(2 2 (:REWRITE SET::TAIL-PRESERVES-EMPTY))
(2 2 (:REWRITE SET::SUBSET-IN-2-ALT))
(2 2 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(2 2 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(2 2 (:REWRITE SET::IN-TAIL-OR-HEAD))
(2 2 (:REWRITE SET::HEAD-WHEN-EMPTY))
(2 2 (:REWRITE HEAD-WHEN-EMPTY))
(2 2 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(2 2 (:REWRITE EQUAL-WHEN-BVLT))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(2 2 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(2 2 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(1 1 (:REWRITE SET::HEAD-UNIQUE))
)
(>=-LEN-OF-LEN-SAME
(13 3 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
(12 8 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(11 9 (:REWRITE DEFAULT-+-2))
(9 9 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(9 9 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(9 9 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(9 9 (:REWRITE LEN-WHEN-BV-ARRAYP))
(9 9 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(9 9 (:REWRITE DEFAULT-+-1))
(8 8 (:REWRITE DEFAULT-CDR))
(7 7 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(7 7 (:REWRITE USE-ALL-CONSP-2))
(7 7 (:REWRITE USE-ALL-CONSP))
(7 7 (:REWRITE CONSP-WHEN-LEN-GREATER))
(7 7 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(2 2 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(2 2 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(2 2 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(2 2 (:REWRITE EQUAL-WHEN-BVLT))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(2 2 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(2 2 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(2 2 (:REWRITE EQUAL-OF-0-WHEN-BVLT))
(2 2 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(2 2 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(2 2 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(2 2 (:REWRITE CLR-DIFFERENTIAL))
)
(>=-LEN-REWRITE
(26 18 (:REWRITE DEFAULT-<-1))
(21 21 (:REWRITE BOUND-WHEN-USB))
(21 21 (:REWRITE <-WHEN-BVLT))
(18 18 (:REWRITE USE-ALL-<=-2))
(18 18 (:REWRITE USE-ALL-<=))
(18 18 (:REWRITE USE-ALL-<-2))
(18 18 (:REWRITE USE-ALL-<))
(18 18 (:REWRITE DEFAULT-<-2))
(18 18 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(18 18 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(13 7 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(12 12 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(12 12 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(12 12 (:REWRITE LEN-WHEN-BV-ARRAYP))
(12 12 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(9 9 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(9 9 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
(9 9 (:REWRITE DEFAULT-+-2))
(9 9 (:REWRITE DEFAULT-+-1))
(8 8 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(8 8 (:REWRITE USE-ALL-CONSP-2))
(8 8 (:REWRITE USE-ALL-CONSP))
(8 8 (:REWRITE SIZE-NON-NEGATIVE-WHEN-UNSIGNED-BYTE-P-FREE))
(8 8 (:REWRITE CONSP-WHEN-LEN-GREATER))
(8 8 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(7 7 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(7 7 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(7 7 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(7 7 (:REWRITE EQUAL-WHEN-BVLT))
(7 7 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(7 7 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(7 7 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(7 7 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(7 7 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(7 7 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(7 7 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(7 7 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(7 7 (:REWRITE DEFAULT-CDR))
(6 6 (:REWRITE NONNEG-WHEN-DARGP-LESS-THAN))
(5 5 (:REWRITE EQUAL-OF-0-WHEN-BVLT))
(5 5 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(5 5 (:REWRITE CLR-DIFFERENTIAL))
(1 1 (:REWRITE <-OF-0-WHEN-<-FREE))
)
(ALL->=-LEN-WHEN-ITEMS-HAVE-LEN
(21 9 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(14 14 (:REWRITE USE-ALL-<=-2))
(14 14 (:REWRITE USE-ALL-<=))
(14 14 (:REWRITE USE-ALL-<-2))
(14 14 (:REWRITE USE-ALL-<))
(14 14 (:REWRITE DEFAULT-<-2))
(14 14 (:REWRITE DEFAULT-<-1))
(14 14 (:REWRITE BOUND-WHEN-USB))
(14 14 (:REWRITE ARITH-HACK-CHEAP))
(14 14 (:REWRITE <-WHEN-BVLT))
(14 14 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(14 14 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(12 6 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(9 9 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(9 9 (:REWRITE USE-ALL-CONSP-2))
(9 9 (:REWRITE USE-ALL-CONSP))
(9 9 (:REWRITE CONSP-WHEN-LEN-GREATER))
(9 9 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(8 8 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(8 8 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
(8 4 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(6 6 (:TYPE-PRESCRIPTION NAT-LISTP))
(6 6 (:REWRITE DEFAULT-CAR))
(5 3 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(4 4 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(4 4 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(4 4 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(4 4 (:REWRITE SIZE-NON-NEGATIVE-WHEN-UNSIGNED-BYTE-P-FREE))
(4 4 (:REWRITE NONNEG-WHEN-DARGP-LESS-THAN))
(3 3 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(3 3 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(3 3 (:REWRITE LEN-WHEN-BV-ARRAYP))
(3 3 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(3 3 (:REWRITE DEFAULT-CDR))
(1 1 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
)
(ALISTP-WHEN-ITEMS-HAVE-LEN
(176 88 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(88 88 (:TYPE-PRESCRIPTION NAT-LISTP))
(64 2 (:REWRITE ALISTP-OF-CDR))
(50 7 (:REWRITE ALISTP-WHEN-HONS-DUPLICITY-ALIST-P))
(35 7 (:REWRITE RULE-ALISTP-MEANS-ALISTP))
(29 7 (:REWRITE HONS-DUPLICITY-ALIST-P-WHEN-NOT-CONSP))
(21 21 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(21 21 (:REWRITE USE-ALL-CONSP-2))
(21 21 (:REWRITE USE-ALL-CONSP))
(21 21 (:REWRITE CONSP-WHEN-LEN-GREATER))
(21 21 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(21 7 (:REWRITE RULE-LIMITSP-FORWARD-TO-ALISTP))
(21 7 (:REWRITE DAG-VARIABLE-ALISTP-FORWARD-TO-ALIST))
(21 7 (:REWRITE JVM::ALISTP-WHEN-METHOD-PROGRAMP))
(15 5 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(15 5 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(14 14 (:TYPE-PRESCRIPTION RULE-LIMITSP))
(14 14 (:TYPE-PRESCRIPTION RULE-ALISTP))
(14 14 (:TYPE-PRESCRIPTION JVM::METHOD-PROGRAMP))
(14 14 (:TYPE-PRESCRIPTION HONS-DUPLICITY-ALIST-P))
(14 14 (:TYPE-PRESCRIPTION DAG-VARIABLE-ALISTP))
(14 7 (:REWRITE ALISTP-WHEN-PSEUDO-TERM-ALISTP-CHEAP))
(14 7 (:REWRITE ALISTP-WHEN-NODENUM-TYPE-ALISTP-CHEAP))
(12 6 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(11 11 (:REWRITE DEFAULT-CAR))
(10 10 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(10 10 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(10 5 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(10 2 (:REWRITE ITEMS-HAVE-LEN-OF-CDR))
(8 4 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(7 7 (:TYPE-PRESCRIPTION PSEUDO-TERM-ALISTP))
(7 7 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(7 7 (:TYPE-PRESCRIPTION NODENUM-TYPE-ALISTP))
(7 7 (:REWRITE USE-ALL-RULE-ALISTP-2))
(7 7 (:REWRITE USE-ALL-RULE-ALISTP))
(7 7 (:REWRITE USE-ALL-ALISTP-2))
(7 7 (:REWRITE USE-ALL-ALISTP))
(7 7 (:REWRITE NODE-REPLACEMENT-ALISTP-FORWARD-TO-ALISTP))
(7 7 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(7 7 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(7 7 (:REWRITE LEN-WHEN-BV-ARRAYP))
(7 7 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(7 7 (:REWRITE ALISTP-WHEN-PSEUDO-DAGP-AUX))
(7 7 (:REWRITE JVM::ALISTP-WHEN-JVM-INSTRUCTIONS-OKAYP))
(7 7 (:REWRITE ALISTP-WHEN-BOUNDED-NATP-ALISTP))
(6 6 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(6 6 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(6 5 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(5 5 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(5 5 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(5 5 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(5 5 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(4 4 (:REWRITE USE-ALL-<=-2))
(4 4 (:REWRITE USE-ALL-<=))
(4 4 (:REWRITE USE-ALL-<-2))
(4 4 (:REWRITE USE-ALL-<))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(4 4 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(4 4 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(4 4 (:REWRITE EQUAL-WHEN-BVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(4 4 (:REWRITE DEFAULT-CDR))
(4 4 (:REWRITE DEFAULT-<-2))
(4 4 (:REWRITE DEFAULT-<-1))
(4 4 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(4 4 (:REWRITE CLR-DIFFERENTIAL))
(4 4 (:REWRITE BOUND-WHEN-USB))
(4 4 (:REWRITE ARITH-HACK-CHEAP))
(4 4 (:REWRITE <-WHEN-BVLT))
(4 4 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(4 4 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(4 4 (:REWRITE <-OF-0-WHEN-<-FREE))
(3 3 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(3 3 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
)
(MISSING-CLASSES
(315 162 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(153 153 (:TYPE-PRESCRIPTION NAT-LISTP))
)
(RUN-STATIC-INITIALIZER-FOR-NEXT-CLASS)
(INITIALIZE-CLASS)
(INITIALIZE-CLASSES)
(INITIALIZE-CLASSES-IN-ARBITRARY-STATE-FN)
(SYMBOLIC-NEW-ADDRESS-IN-HEAPP
(22 11 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(12 6 (:TYPE-PRESCRIPTION INTEGERP-OF-NTH-WHEN-ALL-NATP))
(11 11 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(6 6 (:TYPE-PRESCRIPTION ALL-NATP))
)
(ALL-SYMBOLIC-NEW-ADDRESS-IN-HEAPP
(292 1 (:DEFINITION PSEUDO-TERMP))
(49 1 (:DEFINITION SYMBOL-LISTP))
(47 3 (:DEFINITION LENGTH))
(40 20 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(22 14 (:REWRITE DEFAULT-CAR))
(20 20 (:TYPE-PRESCRIPTION NAT-LISTP))
(18 11 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(17 4 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(16 1 (:REWRITE LEN-OF-CDR))
(13 11 (:REWRITE DEFAULT-CDR))
(10 5 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(9 6 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(8 2 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(7 1 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(6 6 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(6 6 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(6 6 (:REWRITE LEN-WHEN-BV-ARRAYP))
(6 6 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(6 6 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(6 3 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(6 3 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(6 1 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(6 1 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
(4 4 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(4 4 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(4 4 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(4 4 (:REWRITE USE-ALL-CONSP-2))
(4 4 (:REWRITE USE-ALL-CONSP))
(4 4 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(4 4 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(4 4 (:REWRITE EQUAL-WHEN-BVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(4 4 (:REWRITE CONSP-WHEN-LEN-GREATER))
(4 4 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(4 4 (:REWRITE CLR-DIFFERENTIAL))
(4 2 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(4 2 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(4 2 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(3 3 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(3 3 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(3 1 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(3 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(2 2 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(2 2 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(2 2 (:TYPE-PRESCRIPTION BOOLEANP))
(2 2 (:TYPE-PRESCRIPTION AXE-TREEP))
(2 2 (:REWRITE WFR-HACK5))
(2 2 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(2 2 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(2 2 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(2 2 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(2 1 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(2 1 (:REWRITE SYMBOL-LISTP-OF-CADR-OF-CAR-WHEN-PSEUDO-TERMP-CHEAP))
(2 1 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(2 1 (:REWRITE DEFAULT-+-2))
(2 1 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(2 1 (:REWRITE STR::COERCE-TO-LIST-REMOVAL))
(1 1 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(1 1 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(1 1 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(1 1 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(1 1 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(1 1 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE EQUAL-OF-LEN-AND-0))
(1 1 (:REWRITE DEFAULT-+-1))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
)
(SYMBOLIC-SET-FIELD-NESTP
(698 14 (:DEFINITION SYMBOL-LISTP))
(694 45 (:DEFINITION LENGTH))
(429 238 (:REWRITE DEFAULT-CAR))
(374 207 (:REWRITE DEFAULT-CDR))
(341 207 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(285 77 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(248 17 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(183 141 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(165 21 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(145 145 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(136 31 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(114 114 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(114 114 (:REWRITE USE-ALL-CONSP-2))
(114 114 (:REWRITE USE-ALL-CONSP))
(114 114 (:REWRITE CONSP-WHEN-LEN-GREATER))
(110 110 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(109 109 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(109 109 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(109 109 (:REWRITE LEN-WHEN-BV-ARRAYP))
(109 109 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(103 103 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(102 34 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(94 52 (:REWRITE DEFAULT-+-2))
(80 40 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(77 77 (:REWRITE CLR-DIFFERENTIAL))
(74 74 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(74 74 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(74 74 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(74 74 (:REWRITE EQUAL-WHEN-BVLT))
(74 74 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(74 74 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(74 74 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(74 74 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(74 74 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(74 74 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(74 74 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(74 74 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(74 74 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(70 35 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(68 34 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(63 21 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(62 62 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(59 59 (:REWRITE WFR-HACK5))
(59 59 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(54 54 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(52 52 (:REWRITE DEFAULT-+-1))
(50 25 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(50 25 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(46 2 (:LINEAR LEN-OF-CDR-LINEAR-STRONG))
(42 42 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(42 42 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(42 42 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(42 42 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(42 21 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(42 2 (:LINEAR LEN-OF-CDR-LINEAR))
(40 40 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(40 10 (:REWRITE FOLD-CONSTS-IN-+))
(35 35 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(35 35 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(35 35 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(34 17 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(34 17 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(32 32 (:TYPE-PRESCRIPTION BOOLEANP))
(31 31 (:TYPE-PRESCRIPTION AXE-TREEP))
(31 31 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(28 14 (:REWRITE SYMBOL-LISTP-OF-CADR-OF-CAR-WHEN-PSEUDO-TERMP-CHEAP))
(28 14 (:REWRITE STR::COERCE-TO-LIST-REMOVAL))
(24 12 (:REWRITE ACL2-COUNT-WHEN-STRING))
(21 21 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(21 21 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(21 21 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(21 21 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(21 21 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(20 20 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(18 18 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(18 1 (:REWRITE ACL2-COUNT-WHEN-MEMBER))
(17 17 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(16 1 (:REWRITE MEMBER-EQUAL-BECOMES-MEMBERP))
(14 14 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(14 14 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(14 14 (:REWRITE EQUAL-OF-LEN-AND-0))
(8 8 (:LINEAR ACL2-COUNT-WHEN-MEMBER))
(4 4 (:TYPE-PRESCRIPTION MEMBERP))
(3 1 (:REWRITE ARITH-HACK-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE DEFAULT-<-2))
(2 1 (:REWRITE DEFAULT-<-1))
(1 1 (:TYPE-PRESCRIPTION MEMBER-EQUAL))
(1 1 (:REWRITE USE-ALL-<=-2))
(1 1 (:REWRITE USE-ALL-<=))
(1 1 (:REWRITE USE-ALL-<-2))
(1 1 (:REWRITE USE-ALL-<))
(1 1 (:REWRITE NOT-MEMBERP-WHEN-MEMBERP-OF-TAKE))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-2))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-1))
(1 1 (:REWRITE MEMBERP-WHEN-SINGLETON-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-EQUAL-OF-CAR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-CONS-OF-CDR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-FIRSTN))
(1 1 (:REWRITE MEMBERP-OF-CONSTANT-WHEN-NOT-MEMBER-OF-CONSTANT))
(1 1 (:REWRITE BOUND-WHEN-USB))
(1 1 (:REWRITE <-WHEN-BVLT))
(1 1 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(1 1 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
)
(GET-HEAP-TRIPLES-FROM-SYMBOLIC-SET-FIELD-NEST
(784 288 (:REWRITE DEFAULT-CDR))
(667 18 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(640 13 (:DEFINITION SYMBOL-LISTP))
(583 267 (:REWRITE DEFAULT-CAR))
(490 288 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(377 110 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(321 34 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(235 235 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(219 73 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(214 214 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(207 207 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(207 207 (:REWRITE USE-ALL-CONSP-2))
(207 207 (:REWRITE USE-ALL-CONSP))
(207 207 (:REWRITE CONSP-WHEN-LEN-GREATER))
(186 154 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(183 183 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(131 73 (:REWRITE DEFAULT-+-2))
(122 122 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(122 122 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(122 122 (:REWRITE LEN-WHEN-BV-ARRAYP))
(122 122 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(116 31 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(110 110 (:REWRITE CLR-DIFFERENTIAL))
(104 104 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(104 104 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(104 104 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(104 104 (:REWRITE EQUAL-WHEN-BVLT))
(104 104 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(104 104 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(104 104 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(104 104 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(104 104 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(104 104 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(104 104 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(104 104 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(104 104 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(102 34 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(79 79 (:REWRITE WFR-HACK5))
(79 79 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(74 73 (:REWRITE DEFAULT-+-1))
(68 68 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(68 34 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(68 34 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(68 34 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(62 31 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(55 55 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(55 55 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(52 52 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(48 48 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(48 24 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(46 46 (:TYPE-PRESCRIPTION BOOLEANP))
(39 39 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(36 18 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(34 34 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(34 34 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(34 34 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(34 34 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(34 34 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(34 34 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(34 34 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(34 34 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(34 17 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(31 31 (:TYPE-PRESCRIPTION AXE-TREEP))
(31 31 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(31 31 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(31 13 (:REWRITE ACL2-COUNT-WHEN-STRING))
(26 26 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(21 21 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(18 1 (:REWRITE ACL2-COUNT-WHEN-MEMBER))
(17 17 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(16 1 (:REWRITE MEMBER-EQUAL-BECOMES-MEMBERP))
(14 14 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(14 14 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(8 8 (:LINEAR ACL2-COUNT-WHEN-MEMBER))
(4 4 (:TYPE-PRESCRIPTION MEMBERP))
(3 3 (:REWRITE LEN-OF-CDDR-WHEN-EQUAL-OF-LEN))
(3 3 (:REWRITE EQUAL-OF-0-WHEN-BVLT))
(3 1 (:REWRITE ARITH-HACK-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE DEFAULT-<-2))
(2 1 (:REWRITE DEFAULT-<-1))
(1 1 (:TYPE-PRESCRIPTION MEMBER-EQUAL))
(1 1 (:REWRITE USE-ALL-<=-2))
(1 1 (:REWRITE USE-ALL-<=))
(1 1 (:REWRITE USE-ALL-<-2))
(1 1 (:REWRITE USE-ALL-<))
(1 1 (:REWRITE NOT-MEMBERP-WHEN-MEMBERP-OF-TAKE))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-2))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-1))
(1 1 (:REWRITE MEMBERP-WHEN-SINGLETON-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-EQUAL-OF-CAR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-CONS-OF-CDR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-FIRSTN))
(1 1 (:REWRITE MEMBERP-OF-CONSTANT-WHEN-NOT-MEMBER-OF-CONSTANT))
(1 1 (:REWRITE BOUND-WHEN-USB))
(1 1 (:REWRITE <-WHEN-BVLT))
(1 1 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(1 1 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
)
(SYMBOLIC-SET-STATIC-FIELD-NESTP
(553 36 (:DEFINITION LENGTH))
(551 11 (:DEFINITION SYMBOL-LISTP))
(485 217 (:REWRITE DEFAULT-CAR))
(450 236 (:REWRITE DEFAULT-CDR))
(355 236 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(258 69 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(246 19 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(222 189 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(171 22 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(150 150 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(150 150 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(150 150 (:REWRITE LEN-WHEN-BV-ARRAYP))
(150 150 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(138 138 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(138 138 (:REWRITE USE-ALL-CONSP-2))
(138 138 (:REWRITE USE-ALL-CONSP))
(138 138 (:REWRITE CONSP-WHEN-LEN-GREATER))
(114 114 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(112 74 (:REWRITE DEFAULT-+-2))
(112 25 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(105 35 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(74 74 (:REWRITE DEFAULT-+-1))
(73 73 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(73 73 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(69 69 (:REWRITE CLR-DIFFERENTIAL))
(66 66 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(66 66 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(66 66 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(66 66 (:REWRITE EQUAL-WHEN-BVLT))
(66 66 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(66 66 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(66 66 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(66 66 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(66 66 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(66 66 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(66 66 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(66 66 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(66 66 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(66 22 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(64 32 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(60 30 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(59 59 (:REWRITE WFR-HACK5))
(59 59 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(58 29 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(53 53 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(52 26 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(52 26 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(44 44 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(44 22 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(41 41 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(40 10 (:REWRITE FOLD-CONSTS-IN-+))
(38 19 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(33 33 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(30 30 (:TYPE-PRESCRIPTION BOOLEANP))
(30 30 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(29 29 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(29 29 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(29 29 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(28 14 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(25 25 (:TYPE-PRESCRIPTION AXE-TREEP))
(25 25 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(24 12 (:REWRITE ACL2-COUNT-WHEN-STRING))
(22 22 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(22 22 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(22 22 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(22 22 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(22 22 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(22 11 (:REWRITE SYMBOL-LISTP-OF-CADR-OF-CAR-WHEN-PSEUDO-TERMP-CHEAP))
(22 11 (:REWRITE STR::COERCE-TO-LIST-REMOVAL))
(19 19 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(18 1 (:REWRITE ACL2-COUNT-WHEN-MEMBER))
(17 17 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(16 1 (:REWRITE MEMBER-EQUAL-BECOMES-MEMBERP))
(14 14 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(11 11 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(11 11 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(11 11 (:REWRITE EQUAL-OF-LEN-AND-0))
(8 8 (:LINEAR ACL2-COUNT-WHEN-MEMBER))
(4 4 (:TYPE-PRESCRIPTION MEMBERP))
(3 1 (:REWRITE ARITH-HACK-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE DEFAULT-<-2))
(2 1 (:REWRITE DEFAULT-<-1))
(1 1 (:TYPE-PRESCRIPTION MEMBER-EQUAL))
(1 1 (:REWRITE USE-ALL-<=-2))
(1 1 (:REWRITE USE-ALL-<=))
(1 1 (:REWRITE USE-ALL-<-2))
(1 1 (:REWRITE USE-ALL-<))
(1 1 (:REWRITE NOT-MEMBERP-WHEN-MEMBERP-OF-TAKE))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-2))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-1))
(1 1 (:REWRITE MEMBERP-WHEN-SINGLETON-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-EQUAL-OF-CAR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-CONS-OF-CDR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-FIRSTN))
(1 1 (:REWRITE MEMBERP-OF-CONSTANT-WHEN-NOT-MEMBER-OF-CONSTANT))
(1 1 (:REWRITE BOUND-WHEN-USB))
(1 1 (:REWRITE <-WHEN-BVLT))
(1 1 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(1 1 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
)
(GET-STATIC-FIELD-TRIPLES-FROM-SYMBOLIC-SET-STATIC-FIELD-NEST
(1010 392 (:REWRITE DEFAULT-CDR))
(859 343 (:REWRITE DEFAULT-CAR))
(777 25 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(693 14 (:DEFINITION SYMBOL-LISTP))
(641 392 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(502 137 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(459 53 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(322 322 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(306 306 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(300 100 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(292 292 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(292 292 (:REWRITE USE-ALL-CONSP-2))
(292 292 (:REWRITE USE-ALL-CONSP))
(292 292 (:REWRITE CONSP-WHEN-LEN-GREATER))
(251 251 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(249 214 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(165 165 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(165 165 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(165 165 (:REWRITE LEN-WHEN-BV-ARRAYP))
(165 165 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(159 53 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(150 91 (:REWRITE DEFAULT-+-2))
(137 137 (:REWRITE CLR-DIFFERENTIAL))
(132 34 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(130 130 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(130 130 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(130 130 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(130 130 (:REWRITE EQUAL-WHEN-BVLT))
(130 130 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(130 130 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(130 130 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(130 130 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(130 130 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(130 130 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(130 130 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(130 130 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(130 130 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(109 109 (:REWRITE WFR-HACK5))
(109 109 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(106 106 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(106 53 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(98 98 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(98 98 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(92 91 (:REWRITE DEFAULT-+-1))
(84 42 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(76 38 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(76 38 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(70 35 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(65 65 (:TYPE-PRESCRIPTION BOOLEANP))
(64 64 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(56 56 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(53 53 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(53 53 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(53 53 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(53 53 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(53 53 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(50 25 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(43 43 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(42 42 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(38 38 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(38 38 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(38 38 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(38 38 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(38 19 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(34 34 (:TYPE-PRESCRIPTION AXE-TREEP))
(34 34 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(31 13 (:REWRITE ACL2-COUNT-WHEN-STRING))
(24 24 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(19 19 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(18 1 (:REWRITE ACL2-COUNT-WHEN-MEMBER))
(16 1 (:REWRITE MEMBER-EQUAL-BECOMES-MEMBERP))
(15 15 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(15 15 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(8 8 (:LINEAR ACL2-COUNT-WHEN-MEMBER))
(4 4 (:TYPE-PRESCRIPTION MEMBERP))
(3 3 (:REWRITE LEN-OF-CDDR-WHEN-EQUAL-OF-LEN))
(3 3 (:REWRITE EQUAL-OF-0-WHEN-BVLT))
(3 1 (:REWRITE ARITH-HACK-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE DEFAULT-<-2))
(2 1 (:REWRITE DEFAULT-<-1))
(1 1 (:TYPE-PRESCRIPTION MEMBER-EQUAL))
(1 1 (:REWRITE USE-ALL-<=-2))
(1 1 (:REWRITE USE-ALL-<=))
(1 1 (:REWRITE USE-ALL-<-2))
(1 1 (:REWRITE USE-ALL-<))
(1 1 (:REWRITE NOT-MEMBERP-WHEN-MEMBERP-OF-TAKE))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-2))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-1))
(1 1 (:REWRITE MEMBERP-WHEN-SINGLETON-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-EQUAL-OF-CAR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-CONS-OF-CDR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-FIRSTN))
(1 1 (:REWRITE MEMBERP-OF-CONSTANT-WHEN-NOT-MEMBER-OF-CONSTANT))
(1 1 (:REWRITE BOUND-WHEN-USB))
(1 1 (:REWRITE <-WHEN-BVLT))
(1 1 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(1 1 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
)
(SYMBOLIC-CONSTANTP)
(SYMBOLIC-LISTP
(154 89 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(65 65 (:TYPE-PRESCRIPTION NAT-LISTP))
(46 2 (:LINEAR LEN-OF-CDR-LINEAR-STRONG))
(42 2 (:LINEAR LEN-OF-CDR-LINEAR))
(35 16 (:REWRITE DEFAULT-CDR))
(32 13 (:REWRITE DEFAULT-CAR))
(20 8 (:REWRITE ACL2-COUNT-WHEN-STRING))
(19 19 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(19 19 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(19 19 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(19 19 (:REWRITE LEN-WHEN-BV-ARRAYP))
(19 19 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(19 16 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(18 1 (:REWRITE ACL2-COUNT-WHEN-MEMBER))
(18 1 (:DEFINITION PSEUDO-TERM-LISTP))
(16 1 (:REWRITE MEMBER-EQUAL-BECOMES-MEMBERP))
(13 13 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(12 10 (:REWRITE DEFAULT-+-2))
(10 10 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(10 10 (:REWRITE USE-ALL-CONSP-2))
(10 10 (:REWRITE USE-ALL-CONSP))
(10 10 (:REWRITE DEFAULT-+-1))
(10 10 (:REWRITE CONSP-WHEN-LEN-GREATER))
(10 5 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(10 5 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(10 5 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(8 8 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(5 5 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(5 5 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(4 4 (:TYPE-PRESCRIPTION MEMBERP))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(4 4 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(4 4 (:REWRITE EQUAL-WHEN-BVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(4 4 (:REWRITE CLR-DIFFERENTIAL))
(4 4 (:LINEAR ACL2-COUNT-WHEN-MEMBER))
(4 2 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(4 2 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(3 3 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(3 1 (:REWRITE ARITH-HACK-CHEAP))
(2 2 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(2 2 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(2 2 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(2 1 (:REWRITE MEMBERP-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE DEFAULT-<-2))
(2 1 (:REWRITE DEFAULT-<-1))
(1 1 (:TYPE-PRESCRIPTION MEMBER-EQUAL))
(1 1 (:REWRITE USE-ALL-<=-2))
(1 1 (:REWRITE USE-ALL-<=))
(1 1 (:REWRITE USE-ALL-<-2))
(1 1 (:REWRITE USE-ALL-<))
(1 1 (:REWRITE NOT-MEMBERP-WHEN-MEMBERP-OF-TAKE))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-2))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-1))
(1 1 (:REWRITE MEMBERP-WHEN-SINGLETON-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-EQUAL-OF-CAR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-CONS-OF-CDR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-FIRSTN))
(1 1 (:REWRITE MEMBERP-OF-CONSTANT-WHEN-NOT-MEMBER-OF-CONSTANT))
(1 1 (:REWRITE BOUND-WHEN-USB))
(1 1 (:REWRITE <-WHEN-BVLT))
(1 1 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(1 1 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
)
(SYMBOLIC-LIST-ELEMENTS
(86 43 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(65 23 (:REWRITE DEFAULT-CDR))
(62 20 (:REWRITE DEFAULT-CAR))
(43 43 (:TYPE-PRESCRIPTION NAT-LISTP))
(34 23 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(27 9 (:REWRITE ACL2-COUNT-WHEN-STRING))
(24 4 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
(22 1 (:DEFINITION PSEUDO-TERM-LISTP))
(21 21 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(21 21 (:REWRITE USE-ALL-CONSP-2))
(21 21 (:REWRITE USE-ALL-CONSP))
(21 21 (:REWRITE CONSP-WHEN-LEN-GREATER))
(21 21 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(18 1 (:REWRITE ACL2-COUNT-WHEN-MEMBER))
(17 17 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(16 1 (:REWRITE MEMBER-EQUAL-BECOMES-MEMBERP))
(11 11 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(11 11 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(11 11 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(11 11 (:REWRITE LEN-WHEN-BV-ARRAYP))
(11 11 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(10 10 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(10 10 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(10 10 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(10 10 (:REWRITE EQUAL-WHEN-BVLT))
(10 10 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(10 10 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(10 10 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(10 10 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(10 10 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(10 10 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(10 10 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(10 10 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(10 10 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(10 10 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(10 10 (:REWRITE CLR-DIFFERENTIAL))
(10 6 (:REWRITE DEFAULT-+-2))
(10 5 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(10 5 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(10 5 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(9 1 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(7 6 (:REWRITE DEFAULT-+-1))
(6 6 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(6 3 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(6 2 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(5 5 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(5 5 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(4 4 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(4 4 (:TYPE-PRESCRIPTION MEMBERP))
(4 4 (:LINEAR ACL2-COUNT-WHEN-MEMBER))
(4 2 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(4 2 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(3 3 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(3 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(3 1 (:REWRITE ARITH-HACK-CHEAP))
(2 2 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(2 2 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(2 2 (:REWRITE WFR-HACK5))
(2 2 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(2 2 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(2 2 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(2 1 (:REWRITE MEMBERP-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE DEFAULT-<-2))
(2 1 (:REWRITE DEFAULT-<-1))
(2 1 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(1 1 (:TYPE-PRESCRIPTION MEMBER-EQUAL))
(1 1 (:REWRITE USE-ALL-<=-2))
(1 1 (:REWRITE USE-ALL-<=))
(1 1 (:REWRITE USE-ALL-<-2))
(1 1 (:REWRITE USE-ALL-<))
(1 1 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE NOT-MEMBERP-WHEN-MEMBERP-OF-TAKE))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-2))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-1))
(1 1 (:REWRITE MEMBERP-WHEN-SINGLETON-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-EQUAL-OF-CAR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-CONS-OF-CDR-CHEAP))
(1 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-FIRSTN))
(1 1 (:REWRITE MEMBERP-OF-CONSTANT-WHEN-NOT-MEMBER-OF-CONSTANT))
(1 1 (:REWRITE FOLD-CONSTS-IN-+))
(1 1 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE EQUAL-OF-LEN-AND-0))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(1 1 (:REWRITE BOUND-WHEN-USB))
(1 1 (:REWRITE <-WHEN-BVLT))
(1 1 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(1 1 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
)
(<-OF-ACL2-COUNT-OF-SYMBOLIC-LIST-ELEMENTS
(426 3 (:REWRITE ACL2-COUNT-CAR-CHAINING))
(279 6 (:REWRITE ACL2-COUNT-CDR-CHAINING))
(276 138 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(269 14 (:REWRITE ACL2-COUNT-WHEN-MEMBER))
(241 14 (:REWRITE MEMBER-EQUAL-BECOMES-MEMBERP))
(200 87 (:REWRITE ACL2-COUNT-WHEN-STRING))
(138 138 (:TYPE-PRESCRIPTION NAT-LISTP))
(138 82 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(82 82 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(82 82 (:REWRITE USE-ALL-CONSP-2))
(82 82 (:REWRITE USE-ALL-CONSP))
(82 82 (:REWRITE CONSP-WHEN-LEN-GREATER))
(82 82 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(74 74 (:LINEAR ACL2-COUNT-WHEN-MEMBER))
(65 65 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(56 56 (:TYPE-PRESCRIPTION MEMBERP))
(54 17 (:REWRITE ARITH-HACK-CHEAP))
(54 6 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(53 26 (:REWRITE DEFAULT-+-2))
(37 17 (:REWRITE DEFAULT-<-1))
(36 36 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(36 12 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(34 17 (:REWRITE DEFAULT-<-2))
(31 26 (:REWRITE DEFAULT-+-1))
(28 28 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(28 28 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(28 28 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(28 28 (:REWRITE EQUAL-WHEN-BVLT))
(28 28 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(28 28 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(28 28 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(28 28 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(28 28 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(28 28 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(28 28 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(28 28 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(28 28 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(28 28 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(28 28 (:REWRITE CLR-DIFFERENTIAL))
(28 14 (:REWRITE MEMBERP-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(28 14 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-CDR-CHEAP))
(28 14 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(25 14 (:REWRITE MEMBERP-WHEN-SINGLETON-CHEAP))
(20 14 (:REWRITE MEMBERP-WHEN-NOT-CONS-OF-CDR-CHEAP))
(20 10 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(19 19 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(19 19 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(19 19 (:REWRITE LEN-WHEN-BV-ARRAYP))
(19 19 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(18 6 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(17 17 (:TYPE-PRESCRIPTION SYMBOLIC-LIST-ELEMENTS))
(17 17 (:REWRITE USE-ALL-<=-2))
(17 17 (:REWRITE USE-ALL-<=))
(17 17 (:REWRITE USE-ALL-<-2))
(17 17 (:REWRITE USE-ALL-<))
(17 17 (:REWRITE BOUND-WHEN-USB))
(17 17 (:REWRITE <-WHEN-BVLT))
(17 17 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(17 17 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(16 16 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(14 14 (:TYPE-PRESCRIPTION MEMBER-EQUAL))
(14 14 (:REWRITE NOT-MEMBERP-WHEN-MEMBERP-OF-TAKE))
(14 14 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-2))
(14 14 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-1))
(14 14 (:REWRITE MEMBERP-WHEN-NOT-EQUAL-OF-CAR-CHEAP))
(14 14 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-FIRSTN))
(14 14 (:REWRITE MEMBERP-OF-CONSTANT-WHEN-NOT-MEMBER-OF-CONSTANT))
(12 12 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(12 6 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(8 8 (:REWRITE WFR-HACK5))
(8 8 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(6 6 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(6 6 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(5 5 (:REWRITE FOLD-CONSTS-IN-+))
(4 4 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(4 4 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(4 4 (:REWRITE EQUAL-OF-LEN-AND-0))
(2 2 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
)
(PSEUDO-TERM-LISTP-OF-SYMBOLIC-LIST-ELEMENTS
(254 127 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(249 5 (:DEFINITION SYMBOL-LISTP))
(233 15 (:DEFINITION LENGTH))
(184 89 (:REWRITE DEFAULT-CAR))
(127 127 (:TYPE-PRESCRIPTION NAT-LISTP))
(127 79 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(120 79 (:REWRITE DEFAULT-CDR))
(102 35 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(62 31 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(53 53 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(51 36 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(48 11 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(43 43 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(43 43 (:REWRITE USE-ALL-CONSP-2))
(43 43 (:REWRITE USE-ALL-CONSP))
(43 43 (:REWRITE CONSP-WHEN-LEN-GREATER))
(37 37 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(36 36 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(36 36 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(36 36 (:REWRITE LEN-WHEN-BV-ARRAYP))
(36 36 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(36 6 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(35 35 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(35 35 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(35 35 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(35 35 (:REWRITE EQUAL-WHEN-BVLT))
(35 35 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(35 35 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(35 35 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(35 35 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(35 35 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(35 35 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(35 35 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(35 35 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(35 35 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(35 35 (:REWRITE CLR-DIFFERENTIAL))
(34 34 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(34 17 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(26 13 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(24 24 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(21 21 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(20 10 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(18 18 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(18 18 (:REWRITE WFR-HACK5))
(18 18 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(18 6 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(18 6 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(18 3 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
(16 8 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(16 8 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(14 14 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(14 9 (:REWRITE DEFAULT-+-2))
(13 13 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(12 12 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(12 12 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(12 12 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(12 6 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(12 6 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(11 11 (:TYPE-PRESCRIPTION AXE-TREEP))
(11 11 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(10 10 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(10 10 (:TYPE-PRESCRIPTION BOOLEANP))
(10 10 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(10 10 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(10 5 (:REWRITE SYMBOL-LISTP-OF-CADR-OF-CAR-WHEN-PSEUDO-TERMP-CHEAP))
(10 5 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(10 5 (:REWRITE STR::COERCE-TO-LIST-REMOVAL))
(9 9 (:REWRITE DEFAULT-+-1))
(6 6 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(6 6 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(6 6 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(6 6 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(6 6 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(6 6 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(5 5 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(5 5 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(5 5 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(5 5 (:REWRITE EQUAL-OF-LEN-AND-0))
(2 1 (:TYPE-PRESCRIPTION INTEGERP-OF-NTH-WHEN-ALL-NATP))
(1 1 (:TYPE-PRESCRIPTION ALL-NATP))
)
(SUPPORTED-SCALAR-TERMP)
(ALL-SUPPORTED-SCALAR-TERMP
(292 1 (:DEFINITION PSEUDO-TERMP))
(49 1 (:DEFINITION SYMBOL-LISTP))
(47 3 (:DEFINITION LENGTH))
(40 20 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(22 14 (:REWRITE DEFAULT-CAR))
(20 20 (:TYPE-PRESCRIPTION NAT-LISTP))
(18 11 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(17 4 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(16 1 (:REWRITE LEN-OF-CDR))
(13 11 (:REWRITE DEFAULT-CDR))
(10 5 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(9 6 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(8 2 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(7 1 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(6 6 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(6 6 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(6 6 (:REWRITE LEN-WHEN-BV-ARRAYP))
(6 6 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(6 6 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(6 3 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(6 3 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(6 1 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(6 1 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
(4 4 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(4 4 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(4 4 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(4 4 (:REWRITE USE-ALL-CONSP-2))
(4 4 (:REWRITE USE-ALL-CONSP))
(4 4 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(4 4 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(4 4 (:REWRITE EQUAL-WHEN-BVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(4 4 (:REWRITE CONSP-WHEN-LEN-GREATER))
(4 4 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(4 4 (:REWRITE CLR-DIFFERENTIAL))
(4 2 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(4 2 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(4 2 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(3 3 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(3 3 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(3 1 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(3 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(2 2 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(2 2 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(2 2 (:TYPE-PRESCRIPTION BOOLEANP))
(2 2 (:TYPE-PRESCRIPTION AXE-TREEP))
(2 2 (:REWRITE WFR-HACK5))
(2 2 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(2 2 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(2 2 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(2 2 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(2 1 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(2 1 (:REWRITE SYMBOL-LISTP-OF-CADR-OF-CAR-WHEN-PSEUDO-TERMP-CHEAP))
(2 1 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(2 1 (:REWRITE DEFAULT-+-2))
(2 1 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(2 1 (:REWRITE STR::COERCE-TO-LIST-REMOVAL))
(1 1 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(1 1 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(1 1 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(1 1 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(1 1 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(1 1 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE EQUAL-OF-LEN-AND-0))
(1 1 (:REWRITE DEFAULT-+-1))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
)
(SUPPORTED-HEAP-VALUE-TERMP)
(ALL-SUPPORTED-HEAP-VALUE-TERM-IN-HEAPP
(292 1 (:DEFINITION PSEUDO-TERMP))
(49 1 (:DEFINITION SYMBOL-LISTP))
(47 3 (:DEFINITION LENGTH))
(40 20 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(22 14 (:REWRITE DEFAULT-CAR))
(20 20 (:TYPE-PRESCRIPTION NAT-LISTP))
(18 11 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(17 4 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(16 1 (:REWRITE LEN-OF-CDR))
(13 11 (:REWRITE DEFAULT-CDR))
(10 5 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(9 6 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(8 2 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(7 1 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(6 6 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(6 6 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(6 6 (:REWRITE LEN-WHEN-BV-ARRAYP))
(6 6 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(6 6 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(6 3 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(6 3 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(6 1 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(6 1 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
(4 4 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(4 4 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(4 4 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(4 4 (:REWRITE USE-ALL-CONSP-2))
(4 4 (:REWRITE USE-ALL-CONSP))
(4 4 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(4 4 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(4 4 (:REWRITE EQUAL-WHEN-BVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(4 4 (:REWRITE CONSP-WHEN-LEN-GREATER))
(4 4 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(4 4 (:REWRITE CLR-DIFFERENTIAL))
(4 2 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(4 2 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(4 2 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(3 3 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(3 3 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(3 1 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(3 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(2 2 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(2 2 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(2 2 (:TYPE-PRESCRIPTION BOOLEANP))
(2 2 (:TYPE-PRESCRIPTION AXE-TREEP))
(2 2 (:REWRITE WFR-HACK5))
(2 2 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(2 2 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(2 2 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(2 2 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(2 1 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(2 1 (:REWRITE SYMBOL-LISTP-OF-CADR-OF-CAR-WHEN-PSEUDO-TERMP-CHEAP))
(2 1 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(2 1 (:REWRITE DEFAULT-+-2))
(2 1 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(2 1 (:REWRITE STR::COERCE-TO-LIST-REMOVAL))
(1 1 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(1 1 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(1 1 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(1 1 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(1 1 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(1 1 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE EQUAL-OF-LEN-AND-0))
(1 1 (:REWRITE DEFAULT-+-1))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
)
(FILTER-NON-SUPPORTED-HEAP-VALUE-TERMS-IN-HEAPP
(292 1 (:DEFINITION PSEUDO-TERMP))
(49 1 (:DEFINITION SYMBOL-LISTP))
(47 3 (:DEFINITION LENGTH))
(42 21 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(22 14 (:REWRITE DEFAULT-CAR))
(21 21 (:TYPE-PRESCRIPTION NAT-LISTP))
(18 11 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(17 4 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(16 1 (:REWRITE LEN-OF-CDR))
(13 11 (:REWRITE DEFAULT-CDR))
(10 5 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(9 6 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(8 2 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(7 1 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(6 6 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(6 6 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(6 6 (:REWRITE LEN-WHEN-BV-ARRAYP))
(6 6 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(6 6 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(6 3 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(6 3 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(6 1 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(6 1 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
(4 4 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(4 4 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(4 4 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(4 4 (:REWRITE USE-ALL-CONSP-2))
(4 4 (:REWRITE USE-ALL-CONSP))
(4 4 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(4 4 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(4 4 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(4 4 (:REWRITE EQUAL-WHEN-BVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(4 4 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(4 4 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(4 4 (:REWRITE CONSP-WHEN-LEN-GREATER))
(4 4 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(4 4 (:REWRITE CLR-DIFFERENTIAL))
(4 2 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(4 2 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(4 2 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(3 3 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(3 3 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(3 1 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(3 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(2 2 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(2 2 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(2 2 (:TYPE-PRESCRIPTION BOOLEANP))
(2 2 (:TYPE-PRESCRIPTION AXE-TREEP))
(2 2 (:REWRITE WFR-HACK5))
(2 2 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(2 2 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(2 2 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(2 2 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(2 2 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(2 1 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(2 1 (:REWRITE SYMBOL-LISTP-OF-CADR-OF-CAR-WHEN-PSEUDO-TERMP-CHEAP))
(2 1 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(2 1 (:REWRITE DEFAULT-+-2))
(2 1 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(2 1 (:REWRITE STR::COERCE-TO-LIST-REMOVAL))
(1 1 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(1 1 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(1 1 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(1 1 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(1 1 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(1 1 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1 1 (:REWRITE EQUAL-OF-LEN-AND-0))
(1 1 (:REWRITE DEFAULT-+-1))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(1 1 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
)
(FILTER-NON-QUOTEPS
(8 4 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(6 1 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
(4 4 (:TYPE-PRESCRIPTION NAT-LISTP))
(4 2 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(2 2 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(2 2 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(2 1 (:REWRITE PSEUDO-TERMP-OF-CAR-WHEN-PSEUDO-TERM-LISTP-CHEAP))
(2 1 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(2 1 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(1 1 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(1 1 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(1 1 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(1 1 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(1 1 (:REWRITE LEN-WHEN-BV-ARRAYP))
(1 1 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(1 1 (:REWRITE DEFAULT-CDR))
(1 1 (:REWRITE DEFAULT-CAR))
(1 1 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
)
(PSEUDO-TERM-LISTP-OF-FILTER-NON-QUOTEPS
(374 187 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(187 187 (:TYPE-PRESCRIPTION NAT-LISTP))
(152 76 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(92 46 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(85 85 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(73 63 (:REWRITE DEFAULT-CAR))
(67 42 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(54 27 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP-CHEAP))
(54 27 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(53 1 (:DEFINITION SYMBOL-LISTP))
(51 3 (:DEFINITION LENGTH))
(49 9 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(47 47 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(46 46 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(46 42 (:REWRITE DEFAULT-CDR))
(34 34 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(32 32 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(32 32 (:REWRITE USE-ALL-CONSP-2))
(32 32 (:REWRITE USE-ALL-CONSP))
(32 32 (:REWRITE CONSP-WHEN-LEN-GREATER))
(30 9 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(28 28 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(27 9 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(20 20 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(20 1 (:REWRITE LEN-OF-CDR))
(19 19 (:REWRITE WFR-HACK5))
(19 19 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(18 18 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(18 9 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(18 4 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(14 11 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(11 11 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(11 11 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(11 11 (:REWRITE LEN-WHEN-BV-ARRAYP))
(11 11 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(10 10 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(9 9 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(9 9 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(9 9 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(9 9 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(9 9 (:REWRITE EQUAL-WHEN-BVLT))
(9 9 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(9 9 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(9 9 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(9 9 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(9 9 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(9 9 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(9 9 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(9 9 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(9 9 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(9 9 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(9 9 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(9 9 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(9 9 (:REWRITE CLR-DIFFERENTIAL))
(7 7 (:TYPE-PRESCRIPTION BOOLEANP))
(7 7 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(7 1 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(6 6 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(6 6 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(6 6 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(4 4 (:TYPE-PRESCRIPTION AXE-TREEP))
(4 4 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(4 4 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(4 2 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(4 2 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(3 1 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(2 2 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(2 2 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(2 2 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(2 2 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(2 2 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(2 1 (:REWRITE SYMBOL-LISTP-OF-CADR-OF-CAR-WHEN-PSEUDO-TERMP-CHEAP))
(2 1 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(2 1 (:REWRITE DEFAULT-+-2))
(2 1 (:REWRITE STR::COERCE-TO-LIST-REMOVAL))
(1 1 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(1 1 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(1 1 (:REWRITE EQUAL-OF-LEN-AND-0))
(1 1 (:REWRITE DEFAULT-+-1))
)
(ALL-BOUND-IN-HEAP
(2 1 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(1 1 (:TYPE-PRESCRIPTION NAT-LISTP))
)
(ALL-BOUND-IN-HEAP-OF-CONS
(50 10 (:REWRITE SET::IN-TAIL))
(20 20 (:TYPE-PRESCRIPTION SET::EMPTY-TYPE))
(20 20 (:REWRITE SET::SUBSET-IN))
(15 5 (:REWRITE SET::TAIL-WHEN-EMPTY))
(15 5 (:REWRITE SET::NEVER-IN-EMPTY))
(15 5 (:REWRITE JVM::IN-OF-RKEYS-WHEN-G-REV))
(10 10 (:REWRITE SET::SUBSET-IN-2))
(10 5 (:REWRITE G-WHEN-NOT-IN-RKEYS-CHEAP))
(6 3 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(5 5 (:REWRITE SET::SUBSET-IN-2-ALT))
(5 5 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-TWO))
(5 5 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-MAIN))
(5 5 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-ALT))
(5 5 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL))
(5 5 (:REWRITE JVM::IN-OF-RKEYS-WHEN-G))
(3 3 (:TYPE-PRESCRIPTION LEN))
(3 3 (:REWRITE DEFAULT-CDR))
(3 3 (:REWRITE DEFAULT-CAR))
(2 2 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(2 2 (:REWRITE USE-ALL-CONSP-2))
(2 2 (:REWRITE USE-ALL-CONSP))
(2 2 (:REWRITE CONSP-WHEN-LEN-GREATER))
(2 2 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
)
(ALL-BOUND-IN-HEAP-OF-NIL)
(ALL-BOUND-IN-HEAP$-KNOWN-BOOLEANS-JUSTIFICATION)
(NOT-IN-OF-MINUS1
(217 46 (:REWRITE SET::SUBSET-IN))
(204 10 (:REWRITE ADDRESSP-WHEN-ADDRESS-OR-NULLP-AND-NOT-NULL-REFP))
(194 10 (:REWRITE ALL-ADDRESSP-WHEN-NOT-CONSP))
(160 5 (:DEFINITION ADDRESS-OR-NULLP))
(113 5 (:REWRITE EQUAL-EQUAL-A-HEAD-HACK))
(73 19 (:REWRITE SET::IN-TAIL))
(53 14 (:REWRITE SET::EMPTY-SUBSET-2))
(51 49 (:REWRITE SET::TAIL-PRESERVES-EMPTY))
(44 37 (:REWRITE SET::TAIL-WHEN-EMPTY))
(36 10 (:REWRITE USE-ALL-ADDRESSP))
(33 1 (:DEFINITION NULL-REFP))
(28 28 (:REWRITE SET::SUBSET-TRANSITIVE))
(28 28 (:REWRITE SET::SUBSET-IN-2))
(20 10 (:REWRITE ALL-ADDRESSP-WHEN-NOT-CONSP-CHEAP))
(20 2 (:REWRITE MEMBERP-OF-SET2LIST))
(18 18 (:REWRITE HEAD-WHEN-EMPTY))
(17 17 (:REWRITE SET::HEAD-WHEN-EMPTY))
(14 14 (:REWRITE SET::SUBSET-IN-2-ALT))
(14 14 (:REWRITE SUBSET-HACK))
(14 14 (:REWRITE SET::PICK-A-POINT-SUBSET-STRATEGY))
(14 14 (:REWRITE SET::PICK-A-POINT-SUBSET-CONSTRAINT-HELPER))
(14 14 (:REWRITE SET::EMPTY-SUBSET))
(12 12 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(12 12 (:REWRITE CONSP-WHEN-LEN-GREATER))
(12 12 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(10 10 (:TYPE-PRESCRIPTION ADDRESS-OR-NULLP))
(10 10 (:REWRITE USE-ALL-ADDRESSP-2))
(10 10 (:REWRITE ADDRESSP-WHEN-IN-DOMAIN-OF-HEAPP))
(5 5 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(5 5 (:REWRITE CLR-DIFFERENTIAL))
(5 5 (:DEFINITION NULL-REF))
(4 4 (:TYPE-PRESCRIPTION MEMBERP))
(4 2 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(4 2 (:REWRITE SET::IN-HEAD))
(2 2 (:TYPE-PRESCRIPTION SET::SETP-TYPE))
(2 2 (:REWRITE SET::IN-SET))
(1 1 (:TYPE-PRESCRIPTION NULL-REFP))
(1 1 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(1 1 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(1 1 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(1 1 (:REWRITE EQUAL-WHEN-BVLT))
(1 1 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(1 1 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(1 1 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(1 1 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(1 1 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(1 1 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(1 1 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(1 1 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(1 1 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
)
(NOT-NULL-REFP-OF-NTH-WHEN-ALL-BOUND-IN-HEAP
(328 20 (:DEFINITION SET::2LIST))
(228 20 (:REWRITE SET::IN-TAIL-OR-HEAD))
(140 44 (:REWRITE SET::SUBSET-IN))
(132 5 (:REWRITE ALL-BOUND-TO-HEAP-OBJECTSP-WHEN-NOT-CONSP))
(132 5 (:REWRITE ALL-ADDRESSP-WHEN-NOT-CONSP))
(100 100 (:TYPE-PRESCRIPTION SET::EMPTY-TYPE))
(86 22 (:REWRITE SET::IN-TAIL))
(53 15 (:REWRITE SET::NEVER-IN-EMPTY))
(49 35 (:REWRITE SET::TAIL-WHEN-EMPTY))
(40 10 (:REWRITE CONSP-OF-2LIST-GEN))
(32 8 (:REWRITE SET::EMPTY-SUBSET-2))
(30 30 (:REWRITE SET::SUBSET-IN-2))
(22 22 (:REWRITE CONSP-WHEN-LEN-GREATER))
(22 22 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(21 7 (:REWRITE JVM::IN-OF-RKEYS-WHEN-G-REV))
(20 20 (:REWRITE SET::HEAD-WHEN-EMPTY))
(20 20 (:REWRITE HEAD-WHEN-EMPTY))
(19 19 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(18 9 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(16 16 (:TYPE-PRESCRIPTION SET::SUBSET-TYPE))
(16 16 (:REWRITE SET::TAIL-PRESERVES-EMPTY))
(16 16 (:REWRITE SET::SUBSET-TRANSITIVE))
(15 15 (:REWRITE SET::SUBSET-IN-2-ALT))
(14 7 (:REWRITE G-WHEN-NOT-IN-RKEYS-CHEAP))
(13 11 (:REWRITE DEFAULT-CAR))
(12 6 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(10 5 (:REWRITE ALL-BOUND-TO-HEAP-OBJECTSP-WHEN-NOT-CONSP-CHEAP))
(10 5 (:REWRITE ALL-ADDRESSP-WHEN-NOT-CONSP-CHEAP))
(9 9 (:TYPE-PRESCRIPTION NAT-LISTP))
(9 9 (:REWRITE USE-ALL-CONSP-2))
(9 9 (:REWRITE USE-ALL-CONSP))
(8 8 (:REWRITE SUBSET-HACK))
(8 8 (:REWRITE SET::PICK-A-POINT-SUBSET-STRATEGY))
(8 8 (:REWRITE SET::PICK-A-POINT-SUBSET-CONSTRAINT-HELPER))
(8 8 (:REWRITE NTH-WHEN-ALL-EQUAL$-HELPER))
(8 8 (:REWRITE NTH-WHEN-ALL-EQUAL$))
(8 8 (:REWRITE SET::EMPTY-SUBSET))
(8 6 (:REWRITE DEFAULT-CDR))
(7 7 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-TWO))
(7 7 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-MAIN))
(7 7 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-ALT))
(7 7 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL))
(7 7 (:REWRITE JVM::IN-OF-RKEYS-WHEN-G))
(6 6 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(6 6 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(6 6 (:REWRITE LEN-WHEN-BV-ARRAYP))
(6 6 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(5 5 (:REWRITE ZP-OPEN))
(5 5 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(5 5 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(5 5 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(5 5 (:REWRITE EQUAL-WHEN-BVLT))
(5 5 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(5 5 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(5 5 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(5 5 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(5 5 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(5 5 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(5 5 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(5 5 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(5 5 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(5 5 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(5 5 (:REWRITE CLR-DIFFERENTIAL))
(5 5 (:REWRITE BOUND-WHEN-USB))
(5 5 (:REWRITE <-WHEN-BVLT))
(4 4 (:REWRITE SIZE-NON-NEGATIVE-WHEN-UNSIGNED-BYTE-P-FREE))
(3 3 (:REWRITE USE-ALL-<=-2))
(3 3 (:REWRITE USE-ALL-<=))
(3 3 (:REWRITE USE-ALL-<-2))
(3 3 (:REWRITE USE-ALL-<))
(3 3 (:REWRITE NONNEG-WHEN-DARGP-LESS-THAN))
(3 3 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(3 3 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
(3 3 (:REWRITE DEFAULT-<-2))
(3 3 (:REWRITE DEFAULT-<-1))
(3 3 (:REWRITE DEFAULT-+-2))
(3 3 (:REWRITE DEFAULT-+-1))
(3 3 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(3 3 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
)
(IN-OF-NTH-NEW-AD-AND-2SET-OF-N-NEW-ADS
(2 2 (:TYPE-PRESCRIPTION N-NEW-ADS))
(2 2 (:REWRITE USE-ALL-<=-2))
(2 2 (:REWRITE USE-ALL-<=))
(2 2 (:REWRITE USE-ALL-<-2))
(2 2 (:REWRITE USE-ALL-<))
(2 2 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(2 2 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
(2 2 (:REWRITE DEFAULT-<-2))
(2 2 (:REWRITE DEFAULT-<-1))
(2 2 (:REWRITE BOUND-WHEN-USB))
(2 2 (:REWRITE ARITH-HACK-CHEAP))
(2 2 (:REWRITE <-WHEN-BVLT))
(2 2 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(2 2 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(2 1 (:REWRITE MEMBERP-WHEN-SINGLETON-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-NOT-CONSP-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-NOT-CONS-OF-CDR-CHEAP))
(2 1 (:REWRITE MEMBERP-WHEN-MEMBERP-OF-CDR-CHEAP))
(2 1 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(1 1 (:TYPE-PRESCRIPTION LEN))
(1 1 (:REWRITE USE-ALL-NATP-2))
(1 1 (:REWRITE USE-ALL-NATP))
(1 1 (:REWRITE NTH-NEW-AD-WHEN-ZP))
(1 1 (:REWRITE NOT-MEMBERP-WHEN-MEMBERP-OF-TAKE))
(1 1 (:REWRITE NOT-MEMBERP-WHEN-MEMBERP-AND-NOT-INTERSECTION-EQUAL-CHEAP))
(1 1 (:REWRITE NATP-WHEN-UNSIGNED-BYTE-P-SIZE-ARG))
(1 1 (:REWRITE NATP-WHEN-UNSIGNED-BYTE-P))
(1 1 (:REWRITE NATP-WHEN-ALL-DARGP-LESS-THAN-GEN))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-2))
(1 1 (:REWRITE MEMBERP-WHEN-SUBSETP-EQUAL-1))
(1 1 (:REWRITE MEMBERP-WHEN-NOT-EQUAL-OF-CAR-CHEAP))
(1 1 (:REWRITE MEMBERP-OF-CONSTANT-WHEN-NOT-MEMBER-OF-CONSTANT))
(1 1 (:REWRITE <-OF-0-WHEN-<-FREE))
)
(HEAP-TRIPLE-FIELDS-FOR-AD
(609 317 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(292 292 (:TYPE-PRESCRIPTION NAT-LISTP))
(190 12 (:REWRITE DEFAULT-CDR))
(60 6 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(56 28 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(43 43 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(39 13 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(39 13 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(35 12 (:REWRITE DEFAULT-CAR))
(26 26 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(26 26 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(26 13 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(20 20 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(20 20 (:REWRITE USE-ALL-CONSP-2))
(20 20 (:REWRITE USE-ALL-CONSP))
(20 20 (:REWRITE CONSP-WHEN-LEN-GREATER))
(20 20 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(20 12 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(20 8 (:REWRITE ITEMS-HAVE-LEN-WHEN-NOT-CONSP))
(15 13 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(13 13 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(13 13 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(13 13 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(12 6 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(8 8 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(8 8 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(8 8 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(8 8 (:REWRITE LEN-WHEN-BV-ARRAYP))
(8 8 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(6 6 (:TYPE-PRESCRIPTION BOOLEANP))
(6 6 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(6 6 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(6 6 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(6 6 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(6 6 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(6 6 (:REWRITE EQUAL-WHEN-BVLT))
(6 6 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(6 6 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(6 6 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(6 6 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(6 6 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(6 6 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(6 6 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(6 6 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(6 6 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(6 6 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(6 6 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(6 6 (:REWRITE CLR-DIFFERENTIAL))
(4 2 (:REWRITE IFF-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(4 2 (:REWRITE DEFAULT-+-2))
(2 2 (:REWRITE DEFAULT-+-1))
(1 1 (:REWRITE WFR-HACK5))
(1 1 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
)
(CONSTANT-VALUE-OF-FIELD
(1037 556 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(481 481 (:TYPE-PRESCRIPTION NAT-LISTP))
(468 36 (:REWRITE DEFAULT-CDR))
(123 3 (:REWRITE NOT-MYQUOTEP-WHEN-LEN-WRONG))
(93 27 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(81 12 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(75 27 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(72 24 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(70 36 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(66 19 (:REWRITE DEFAULT-CAR))
(60 60 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(54 27 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(53 53 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(48 48 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(48 48 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(48 48 (:REWRITE USE-ALL-CONSP-2))
(48 48 (:REWRITE USE-ALL-CONSP))
(48 48 (:REWRITE CONSP-WHEN-LEN-GREATER))
(48 48 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(44 2 (:LINEAR LEN-OF-CDR-LINEAR-STRONG))
(29 27 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(27 27 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(27 27 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(27 27 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(20 20 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(18 6 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(14 8 (:REWRITE ITEMS-HAVE-LEN-WHEN-NOT-CONSP))
(14 7 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(13 13 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(13 13 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(13 13 (:REWRITE LEN-WHEN-BV-ARRAYP))
(13 13 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(12 12 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(12 12 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(12 12 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(12 12 (:REWRITE EQUAL-WHEN-BVLT))
(12 12 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(12 12 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(12 12 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(12 12 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(12 12 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(12 12 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(12 12 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(12 12 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(12 12 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(12 12 (:REWRITE CLR-DIFFERENTIAL))
(9 9 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(9 9 (:TYPE-PRESCRIPTION BOOLEANP))
(7 7 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(7 7 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(6 6 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(6 3 (:REWRITE DEFAULT-+-2))
(4 4 (:REWRITE WFR-HACK5))
(4 4 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(4 2 (:REWRITE IFF-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(3 3 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(3 3 (:REWRITE MYQUOTEP-WHEN-DARGP-LESS-THAN))
(3 3 (:REWRITE MYQUOTEP-WHEN-BOUNDED-DAG-EXPRP))
(3 3 (:REWRITE MYQUOTEP-WHEN-AXE-TREEP))
(3 3 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(3 3 (:REWRITE DEFAULT-+-1))
)
(FIELD-VALS-IF-ALL-ADDRESSES-HAVE-THEM
(15638 7819 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(7819 7819 (:TYPE-PRESCRIPTION NAT-LISTP))
(5697 576 (:REWRITE DEFAULT-CAR))
(4630 646 (:REWRITE DEFAULT-CDR))
(2326 835 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(2041 344 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(1256 646 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(1145 307 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(1142 1142 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(828 828 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(828 828 (:REWRITE USE-ALL-CONSP-2))
(828 828 (:REWRITE USE-ALL-CONSP))
(828 828 (:REWRITE CONSP-WHEN-LEN-GREATER))
(828 828 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(719 307 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(696 696 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(614 307 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(426 142 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(413 413 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(412 412 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(344 344 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(344 344 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(344 344 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(344 344 (:REWRITE EQUAL-WHEN-BVLT))
(344 344 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(344 344 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(344 344 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(344 344 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(344 344 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(344 344 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(344 344 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(344 344 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(344 344 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(344 344 (:REWRITE CLR-DIFFERENTIAL))
(307 307 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(307 307 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(307 307 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(307 307 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(233 233 (:TYPE-PRESCRIPTION BOOLEANP))
(190 190 (:REWRITE WFR-HACK5))
(190 190 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(188 61 (:REWRITE ITEMS-HAVE-LEN-WHEN-NOT-CONSP))
(152 152 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(114 114 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(114 114 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(114 114 (:REWRITE LEN-WHEN-BV-ARRAYP))
(114 114 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(108 54 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(91 91 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN-STRONG))
(91 91 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(73 73 (:REWRITE MYQUOTEP-WHEN-DARGP-LESS-THAN))
(73 73 (:REWRITE MYQUOTEP-WHEN-BOUNDED-DAG-EXPRP))
(73 73 (:REWRITE MYQUOTEP-WHEN-AXE-TREEP))
(64 3 (:LINEAR LEN-OF-CDR-LINEAR-STRONG))
(59 59 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(54 54 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(54 54 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(54 54 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(20 10 (:TYPE-PRESCRIPTION INTEGERP-OF-NTH-WHEN-ALL-NATP))
(16 12 (:REWRITE DEFAULT-+-2))
(12 12 (:REWRITE DEFAULT-+-1))
(10 10 (:TYPE-PRESCRIPTION ALL-NATP))
)
(GET-FIELD-OF-ADDRESSES
(2 1 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(1 1 (:TYPE-PRESCRIPTION NAT-LISTP))
)
(GET-FIELD-OF-ADDRESSES-OF-CONS
(6 3 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(3 3 (:TYPE-PRESCRIPTION LEN))
(3 3 (:REWRITE DEFAULT-CDR))
(3 3 (:REWRITE DEFAULT-CAR))
(2 2 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(2 2 (:REWRITE USE-ALL-CONSP-2))
(2 2 (:REWRITE USE-ALL-CONSP))
(2 2 (:REWRITE CONSP-WHEN-LEN-GREATER))
(2 2 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
)
(GET-FIELD-OF-ADDRESSES-OF-NIL)
(GET-FIELD-OF-NTH
(34 16 (:REWRITE DEFAULT-CAR))
(29 29 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(27 1 (:LINEAR LEN-OF-CDR-LINEAR-STRONG))
(23 9 (:REWRITE DEFAULT-CDR))
(23 1 (:LINEAR LEN-OF-CDR-LINEAR))
(17 17 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(17 17 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(17 17 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(17 17 (:REWRITE LEN-WHEN-BV-ARRAYP))
(17 17 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(15 5 (:REWRITE <-OF-LEN-WHEN-NTH-NON-NIL))
(15 5 (:REWRITE <-OF-LEN-WHEN-INTEGERP-OF-NTH))
(11 11 (:REWRITE NTH-WHEN-ALL-EQUAL$-HELPER))
(11 11 (:REWRITE NTH-WHEN-ALL-EQUAL$))
(11 9 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(11 7 (:REWRITE DEFAULT-<-2))
(9 9 (:REWRITE DEFAULT-+-2))
(9 9 (:REWRITE DEFAULT-+-1))
(9 9 (:REWRITE BOUND-WHEN-USB))
(9 9 (:REWRITE <-WHEN-BVLT))
(7 7 (:REWRITE USE-ALL-<=-2))
(7 7 (:REWRITE USE-ALL-<=))
(7 7 (:REWRITE USE-ALL-<-2))
(7 7 (:REWRITE USE-ALL-<))
(7 7 (:REWRITE DEFAULT-<-1))
(7 7 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(7 7 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(6 6 (:REWRITE ZP-OPEN))
(6 3 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(3 3 (:TYPE-PRESCRIPTION BOOLEANP))
(3 3 (:REWRITE SIZE-NON-NEGATIVE-WHEN-UNSIGNED-BYTE-P-FREE))
(3 3 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(3 3 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(3 3 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(3 3 (:REWRITE EQUAL-WHEN-BVLT))
(3 3 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(3 3 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(3 3 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(3 3 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(3 3 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(3 3 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(3 3 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(3 3 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(3 3 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(3 3 (:REWRITE CLR-DIFFERENTIAL))
(2 2 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(2 2 (:REWRITE USE-ALL-CONSP-2))
(2 2 (:REWRITE USE-ALL-CONSP))
(2 2 (:REWRITE NONNEG-WHEN-DARGP-LESS-THAN))
(2 2 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(2 2 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
(1 1 (:REWRITE <-OF-0-WHEN-<-FREE))
)
(GET-FIELD-OF-NTH-WHEN-EQUAL-OF-GET-FIELD-OF-ADDRESSES
(49 3 (:DEFINITION NTH))
(6 6 (:REWRITE NTH-WHEN-ALL-EQUAL$-HELPER))
(6 6 (:REWRITE NTH-WHEN-ALL-EQUAL$))
(5 5 (:REWRITE CONSP-WHEN-LEN-GREATER))
(5 5 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(5 3 (:REWRITE DEFAULT-CDR))
(5 3 (:REWRITE DEFAULT-CAR))
(5 3 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(3 3 (:REWRITE ZP-OPEN))
(3 3 (:REWRITE DEFAULT-+-2))
(3 3 (:REWRITE DEFAULT-+-1))
(3 2 (:REWRITE DEFAULT-<-2))
(3 2 (:REWRITE ARITH-HACK-CHEAP))
(3 1 (:REWRITE <-OF-LEN-WHEN-NTH-NON-NIL))
(3 1 (:REWRITE <-OF-LEN-WHEN-INTEGERP-OF-NTH))
(2 2 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(2 2 (:REWRITE USE-ALL-CONSP-2))
(2 2 (:REWRITE USE-ALL-CONSP))
(2 2 (:REWRITE USE-ALL-<=-2))
(2 2 (:REWRITE USE-ALL-<=))
(2 2 (:REWRITE USE-ALL-<-2))
(2 2 (:REWRITE USE-ALL-<))
(2 2 (:REWRITE DEFAULT-<-1))
(2 2 (:REWRITE BOUND-WHEN-USB))
(2 2 (:REWRITE <-WHEN-BVLT))
(2 2 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(2 2 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(1 1 (:REWRITE SIZE-NON-NEGATIVE-WHEN-UNSIGNED-BYTE-P-FREE))
(1 1 (:REWRITE NONNEG-WHEN-DARGP-LESS-THAN))
(1 1 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(1 1 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(1 1 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(1 1 (:REWRITE LEN-WHEN-BV-ARRAYP))
(1 1 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(1 1 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(1 1 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
(1 1 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
)
(GET-FIELD-OF-NTH-WHEN-EQUAL-OF-GET-FIELD-OF-ADDRESSES-ALT
(49 3 (:DEFINITION NTH))
(6 6 (:REWRITE NTH-WHEN-ALL-EQUAL$-HELPER))
(6 6 (:REWRITE NTH-WHEN-ALL-EQUAL$))
(5 5 (:REWRITE CONSP-WHEN-LEN-GREATER))
(5 5 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(5 3 (:REWRITE DEFAULT-CDR))
(5 3 (:REWRITE DEFAULT-CAR))
(5 3 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(3 3 (:REWRITE ZP-OPEN))
(3 3 (:REWRITE DEFAULT-+-2))
(3 3 (:REWRITE DEFAULT-+-1))
(3 2 (:REWRITE DEFAULT-<-2))
(3 2 (:REWRITE ARITH-HACK-CHEAP))
(3 1 (:REWRITE <-OF-LEN-WHEN-NTH-NON-NIL))
(3 1 (:REWRITE <-OF-LEN-WHEN-INTEGERP-OF-NTH))
(2 2 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(2 2 (:REWRITE USE-ALL-CONSP-2))
(2 2 (:REWRITE USE-ALL-CONSP))
(2 2 (:REWRITE USE-ALL-<=-2))
(2 2 (:REWRITE USE-ALL-<=))
(2 2 (:REWRITE USE-ALL-<-2))
(2 2 (:REWRITE USE-ALL-<))
(2 2 (:REWRITE DEFAULT-<-1))
(2 2 (:REWRITE BOUND-WHEN-USB))
(2 2 (:REWRITE <-WHEN-BVLT))
(2 2 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(2 2 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(1 1 (:REWRITE SIZE-NON-NEGATIVE-WHEN-UNSIGNED-BYTE-P-FREE))
(1 1 (:REWRITE NONNEG-WHEN-DARGP-LESS-THAN))
(1 1 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(1 1 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(1 1 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(1 1 (:REWRITE LEN-WHEN-BV-ARRAYP))
(1 1 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(1 1 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(1 1 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
(1 1 (:LINEAR LEN-POSITIVE-WHEN-CONSP-LINEAR-CHEAP))
)
(FIELD-CLAIM-FOR-ARRAY-ITEMS)
(FIELD-CLAIMS-FOR-ARRAY-ITEMS
(2 1 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(1 1 (:TYPE-PRESCRIPTION NAT-LISTP))
)
(INITIALIZED-FIELD-ASSUMPTIONS-FOR-HEAP-ADDRESS
(52 26 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(26 26 (:TYPE-PRESCRIPTION NAT-LISTP))
)
(FLAG-INITIALIZED-FIELD-ASSUMPTIONS-FOR-HEAP-ADDRESS
(376 191 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(185 185 (:TYPE-PRESCRIPTION NAT-LISTP))
(92 46 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(46 46 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
)
(FLAG::FLAG-EQUIV-LEMMA)
(FLAG-INITIALIZED-FIELD-ASSUMPTIONS-FOR-HEAP-ADDRESS-EQUIVALENCES)
(FLAG-LEMMA-FOR-THEOREM-FOR-INITIALIZED-FIELD-ASSUMPTIONS-FOR-HEAP-ADDRESS
(48 24 (:TYPE-PRESCRIPTION NATP-OF-CAR-WHEN-NAT-LISTP-TYPE))
(24 24 (:TYPE-PRESCRIPTION NAT-LISTP))
(12 6 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(6 6 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
)
(THEOREM-FOR-INITIALIZED-FIELD-ASSUMPTIONS-FOR-HEAP-ADDRESS)
(THEOREM-FOR-INITIALIZED-FIELD-ASSUMPTIONS-FOR-HEAP-ADDRESSES)
(INITIALIZED-FIELD-ASSUMPTIONS-FOR-HEAP-ADDRESS
(7764 4203 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(7752 100 (:DEFINITION SYMBOLIC-LIST-ELEMENTS))
(7178 97 (:DEFINITION ALL-SUPPORTED-SCALAR-TERMP))
(6553 129 (:DEFINITION SYMBOL-LISTP))
(5913 171 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(4456 1964 (:TYPE-PRESCRIPTION SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-TYPE))
(4195 1058 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(3948 3948 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(3948 3948 (:REWRITE USE-ALL-CONSP-2))
(3948 3948 (:REWRITE USE-ALL-CONSP))
(3948 3948 (:REWRITE CONSP-WHEN-LEN-GREATER))
(3351 1262 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(3142 1058 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(3109 544 (:REWRITE STRIP-CADDRS-WHEN-NOT-CONSP))
(3024 3024 (:TYPE-PRESCRIPTION SYMBOL-TERM-ALISTP))
(2786 2786 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(2495 1 (:DEFINITION INITIALIZED-FIELD-ASSUMPTIONS-FOR-HEAP-ADDRESS))
(2220 5 (:DEFINITION FIELD-CLAIMS-FOR-ARRAY-ITEMS))
(2167 2167 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(2116 1058 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(2084 2084 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(1948 5 (:DEFINITION FIELD-CLAIM-FOR-ARRAY-ITEMS))
(1858 5 (:DEFINITION FIELD-VALS-IF-ALL-ADDRESSES-HAVE-THEM))
(1648 5 (:DEFINITION CONSTANT-VALUE-OF-FIELD))
(1380 297 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(1262 1262 (:REWRITE CLR-DIFFERENTIAL))
(1220 1220 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(1220 1220 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(1220 1220 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(1220 1220 (:REWRITE EQUAL-WHEN-BVLT))
(1220 1220 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(1220 1220 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(1220 1220 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(1220 1220 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(1220 1220 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(1220 1220 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(1220 1220 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(1220 1220 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(1220 1220 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(1126 563 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(1073 1073 (:REWRITE WFR-HACK5))
(1073 1073 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(1060 1058 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(1058 1058 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(1058 1058 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(1058 1058 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(1053 351 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(971 971 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(971 971 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(971 971 (:REWRITE LEN-WHEN-BV-ARRAYP))
(971 971 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(748 748 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(696 348 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(623 623 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(596 298 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(574 302 (:REWRITE DEFAULT-+-2))
(563 563 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(541 541 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(513 513 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(498 8 (:DEFINITION QUOTEP))
(485 5 (:DEFINITION MYQUOTEP))
(450 225 (:REWRITE JVM::MEMBER-WHEN-NOT-MEMBERP-OF-CDR-CHEAP))
(407 407 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(390 13 (:DEFINITION BINARY-APPEND))
(370 3 (:DEFINITION HEAP-TRIPLE-FIELDS-FOR-AD))
(368 368 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(364 77 (:REWRITE ITEMS-HAVE-LEN-WHEN-NOT-CONSP))
(350 350 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(348 348 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(348 348 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(342 171 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(326 326 (:TYPE-PRESCRIPTION BOOLEANP))
(316 158 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(302 302 (:REWRITE DEFAULT-+-1))
(297 297 (:TYPE-PRESCRIPTION AXE-TREEP))
(297 297 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(225 225 (:TYPE-PRESCRIPTION MEMBERP))
(219 3 (:DEFINITION FILTER-NON-QUOTEPS))
(205 5 (:REWRITE NOT-MYQUOTEP-WHEN-LEN-WRONG))
(168 168 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(167 4 (:DEFINITION STRIP-CARS))
(158 158 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(139 139 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(139 139 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(112 14 (:REWRITE APPEND-ATOM-UNDER-LIST-EQUIV))
(72 21 (:REWRITE FOLD-CONSTS-IN-+))
(66 3 (:LINEAR LEN-OF-CDR-LINEAR-STRONG))
(64 1 (:DEFINITION INITIALIZED-FIELD-ASSUMPTIONS-FOR-HEAP-ADDRESSES))
(47 21 (:REWRITE ZP-OPEN))
(47 8 (:REWRITE STRIP-CARS-OF-NON-CONSP))
(35 35 (:TYPE-PRESCRIPTION FIELD-VALS-IF-ALL-ADDRESSES-HAVE-THEM))
(27 3 (:REWRITE SUBSETP-WHEN-ATOM-RIGHT))
(27 3 (:REWRITE SUBSETP-WHEN-ATOM-LEFT))
(14 14 (:REWRITE BOUND-WHEN-USB))
(14 14 (:REWRITE <-WHEN-BVLT))
(12 12 (:REWRITE USE-ALL-<=-2))
(12 12 (:REWRITE USE-ALL-<=))
(12 12 (:REWRITE USE-ALL-<-2))
(12 12 (:REWRITE USE-ALL-<))
(12 12 (:REWRITE SIZE-NON-NEGATIVE-WHEN-UNSIGNED-BYTE-P-FREE))
(12 12 (:REWRITE DEFAULT-<-2))
(12 12 (:REWRITE DEFAULT-<-1))
(12 12 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(12 12 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(10 10 (:REWRITE NONNEG-WHEN-DARGP-LESS-THAN))
(10 10 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(10 10 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
(5 5 (:REWRITE MYQUOTEP-WHEN-DARGP-LESS-THAN))
(5 5 (:REWRITE MYQUOTEP-WHEN-BOUNDED-DAG-EXPRP))
(5 5 (:REWRITE MYQUOTEP-WHEN-AXE-TREEP))
(4 2 (:REWRITE IFF-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(3 3 (:REWRITE SUBSETP-TRANS2))
(3 3 (:REWRITE SUBSETP-TRANS))
(3 3 (:REWRITE NOT-SUBSETP-EQUAL-WHEN-MEMBERP))
(2 2 (:REWRITE <-OF-0-WHEN-<-FREE))
)
(INITIALIZED-CLASS-ASSUMPTIONS-FOR-STATIC-FIELDS
(2969 59 (:DEFINITION SYMBOL-LISTP))
(2698 38 (:DEFINITION STRIP-CADDRS))
(2076 1172 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(1415 283 (:REWRITE EQUAL-OF-BOOLEANS-CHEAP))
(1371 315 (:REWRITE JVM::CONSP-OF-CAR-WHEN-FIELD-INFO-ALISTP))
(1142 1142 (:REWRITE USE-ALL-HEAPREF-TABLE-ENTRYP-2))
(1142 1142 (:REWRITE USE-ALL-CONSP-2))
(1142 1142 (:REWRITE USE-ALL-CONSP))
(1142 1142 (:REWRITE CONSP-WHEN-LEN-GREATER))
(939 315 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP))
(912 912 (:TYPE-PRESCRIPTION JVM::FIELD-INFO-ALISTP))
(684 342 (:REWRITE PSEUDO-TERM-LISTP-WHEN-SYMBOL-LISTP-CHEAP))
(672 116 (:REWRITE STRIP-CARS-OF-NON-CONSP))
(668 134 (:REWRITE SYMBOLP-OF-CAR-WHEN-AXE-TREEP-CHEAP))
(630 315 (:REWRITE CONSP-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
(624 624 (:TYPE-PRESCRIPTION PSEUDO-DAGP))
(544 544 (:REWRITE CONSP-OF-CDR-WHEN-LEN-KNOWN))
(494 76 (:REWRITE STRIP-CADDRS-WHEN-NOT-CONSP))
(441 63 (:REWRITE PSEUDO-TERMP-OF-CADDR))
(432 144 (:REWRITE JVM::FIELD-INFO-ALISTP-OF-CDR))
(401 401 (:TYPE-PRESCRIPTION SYMBOL-LISTP))
(373 373 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(373 373 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(373 373 (:REWRITE LEN-WHEN-BV-ARRAYP))
(373 373 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(344 172 (:REWRITE PSEUDO-TERM-LISTP-OF-CDR-WHEN-PSEUDO-TERMP))
(342 342 (:REWRITE TERM-LISTP-IMPLIES-PSEUDO-TERM-LISTP))
(326 163 (:REWRITE TRUE-LISTP-WHEN-POSSIBLY-NEGATED-NODENUMSP))
(324 324 (:REWRITE TERMP-IMPLIES-PSEUDO-TERMP))
(321 315 (:REWRITE CONSP-OF-CAR-WHEN-POSSIBLY-NEGATED-NODENUMSP-WEAKEN-CHEAP))
(315 315 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(315 315 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX-2))
(315 315 (:REWRITE CONSP-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(314 314 (:REWRITE WFR-HACK5))
(314 314 (:REWRITE CAR-OF-CAR-WHEN-PSEUDO-DAGP-AUX))
(283 283 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CDR-WRONG))
(283 283 (:REWRITE JVM::NOT-EQUAL-CONSTANT-WHEN-CAR-WRONG))
(283 283 (:REWRITE EQUAL-WHEN-BVLT-ALT))
(283 283 (:REWRITE EQUAL-WHEN-BVLT))
(283 283 (:REWRITE EQUAL-OF-CONSTANT-WHEN-SBVLT))
(283 283 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-2))
(283 283 (:REWRITE EQUAL-OF-CONSTANT-WHEN-NOT-BVLT-CONSTANT-1))
(283 283 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2-ALT))
(283 283 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-2))
(283 283 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1-ALT))
(283 283 (:REWRITE EQUAL-OF-CONSTANT-WHEN-BVLT-CONSTANT-1))
(283 283 (:REWRITE EQUAL-CONSTANT-WHEN-NOT-SBVLT))
(283 283 (:REWRITE EQUAL-CONSTANT-WHEN-BVCHOP-EQUAL-CONSTANT-FALSE))
(283 283 (:REWRITE CLR-DIFFERENTIAL))
(280 140 (:REWRITE DEFAULT-+-2))
(185 185 (:REWRITE SYMBOLP-WHEN-BOUNDED-DAG-EXPRP))
(173 41 (:REWRITE ITEMS-HAVE-LEN-WHEN-NOT-CONSP))
(169 169 (:TYPE-PRESCRIPTION POSSIBLY-NEGATED-NODENUMSP))
(163 163 (:REWRITE TRUE-LISTP-WHEN-PSEUDO-DAGP-AUX))
(163 163 (:REWRITE TRUE-LISTP-WHEN-BV-ARRAYP))
(157 157 (:TYPE-PRESCRIPTION BOOLEANP))
(152 76 (:REWRITE SYMBOLP-OF-CAR-OF-CAR-WHEN-SYMBOL-ALISTP-CHEAP))
(150 150 (:REWRITE LEN-OF-CAR-WHEN-ITEMS-HAVE-LEN))
(140 140 (:REWRITE DEFAULT-+-1))
(134 134 (:TYPE-PRESCRIPTION AXE-TREEP))
(134 134 (:REWRITE SYMBOLP-OF-CAR-WHEN-BOUNDED-DAG-EXPRP))
(126 63 (:REWRITE PSEUDO-TERMP-OF-LAMBDA-BODY-CHEAP))
(106 106 (:REWRITE EQUAL-OF-NON-NATP-AND-CAAR-WHEN-WHEN-BOUNDED-NATP-ALISTP))
(94 94 (:REWRITE QUOTE-LEMMA-FOR-ALL-DARGP-LESS-THAN-GEN-ALT))
(76 76 (:TYPE-PRESCRIPTION SYMBOL-ALISTP))
(75 75 (:REWRITE TRUE-LISTP-OF-CAR-WHEN-ALL-DARGP-LESS-THAN))
(63 63 (:TYPE-PRESCRIPTION STR::TRUE-LISTP-OF-EXPLODE))
(63 63 (:REWRITE STR::EXPLODE-WHEN-NOT-STRINGP))
(44 2 (:LINEAR LEN-OF-CDR-LINEAR-STRONG))
(4 2 (:REWRITE IFF-OF-CAR-WHEN-SYMBOL-TERM-ALISTP-CHEAP))
)
(ASSUMPTION-CHECKING-RULES)
(INITIALIZED-CLASS-ASSUMPTIONS-FN)
(IN-OF-NTH-OF-RKEYS
(90 18 (:REWRITE SET::IN-TAIL))
(36 36 (:TYPE-PRESCRIPTION SET::EMPTY-TYPE))
(31 11 (:REWRITE JVM::IN-OF-RKEYS-WHEN-G-REV))
(27 9 (:REWRITE SET::TAIL-WHEN-EMPTY))
(27 9 (:REWRITE SET::NEVER-IN-EMPTY))
(23 1 (:LINEAR LEN-OF-CDR-LINEAR-STRONG))
(22 22 (:REWRITE SET::SUBSET-IN-2))
(22 22 (:REWRITE CONSP-WHEN-LEN-EQUAL-CONSTANT))
(21 9 (:REWRITE DEFAULT-CAR))
(21 1 (:LINEAR LEN-OF-CDR-LINEAR))
(20 11 (:REWRITE G-WHEN-NOT-IN-RKEYS-CHEAP))
(20 10 (:TYPE-PRESCRIPTION INTEGERP-OF-NTH-WHEN-ALL-NATP))
(17 17 (:REWRITE LEN-WHEN-PSEUDO-DAGP-AUX))
(17 17 (:REWRITE LEN-WHEN-NOT-CONSP-CHEAP))
(17 17 (:REWRITE LEN-WHEN-DARGP-LESS-THAN))
(17 17 (:REWRITE LEN-WHEN-BV-ARRAYP))
(17 17 (:REWRITE LEN-WHEN-BOUNDED-DAG-EXPRP-AND-QUOTEP))
(17 7 (:REWRITE DEFAULT-CDR))
(15 5 (:REWRITE <-OF-LEN-WHEN-NTH-NON-NIL))
(15 5 (:REWRITE <-OF-LEN-WHEN-INTEGERP-OF-NTH))
(11 11 (:REWRITE SET::SUBSET-IN-2-ALT))
(11 11 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-TWO))
(11 11 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-MAIN))
(11 11 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL-ALT))
(11 11 (:REWRITE IN-RKEYS-WHEN-GET-FIELD-NON-NIL))
(11 11 (:REWRITE JVM::IN-OF-RKEYS-WHEN-G))
(11 7 (:REWRITE DEFAULT-<-2))
(11 7 (:REWRITE CDR-WHEN-EQUAL-OF-LEN-AND-1-CHEAP))
(10 10 (:TYPE-PRESCRIPTION ALL-NATP))
(9 9 (:REWRITE BOUND-WHEN-USB))
(9 9 (:REWRITE <-WHEN-BVLT))
(7 7 (:REWRITE USE-ALL-<=-2))
(7 7 (:REWRITE USE-ALL-<=))
(7 7 (:REWRITE USE-ALL-<-2))
(7 7 (:REWRITE USE-ALL-<))
(7 7 (:REWRITE DEFAULT-<-1))
(7 7 (:REWRITE DEFAULT-+-2))
(7 7 (:REWRITE DEFAULT-+-1))
(7 7 (:REWRITE <-WHEN-BOUNDED-AXE-TREEP))
(7 7 (:REWRITE <-WHEN-ALL-DARGP-LESS-THAN-GEN))
(6 6 (:REWRITE NTH-WHEN-ALL-EQUAL$-HELPER))
(6 6 (:REWRITE NTH-WHEN-ALL-EQUAL$))
(5 5 (:REWRITE ZP-OPEN))
(3 3 (:REWRITE SIZE-NON-NEGATIVE-WHEN-UNSIGNED-BYTE-P-FREE))
(2 2 (:REWRITE SUBSET-HACK))
(2 2 (:REWRITE NONNEG-WHEN-DARGP-LESS-THAN))
(2 2 (:REWRITE INTEGERP-WHEN-DARGP-LESS-THAN))
(2 2 (:REWRITE INTEGERP-FROM-UNSIGNED-BYTE-P-SIZE-PARAM))
(1 1 (:REWRITE <-OF-0-WHEN-<-FREE))
)
|
using System;
using System.Collections.Generic;
namespace Skibitsky.Urx.Subjects
{
public class ReplaySubject<T> : SubjectBase<T>
{
private readonly SubjectBase<T> _subject;
private readonly Action<IObserver<T>> _replay;
private readonly Action<T> _add;
private readonly Action? _trim;
public ReplaySubject(int bufferSize)
{
if (bufferSize <= 0) throw new ArgumentException("Buffer size cannot be equal to or less than 0");
_subject = new Subject<T>();
(_replay, _add, _trim) = bufferSize switch
{
1 => CreateReplayOnce(),
int.MaxValue => CreateReplayAll(),
_ => CreateReplayMany(bufferSize)
};
}
private static (Action<IObserver<T>>, Action<T>, Action) CreateReplayMany(int bufferSize)
{
var replay = new ReplayMany(bufferSize);
return (replay.Replay, replay.Add, replay.Trim);
}
private static (Action<IObserver<T>>, Action<T>, Action) CreateReplayOnce()
{
var replay = new ReplayOnce();
return (replay.Replay, replay.Add, null);
}
private static (Action<IObserver<T>>, Action<T>, Action) CreateReplayAll()
{
var replay = new ReplayAll();
return (replay.Replay, replay.Add, null);
}
public override void OnCompleted() => _subject.OnCompleted();
public override void OnError(Exception error) => _subject.OnError(error);
public override void OnNext(T value)
{
if (_subject.IsCompleted) return;
_add(value);
_trim?.Invoke();
_subject.OnNext(value);
}
public override IDisposable Subscribe(IObserver<T> observer)
{
var disposable = _subject.Subscribe(observer);
if (!_subject.IsCompleted) _replay(observer);
return disposable;
}
public override void Dispose() => _subject.Dispose();
internal override void Unsubscribe(Subscription subscription) => _subject.Unsubscribe(subscription);
private sealed class ReplayMany
{
private readonly int _bufferSize;
private readonly Queue<T> _queue = new Queue<T>();
public ReplayMany(int bufferSize)
{
_bufferSize = bufferSize;
}
public void Add(T value)
{
if (value == null) throw new ArgumentNullException(nameof(value));
_queue.Enqueue(value);
}
public void Replay(IObserver<T> observer)
{
foreach (var item in _queue)
observer.OnNext(item);
}
public void Trim()
{
if (_queue.Count > _bufferSize) _queue.Dequeue();
}
}
private sealed class ReplayOnce
{
private T _value;
private bool _hasValue;
public void Add(T value)
{
if (value == null) throw new ArgumentNullException(nameof(value));
_value = value;
_hasValue = true;
}
public void Replay(IObserver<T> observer)
{
if (_hasValue) observer.OnNext(_value);
}
}
private sealed class ReplayAll
{
private readonly IList<T> _list = new List<T>();
public void Add(T value)
{
if (value == null) throw new ArgumentNullException(nameof(value));
_list.Add(value);
}
public void Replay(IObserver<T> observer)
{
for (var i = 0; i < _list.Count; i++)
observer.OnNext(_list[i]);
}
}
}
}
|
(in-package :lem-base)
(export '(skip-space-and-comment-forward
skip-space-and-comment-backward
form-offset
scan-lists
skip-whitespace-forward
skip-whitespace-backward
skip-symbol-forward
skip-symbol-backward
symbol-string-at-point
make-pps-state
pps-state-type
pps-state-token-start-point
pps-state-end-char
pps-state-block-comment-depth
pps-state-block-pair
pps-state-paren-stack
pps-state-paren-depth
parse-partial-sexp
syntax-ppss
pps-state-string-p
pps-state-comment-p
pps-state-string-or-comment-p
in-string-p
in-comment-p
in-string-or-comment-p
maybe-beginning-of-string
maybe-beginning-of-comment
maybe-beginning-of-string-or-comment))
(flet ((%match (str1 str2 str1-pos)
(let ((end1 (+ str1-pos (length str2))))
(when (and (<= end1 (length str1))
(string= str1 str2
:start1 str1-pos
:end1 end1))
(length str2)))))
(defun syntax-start-block-syntax-string-p (line-string pos pairs)
(dolist (pair pairs)
(let ((start (car pair)))
(let ((result (%match line-string start pos)))
(when result
(return (values result pair)))))))
(defun syntax-end-block-syntax-string-p (line-string pos pairs)
(dolist (pair pairs)
(let* ((end (cdr pair))
(pos (- pos (length end))))
(when (<= 0 pos)
(let ((result (%match line-string end pos)))
(when result
(return (values result pair))))))))
(defun syntax-line-comment-p (point)
(%match (line-string point)
(syntax-table-line-comment-string (current-syntax))
(point-charpos point)))
(defun syntax-start-block-comment-p (point)
(syntax-start-block-syntax-string-p (line-string point)
(point-charpos point)
(syntax-table-block-comment-pairs
(current-syntax))))
(defun syntax-end-block-comment-p (point)
(syntax-end-block-syntax-string-p (line-string point)
(point-charpos point)
(syntax-table-block-comment-pairs
(current-syntax))))
(defun syntax-start-block-string-p (point)
(syntax-start-block-syntax-string-p (line-string point)
(point-charpos point)
(syntax-table-block-string-pairs
(current-syntax))))
(defun syntax-end-block-string-p (point)
(syntax-end-block-syntax-string-p (line-string point)
(point-charpos point)
(syntax-table-block-string-pairs
(current-syntax)))))
(let ((cache (make-hash-table :test 'equal)))
(defun %create-pair-regex (pair)
(let ((tree
`(:positive-lookahead
(:alternation
(:sequence ,(car pair))
(:sequence ,(cdr pair))))))
(or (gethash tree cache)
(setf (gethash tree cache)
(ppcre:create-scanner tree))))))
(defun syntax-escape-point-p (point offset)
(let ((count 0))
(loop :with string := (line-string point)
:for i :downfrom (+ (1- (point-charpos point)) offset) :to 0
:do (if (syntax-escape-char-p (schar string i))
(incf count)
(return)))
(when (oddp count)
count)))
(defun inline-line-comment-p (point)
(with-point ((start point))
(line-start start)
(let ((pps-state (parse-partial-sexp start point)))
(when (pps-state-comment-p pps-state)
(move-point point (pps-state-token-start-point pps-state))))))
(defun %skip-comment-forward (point)
(multiple-value-bind (n pair)
(syntax-start-block-comment-p point)
(cond (n
(let ((regex (%create-pair-regex pair)))
(with-point ((curr point))
(character-offset curr n)
(loop :with depth := 1
:do (cond ((not (search-forward-regexp curr regex))
(return (values nil nil)))
((match-string-at curr (cdr pair))
(character-offset curr (length (cdr pair)))
(when (= 0 (decf depth))
(return (values (move-point point curr) t))))
(t
(character-offset curr (length (car pair)))
(incf depth)))))))
((syntax-line-comment-p point)
(values (line-offset point 1) t))
(t
(values nil t)))))
(defun %skip-block-comment-backward (point)
(multiple-value-bind (n pair)
(syntax-end-block-comment-p point)
(if n
(let ((regex (%create-pair-regex pair)))
(with-point ((curr point))
(character-offset curr (- n))
(loop :with depth := 1
:do (cond ((not (search-backward-regexp curr regex))
(return (values nil nil)))
((match-string-at curr (car pair))
(when (= 0 (decf depth))
(return (values (move-point point curr) t))))
(t
(incf depth))))))
(values nil t))))
(defun %skip-comment-backward (point)
(multiple-value-bind (p win)
(%skip-block-comment-backward point)
(cond ((not win)
(values nil nil))
((null p)
(alexandria:if-let (p (inline-line-comment-p point))
(values (move-point point p) t)
(values nil t)))
(t
(values point win)))))
(defun skip-space-and-comment-forward (point)
(with-point-syntax point
(loop
(skip-chars-forward point #'syntax-space-char-p)
(multiple-value-bind (result success)
(%skip-comment-forward point)
(unless result
(return success))))))
(defun skip-space-and-comment-backward (point)
(with-point-syntax point
(if (inline-line-comment-p point)
(skip-chars-backward point #'syntax-space-char-p)
(loop
(skip-chars-backward point #'syntax-space-char-p)
(multiple-value-bind (result success)
(%skip-comment-backward point)
(unless result
(return success)))))))
(defun %skip-symbol-forward (point)
(loop :for c := (character-at point 0)
:do (cond ((syntax-escape-char-p c)
(unless (character-offset point 2)
(return)))
((syntax-fence-char-p c)
(unless (%skip-fence-forward point)
(return)))
((not (or (syntax-symbol-char-p c)
(syntax-expr-prefix-char-p c)))
(return point))
(t
(unless (character-offset point 1)
(return))))))
(defun %skip-symbol-backward (point)
(loop :for c := (character-at point -1)
:do (let ((skip-count (syntax-escape-point-p point -1)))
(cond (skip-count
(character-offset point (- (1+ skip-count))))
((syntax-fence-char-p c)
(unless (%skip-fence-backward point)
(return)))
((or (syntax-symbol-char-p c)
(syntax-expr-prefix-char-p c)
(syntax-escape-char-p c))
(character-offset point -1))
(t
(return point))))))
(defun %skip-quote-forward (point)
(loop :with quote-char := (character-at point 0)
:do (unless (character-offset point 1)
(return nil))
(let ((c (character-at point)))
(cond ((syntax-escape-char-p c)
(character-offset point 1))
((eql c quote-char)
(character-offset point 1)
(return point))))))
(defun %skip-quote-backward (point)
(character-offset point -1)
(loop :with quote-char := (character-at point)
:do (unless (character-offset point -1)
(return nil))
(if (syntax-escape-point-p point 0)
(character-offset point -1)
(let ((c (character-at point)))
(cond ((eql c quote-char)
(return point)))))))
(defun %skip-string-forward (point)
(%skip-quote-forward point))
(defun %skip-string-backward (point)
(%skip-quote-backward point))
(defun %skip-fence-forward (point)
(%skip-quote-forward point))
(defun %skip-fence-backward (point)
(%skip-quote-backward point))
(defun %skip-list-forward (point depth limit-point)
(loop :with paren-stack := '()
:do (unless (skip-space-and-comment-forward point)
(return nil))
(when (if limit-point
(point<= limit-point point)
(end-buffer-p point))
(return nil))
(let ((c (character-at point 0))
n pair)
(cond ((multiple-value-setq (n pair) (syntax-start-block-string-p point))
(character-offset point n)
(unless (search-forward point (cdr pair))
(return nil)))
((syntax-open-paren-char-p c)
(push c paren-stack)
(character-offset point 1)
(when (zerop (incf depth))
(return point)))
((syntax-closed-paren-char-p c)
(unless (or (and (< 0 depth)
(null paren-stack))
(syntax-equal-paren-p c (car paren-stack)))
(return nil))
(pop paren-stack)
(character-offset point 1)
(when (zerop (decf depth))
(return point)))
((syntax-string-quote-char-p c)
(%skip-string-forward point))
((syntax-fence-char-p c)
(%skip-fence-forward point))
((syntax-escape-char-p c)
(unless (character-offset point 2)
(return nil)))
(t
(character-offset point 1))))))
(defun %skip-list-backward (point depth limit-point)
(loop :with paren-stack := '()
:do (when (if limit-point
(point<= point limit-point)
(start-buffer-p point))
(return nil))
(let ((c (character-at point -1))
n pair)
(cond ((syntax-escape-point-p point -1)
(character-offset point -1))
((syntax-closed-paren-char-p c)
(push c paren-stack)
(character-offset point -1)
(when (zerop (incf depth))
(return point)))
((syntax-open-paren-char-p c)
(unless (or (and (< 0 depth)
(null paren-stack))
(syntax-equal-paren-p c (car paren-stack)))
(return nil))
(pop paren-stack)
(character-offset point -1)
(when (zerop (decf depth))
(return point)))
((multiple-value-setq (n pair) (syntax-end-block-string-p point))
(character-offset point (- n))
(unless (search-backward point (car pair))
(return nil)))
((syntax-string-quote-char-p c)
(%skip-string-backward point))
((syntax-fence-char-p c)
(%skip-fence-backward point))
(t
(multiple-value-bind (p win)
(%skip-block-comment-backward point)
(unless win
(return nil))
(unless p
(character-offset point -1))))))
(when (end-line-p point)
(alexandria:when-let (p (inline-line-comment-p point))
(move-point point p)))))
(defun %form-offset-positive (point)
(skip-space-and-comment-forward point)
(when (end-buffer-p point)
(return-from %form-offset-positive nil))
(syntax-skip-expr-prefix-forward point)
(skip-chars-forward point #'syntax-expr-prefix-char-p)
(unless (end-buffer-p point)
(let ((c (character-at point))
n pair)
(let ((point
(cond ((multiple-value-setq (n pair) (syntax-start-block-string-p point))
(character-offset point n)
(if (search-forward point (cdr pair))
point
nil))
((syntax-open-paren-char-p c)
(%skip-list-forward point 0 nil))
((or (syntax-symbol-char-p c)
(syntax-escape-char-p c))
(%skip-symbol-forward point))
((syntax-expr-prefix-char-p c)
(character-offset point 1))
((syntax-closed-paren-char-p c)
nil)
((syntax-string-quote-char-p c)
(%skip-string-forward point))
((syntax-fence-char-p c)
(%skip-fence-forward point))
(t
(character-offset point 1)))))
(when point
(when (syntax-table-expr-suffix-chars (current-syntax))
(skip-chars-forward point
(syntax-table-expr-suffix-chars
(current-syntax))))
point)))))
(defun %form-offset-negative (point)
(skip-space-and-comment-backward point)
(when (start-buffer-p point)
(return-from %form-offset-negative nil))
(when (syntax-table-expr-suffix-chars (current-syntax))
(skip-chars-backward point (syntax-table-expr-suffix-chars (current-syntax))))
(let ((c (character-at point -1))
(escape-point-p (syntax-escape-point-p point -1))
n pair)
(prog1 (cond ((and (syntax-closed-paren-char-p c)
(not escape-point-p))
(%skip-list-backward point 0 nil))
((or (syntax-symbol-char-p c)
(syntax-escape-char-p c)
(syntax-expr-prefix-char-p c)
escape-point-p)
(%skip-symbol-backward point))
((syntax-open-paren-char-p c)
nil)
((multiple-value-setq (n pair) (syntax-end-block-string-p point))
(character-offset point (- n))
(if (search-backward point (car pair))
point
nil))
((syntax-string-quote-char-p c)
(%skip-string-backward point))
((syntax-fence-char-p c)
(%skip-fence-backward point))
(t
(character-offset point -1)))
(skip-chars-backward point #'syntax-expr-prefix-char-p)
(syntax-skip-expr-prefix-backward point))))
(defun form-offset (point n)
(with-point-syntax point
(with-point ((curr point))
(when (cond ((plusp n)
(dotimes (_ n t)
(unless (%form-offset-positive curr)
(return nil))))
(t
(dotimes (_ (- n) t)
(unless (%form-offset-negative curr)
(return nil)))))
(move-point point curr)))))
(defun scan-lists (point n depth &optional no-errors limit-point)
(with-point-syntax point
(with-point ((curr point))
(when (cond ((plusp n)
(dotimes (_ n t)
(unless (%skip-list-forward curr depth limit-point)
(if no-errors
(return nil)
(scan-error)))))
(t
(dotimes (_ (- n) t)
(unless (%skip-list-backward curr depth limit-point)
(if no-errors
(return nil)
(scan-error))))))
(move-point point curr)))))
(flet ((non-newline-whitespace-p (c)
(and (char/= c #\newline)
(syntax-space-char-p c))))
(defun skip-whitespace-forward (point &optional (oneline nil))
(with-point-syntax point
(if oneline
(skip-chars-forward point #'non-newline-whitespace-p)
(skip-chars-forward point #'syntax-space-char-p))))
(defun skip-whitespace-backward (point &optional (oneline nil))
(with-point-syntax point
(if oneline
(skip-chars-backward point #'non-newline-whitespace-p)
(skip-chars-backward point #'syntax-space-char-p)))))
(defun skip-symbol-forward (point)
(with-point-syntax point
(skip-chars-forward point #'syntax-symbol-char-p)))
(defun skip-symbol-backward (point)
(with-point-syntax point
(skip-chars-backward point #'syntax-symbol-char-p)))
(defun symbol-string-at-point (point)
(with-point-syntax point
(with-point ((point point))
(skip-chars-backward point #'syntax-symbol-char-p)
(unless (syntax-symbol-char-p (character-at point))
(return-from symbol-string-at-point nil))
(with-point ((start point))
(skip-chars-forward point #'syntax-symbol-char-p)
(points-to-string start point)))))
|
-- |
-- Module : Crypto.PubKey.ECC.DH
-- License : BSD-style
-- Maintainer : Vincent Hanquez <vincent@snarc.org>
-- Stability : experimental
-- Portability : unknown
--
-- Elliptic curve Diffie Hellman
--
module Crypto.PubKey.ECC.DH
(
Curve
, PublicPoint
, PrivateNumber
, SharedKey(..)
, generatePrivate
, calculatePublic
, getShared
) where
import Crypto.Number.Generate (generateMax)
import Crypto.Number.Serialize (i2ospOf_)
import Crypto.PubKey.ECC.Prim (pointMul)
import Crypto.Random.Types
import Crypto.PubKey.DH (SharedKey(..))
import Crypto.PubKey.ECC.Types (PublicPoint, PrivateNumber, Curve, Point(..), curveSizeBits)
import Crypto.PubKey.ECC.Types (ecc_n, ecc_g, common_curve)
-- | Generating a private number d.
generatePrivate :: MonadRandom m => Curve -> m PrivateNumber
generatePrivate curve = generateMax n
where
n = ecc_n $ common_curve curve
-- | Generating a public point Q.
calculatePublic :: Curve -> PrivateNumber -> PublicPoint
calculatePublic curve d = q
where
g = ecc_g $ common_curve curve
q = pointMul curve d g
-- | Generating a shared key using our private number and
-- the other party public point.
getShared :: Curve -> PrivateNumber -> PublicPoint -> SharedKey
getShared curve db qa = SharedKey $ i2ospOf_ ((nbBits + 7) `div` 8) x
where
Point x _ = pointMul curve db qa
nbBits = curveSizeBits curve
|
#include <darts.h>
#include <cstdio>
#include <fstream>
#include <iostream>
#include "./benchmark-config.h"
#include "./lexicon.h"
#include "./timer.h"
namespace {
int progress_bar(std::size_t current, std::size_t total) {
static const char bar[] = "*******************************************";
static const int scale = sizeof(bar) - 1;
static int prev = 0;
int cur_percentage = static_cast<int>(100.0 * current / total);
int bar_len = static_cast<int>(1.0 * current * scale / total);
if (prev != cur_percentage) {
std::fprintf(stderr, "Making double-array: %3d%% |%.*s%*s|",
cur_percentage, bar_len, bar, scale - bar_len, "");
if (cur_percentage >= 100) {
std::fprintf(stderr, "\n");
} else {
std::fprintf(stderr, "\r");
}
std::fflush(stderr);
}
prev = cur_percentage;
return 1;
};
void benchmark_exact_match_search(const Darts::DoubleArray &dic,
const Darts::Lexicon &lexicon) {
Darts::Timer timer;
std::size_t num_tries = 0;
do {
for (std::size_t i = 0; i < lexicon.size(); ++i) {
Darts::DoubleArray::value_type value;
dic.exactMatchSearch(lexicon[i], value);
if (value == -1) {
std::cerr << "error: failed to find key: "
<< lexicon[i] << std::endl;
std::exit(1);
}
}
++num_tries;
} while (timer.elapsed() < 1.0);
std::printf(" %6.1fns", 1e+9 * timer.elapsed()
/ (lexicon.size() * num_tries));
std::fflush(stdout);
}
void benchmark_common_prefix_search(const Darts::DoubleArray &dic,
const Darts::Lexicon &lexicon) {
Darts::Timer timer;
std::size_t num_tries = 0;
static const std::size_t MAX_NUM_RESULTS = 256;
Darts::DoubleArray::value_type results[MAX_NUM_RESULTS];
do {
for (std::size_t i = 0; i < lexicon.size(); ++i) {
std::size_t num_matches = dic.commonPrefixSearch(
lexicon[i], results, MAX_NUM_RESULTS);
if (num_matches < 1) {
std::cerr << "error: failed to find prefix keys of: "
<< lexicon[i] << std::endl;
std::exit(1);
}
}
++num_tries;
} while (timer.elapsed() < 1.0);
std::printf(" %7.1fns", 1e+9 * timer.elapsed()
/ (lexicon.size() * num_tries));
std::fflush(stdout);
}
void benchmark_traverse(const Darts::DoubleArray &dic,
const Darts::Lexicon &lexicon) {
Darts::Timer timer;
std::size_t num_tries = 0;
do {
for (std::size_t i = 0; i < lexicon.size(); ++i) {
const char *key = lexicon[i];
std::size_t id = 0;
std::size_t key_pos = 0;
Darts::DoubleArray::value_type result = 0;
for (std::size_t j = 0; key[j] != '\0'; ++j) {
result = dic.traverse(key, id, key_pos, j + 1);
if (result == -2) {
std::cerr << "error: failed to traverse key: "
<< key << std::endl;
std::exit(1);
}
}
if (result < 0) {
std::cerr << "error: failed to find key: " << key << std::endl;
std::exit(1);
}
}
++num_tries;
} while (timer.elapsed() < 1.0);
std::printf(" %6.1fns", 1e+9 * timer.elapsed()
/ (lexicon.size() * num_tries));
std::fflush(stdout);
}
void benchmark_lexicon(const Darts::BenchmarkConfig &config,
const Darts::Lexicon &lexicon, Darts::DoubleArray *dic) {
Darts::Timer timer;
if (dic->build(lexicon.size(), lexicon.keys(), NULL,
lexicon.values(), progress_bar) != 0) {
std::cerr << "error: failed to build dictionary" << std::endl;
std::exit(1);
}
std::printf("+--------+--------+-----------------+-------------------+"
"-----------------+\n");
std::printf(" %8s %8s", "size", "build");
if (config.benchmarks_exact_match_search()) {
std::printf(" %17s", "exactMatchSearch");
}
if (config.benchmarks_common_prefix_search()) {
std::printf(" %19s", "commonPrefixSearch");
}
if (config.benchmarks_traverse()) {
std::printf(" %17s", "traverse");
}
std::printf("\n");
std::printf(" %8s %8s", "", "");
if (config.benchmarks_exact_match_search()) {
std::printf(" %8s %8s", "sorted", "random");
}
if (config.benchmarks_common_prefix_search()) {
std::printf(" %9s %9s", "sorted", "random");
}
if (config.benchmarks_traverse()) {
std::printf(" %8s %8s", "sorted", "random");
}
std::printf("\n");
std::printf("+--------+--------+-----------------+-------------------+"
"-----------------+\n");
Darts::Lexicon randomized_lexicon(lexicon);
randomized_lexicon.randomize();
std::printf(" %6ukb", static_cast<unsigned int>(dic->total_size() / 1000));
std::printf(" %6.0fns", 1e+9 * timer.elapsed() / lexicon.size());
std::fflush(stdout);
benchmark_exact_match_search(*dic, lexicon);
benchmark_exact_match_search(*dic, randomized_lexicon);
benchmark_common_prefix_search(*dic, lexicon);
benchmark_common_prefix_search(*dic, randomized_lexicon);
benchmark_traverse(*dic, lexicon);
benchmark_traverse(*dic, randomized_lexicon);
std::printf("\n");
std::printf("+--------+--------+-----------------+-------------------+"
"-----------------+\n");
}
} // namespace
int main(int argc, char *argv[]) {
try {
Darts::BenchmarkConfig config;
config.parse(argc, argv);
Darts::Lexicon lexicon;
if (std::strcmp(config.lexicon_file_name(), "-") != 0) {
std::ifstream file(config.lexicon_file_name());
if (!file) {
std::cerr << "error: failed to open lexicon file: "
<< config.lexicon_file_name() << std::endl;
std::exit(1);
}
lexicon.read(&file);
} else {
lexicon.read(&std::cin);
}
// Note that split() of <Darts::Lexicon> may cause a problem if the lexicon
// contains control characters.
lexicon.sort();
if (config.has_values()) {
lexicon.split();
}
Darts::DoubleArray dic;
benchmark_lexicon(config, lexicon, &dic);
} catch (const std::exception &ex) {
std::cerr << "exception: " << ex.what() << std::endl;
throw ex;
}
return 0;
}
|
# encoding: utf-8
require File.expand_path('../../../spec_helper.rb', __FILE__)
describe 'Backup::Syncer::Cloud::S3' do
let(:syncer) do
Backup::Syncer::Cloud::S3.new do |s3|
s3.access_key_id = 'my_access_key_id'
s3.secret_access_key = 'my_secret_access_key'
s3.bucket = 'my_bucket'
s3.region = 'my_region'
end
end
it 'should be a subclass of Syncer::Cloud::Base' do
Backup::Syncer::Cloud::S3.
superclass.should == Backup::Syncer::Cloud::Base
end
describe '#initialize' do
after { Backup::Syncer::Cloud::S3.clear_defaults! }
it 'should load pre-configured defaults through Syncer::Cloud::Base' do
Backup::Syncer::Cloud::S3.any_instance.expects(:load_defaults!)
syncer
end
it 'should strip any leading slash in path' do
syncer = Backup::Syncer::Cloud::S3.new do |cloud|
cloud.path = '/cleaned/path'
end
syncer.path.should == 'cleaned/path'
end
context 'when no pre-configured defaults have been set' do
it 'should use the values given' do
syncer.access_key_id.should == 'my_access_key_id'
syncer.secret_access_key.should == 'my_secret_access_key'
syncer.bucket.should == 'my_bucket'
syncer.region.should == 'my_region'
end
it 'should use default values if none are given' do
syncer = Backup::Syncer::Cloud::S3.new
# from Syncer::Base
syncer.path.should == 'backups'
syncer.mirror.should == false
syncer.directories.should == []
# from Syncer::Cloud::Base
syncer.concurrency_type.should == false
syncer.concurrency_level.should == 2
syncer.access_key_id.should be_nil
syncer.secret_access_key.should be_nil
syncer.bucket.should be_nil
syncer.region.should be_nil
end
end # context 'when no pre-configured defaults have been set'
context 'when pre-configured defaults have been set' do
before do
Backup::Syncer::Cloud::S3.defaults do |cloud|
cloud.access_key_id = 'default_access_key_id'
cloud.secret_access_key = 'default_secret_access_key'
cloud.bucket = 'default_bucket'
cloud.region = 'default_region'
end
end
it 'should use pre-configured defaults' do
syncer = Backup::Syncer::Cloud::S3.new
# from Syncer::Base
syncer.path.should == 'backups'
syncer.mirror.should == false
syncer.directories.should == []
# from Syncer::Cloud::Base
syncer.concurrency_type.should == false
syncer.concurrency_level.should == 2
syncer.access_key_id.should == 'default_access_key_id'
syncer.secret_access_key.should == 'default_secret_access_key'
syncer.bucket.should == 'default_bucket'
syncer.region.should == 'default_region'
end
it 'should override pre-configured defaults' do
syncer = Backup::Syncer::Cloud::S3.new do |cloud|
cloud.path = 'new_path'
cloud.mirror = 'new_mirror'
cloud.concurrency_type = 'new_concurrency_type'
cloud.concurrency_level = 'new_concurrency_level'
cloud.access_key_id = 'new_access_key_id'
cloud.secret_access_key = 'new_secret_access_key'
cloud.bucket = 'new_bucket'
cloud.region = 'new_region'
end
syncer.path.should == 'new_path'
syncer.mirror.should == 'new_mirror'
syncer.directories.should == []
syncer.concurrency_type.should == 'new_concurrency_type'
syncer.concurrency_level.should == 'new_concurrency_level'
syncer.access_key_id.should == 'new_access_key_id'
syncer.secret_access_key.should == 'new_secret_access_key'
syncer.bucket.should == 'new_bucket'
syncer.region.should == 'new_region'
end
end # context 'when pre-configured defaults have been set'
end # describe '#initialize'
describe '#connection' do
let(:connection) { mock }
before do
Fog::Storage.expects(:new).once.with(
:provider => 'AWS',
:aws_access_key_id => 'my_access_key_id',
:aws_secret_access_key => 'my_secret_access_key',
:region => 'my_region'
).returns(connection)
end
it 'should establish and re-use the connection' do
syncer.send(:connection).should == connection
syncer.instance_variable_get(:@connection).should == connection
syncer.send(:connection).should == connection
end
end
describe '#repository_object' do
let(:connection) { mock }
let(:directories) { mock }
let(:bucket) { mock }
before do
syncer.stubs(:connection).returns(connection)
connection.stubs(:directories).returns(directories)
end
context 'when the @bucket does not exist' do
before do
directories.expects(:get).once.with('my_bucket').returns(nil)
directories.expects(:create).once.with(
:key => 'my_bucket',
:location => 'my_region'
).returns(bucket)
end
it 'should create and re-use the bucket' do
syncer.send(:repository_object).should == bucket
syncer.instance_variable_get(:@repository_object).should == bucket
syncer.send(:repository_object).should == bucket
end
end
context 'when the @bucket does exist' do
before do
directories.expects(:get).once.with('my_bucket').returns(bucket)
directories.expects(:create).never
end
it 'should retrieve and re-use the bucket' do
syncer.send(:repository_object).should == bucket
syncer.instance_variable_get(:@repository_object).should == bucket
syncer.send(:repository_object).should == bucket
end
end
end
end
|
docker build -t sampleapp .
docker run --name sampleappimpl --privileged --cap-add SYS_ADMIN --cap-add DAC_READ_SEARCH --dns=127.0.0.1 sampleapp
docker run --name test -e ROOT_PWD=root --privileged --cap-add SYS_ADMIN --cap-add DAC_READ_SEARCH ham.base
|
package chef
import (
"fmt"
"path"
"testing"
"github.com/hashicorp/terraform/communicator"
"github.com/hashicorp/terraform/terraform"
)
func TestResourceProvider_linuxInstallChefClient(t *testing.T) {
cases := map[string]struct {
Config *terraform.ResourceConfig
Commands map[string]bool
}{
"Sudo": {
Config: testConfig(t, map[string]interface{}{
"node_name": "nodename1",
"run_list": []interface{}{"cookbook::recipe"},
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "validator.pem",
}),
Commands: map[string]bool{
"sudo curl -LO https://www.chef.io/chef/install.sh": true,
"sudo bash ./install.sh -v \"\"": true,
"sudo rm -f install.sh": true,
},
},
"NoSudo": {
Config: testConfig(t, map[string]interface{}{
"node_name": "nodename1",
"prevent_sudo": true,
"run_list": []interface{}{"cookbook::recipe"},
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "validator.pem",
"secret_key_path": "encrypted_data_bag_secret",
}),
Commands: map[string]bool{
"curl -LO https://www.chef.io/chef/install.sh": true,
"bash ./install.sh -v \"\"": true,
"rm -f install.sh": true,
},
},
"HTTPProxy": {
Config: testConfig(t, map[string]interface{}{
"http_proxy": "http://proxy.local",
"node_name": "nodename1",
"prevent_sudo": true,
"run_list": []interface{}{"cookbook::recipe"},
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "validator.pem",
}),
Commands: map[string]bool{
"http_proxy='http://proxy.local' curl -LO https://www.chef.io/chef/install.sh": true,
"http_proxy='http://proxy.local' bash ./install.sh -v \"\"": true,
"http_proxy='http://proxy.local' rm -f install.sh": true,
},
},
"HTTPSProxy": {
Config: testConfig(t, map[string]interface{}{
"https_proxy": "https://proxy.local",
"node_name": "nodename1",
"prevent_sudo": true,
"run_list": []interface{}{"cookbook::recipe"},
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "validator.pem",
}),
Commands: map[string]bool{
"https_proxy='https://proxy.local' curl -LO https://www.chef.io/chef/install.sh": true,
"https_proxy='https://proxy.local' bash ./install.sh -v \"\"": true,
"https_proxy='https://proxy.local' rm -f install.sh": true,
},
},
"NoProxy": {
Config: testConfig(t, map[string]interface{}{
"http_proxy": "http://proxy.local",
"no_proxy": []interface{}{"http://local.local", "http://local.org"},
"node_name": "nodename1",
"prevent_sudo": true,
"run_list": []interface{}{"cookbook::recipe"},
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "validator.pem",
}),
Commands: map[string]bool{
"http_proxy='http://proxy.local' no_proxy='http://local.local,http://local.org' " +
"curl -LO https://www.chef.io/chef/install.sh": true,
"http_proxy='http://proxy.local' no_proxy='http://local.local,http://local.org' " +
"bash ./install.sh -v \"\"": true,
"http_proxy='http://proxy.local' no_proxy='http://local.local,http://local.org' " +
"rm -f install.sh": true,
},
},
"Version": {
Config: testConfig(t, map[string]interface{}{
"node_name": "nodename1",
"prevent_sudo": true,
"run_list": []interface{}{"cookbook::recipe"},
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "validator.pem",
"version": "11.18.6",
}),
Commands: map[string]bool{
"curl -LO https://www.chef.io/chef/install.sh": true,
"bash ./install.sh -v \"11.18.6\"": true,
"rm -f install.sh": true,
},
},
}
r := new(ResourceProvisioner)
o := new(terraform.MockUIOutput)
c := new(communicator.MockCommunicator)
for k, tc := range cases {
c.Commands = tc.Commands
p, err := r.decodeConfig(tc.Config)
if err != nil {
t.Fatalf("Error: %v", err)
}
p.useSudo = !p.PreventSudo
err = p.linuxInstallChefClient(o, c)
if err != nil {
t.Fatalf("Test %q failed: %v", k, err)
}
}
}
func TestResourceProvider_linuxCreateConfigFiles(t *testing.T) {
cases := map[string]struct {
Config *terraform.ResourceConfig
Commands map[string]bool
Uploads map[string]string
}{
"Sudo": {
Config: testConfig(t, map[string]interface{}{
"ohai_hints": []interface{}{"test-fixtures/ohaihint.json"},
"node_name": "nodename1",
"run_list": []interface{}{"cookbook::recipe"},
"secret_key_path": "test-fixtures/encrypted_data_bag_secret",
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "test-fixtures/validator.pem",
}),
Commands: map[string]bool{
"sudo mkdir -p " + linuxConfDir: true,
"sudo chmod 777 " + linuxConfDir: true,
"sudo " + fmt.Sprintf(chmod, linuxConfDir, 666): true,
"sudo mkdir -p " + path.Join(linuxConfDir, "ohai/hints"): true,
"sudo chmod 777 " + path.Join(linuxConfDir, "ohai/hints"): true,
"sudo " + fmt.Sprintf(chmod, path.Join(linuxConfDir, "ohai/hints"), 666): true,
"sudo chmod 755 " + path.Join(linuxConfDir, "ohai/hints"): true,
"sudo " + fmt.Sprintf(chmod, path.Join(linuxConfDir, "ohai/hints"), 600): true,
"sudo chown -R root.root " + path.Join(linuxConfDir, "ohai/hints"): true,
"sudo chmod 755 " + linuxConfDir: true,
"sudo " + fmt.Sprintf(chmod, linuxConfDir, 600): true,
"sudo chown -R root.root " + linuxConfDir: true,
},
Uploads: map[string]string{
linuxConfDir + "/client.rb": defaultLinuxClientConf,
linuxConfDir + "/encrypted_data_bag_secret": "SECRET-KEY-FILE",
linuxConfDir + "/first-boot.json": `{"run_list":["cookbook::recipe"]}`,
linuxConfDir + "/ohai/hints/ohaihint.json": "OHAI-HINT-FILE",
linuxConfDir + "/validation.pem": "VALIDATOR-PEM-FILE",
},
},
"NoSudo": {
Config: testConfig(t, map[string]interface{}{
"node_name": "nodename1",
"prevent_sudo": true,
"run_list": []interface{}{"cookbook::recipe"},
"secret_key_path": "test-fixtures/encrypted_data_bag_secret",
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "test-fixtures/validator.pem",
}),
Commands: map[string]bool{
"mkdir -p " + linuxConfDir: true,
},
Uploads: map[string]string{
linuxConfDir + "/client.rb": defaultLinuxClientConf,
linuxConfDir + "/encrypted_data_bag_secret": "SECRET-KEY-FILE",
linuxConfDir + "/first-boot.json": `{"run_list":["cookbook::recipe"]}`,
linuxConfDir + "/validation.pem": "VALIDATOR-PEM-FILE",
},
},
"Proxy": {
Config: testConfig(t, map[string]interface{}{
"http_proxy": "http://proxy.local",
"https_proxy": "https://proxy.local",
"no_proxy": []interface{}{"http://local.local", "https://local.local"},
"node_name": "nodename1",
"prevent_sudo": true,
"run_list": []interface{}{"cookbook::recipe"},
"secret_key_path": "test-fixtures/encrypted_data_bag_secret",
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "test-fixtures/validator.pem",
}),
Commands: map[string]bool{
"mkdir -p " + linuxConfDir: true,
},
Uploads: map[string]string{
linuxConfDir + "/client.rb": proxyLinuxClientConf,
linuxConfDir + "/encrypted_data_bag_secret": "SECRET-KEY-FILE",
linuxConfDir + "/first-boot.json": `{"run_list":["cookbook::recipe"]}`,
linuxConfDir + "/validation.pem": "VALIDATOR-PEM-FILE",
},
},
"Attributes": {
Config: testConfig(t, map[string]interface{}{
"attributes": []map[string]interface{}{
map[string]interface{}{
"key1": []map[string]interface{}{
map[string]interface{}{
"subkey1": []map[string]interface{}{
map[string]interface{}{
"subkey2a": []interface{}{
"val1", "val2", "val3",
},
"subkey2b": []map[string]interface{}{
map[string]interface{}{
"subkey3": "value3",
},
},
},
},
},
},
"key2": "value2",
},
},
"node_name": "nodename1",
"prevent_sudo": true,
"run_list": []interface{}{"cookbook::recipe"},
"secret_key_path": "test-fixtures/encrypted_data_bag_secret",
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "test-fixtures/validator.pem",
}),
Commands: map[string]bool{
"mkdir -p " + linuxConfDir: true,
},
Uploads: map[string]string{
linuxConfDir + "/client.rb": defaultLinuxClientConf,
linuxConfDir + "/encrypted_data_bag_secret": "SECRET-KEY-FILE",
linuxConfDir + "/validation.pem": "VALIDATOR-PEM-FILE",
linuxConfDir + "/first-boot.json": `{"key1":{"subkey1":{"subkey2a":["val1","val2","val3"],` +
`"subkey2b":{"subkey3":"value3"}}},"key2":"value2","run_list":["cookbook::recipe"]}`,
},
},
"Attributes JSON": {
Config: testConfig(t, map[string]interface{}{
"attributes_json": `{"key1":{"subkey1":{"subkey2a":["val1","val2","val3"],` +
`"subkey2b":{"subkey3":"value3"}}},"key2":"value2"}`,
"node_name": "nodename1",
"prevent_sudo": true,
"run_list": []interface{}{"cookbook::recipe"},
"secret_key_path": "test-fixtures/encrypted_data_bag_secret",
"server_url": "https://chef.local",
"validation_client_name": "validator",
"validation_key_path": "test-fixtures/validator.pem",
}),
Commands: map[string]bool{
"mkdir -p " + linuxConfDir: true,
},
Uploads: map[string]string{
linuxConfDir + "/client.rb": defaultLinuxClientConf,
linuxConfDir + "/encrypted_data_bag_secret": "SECRET-KEY-FILE",
linuxConfDir + "/validation.pem": "VALIDATOR-PEM-FILE",
linuxConfDir + "/first-boot.json": `{"key1":{"subkey1":{"subkey2a":["val1","val2","val3"],` +
`"subkey2b":{"subkey3":"value3"}}},"key2":"value2","run_list":["cookbook::recipe"]}`,
},
},
}
r := new(ResourceProvisioner)
o := new(terraform.MockUIOutput)
c := new(communicator.MockCommunicator)
for k, tc := range cases {
c.Commands = tc.Commands
c.Uploads = tc.Uploads
p, err := r.decodeConfig(tc.Config)
if err != nil {
t.Fatalf("Error: %v", err)
}
p.useSudo = !p.PreventSudo
err = p.linuxCreateConfigFiles(o, c)
if err != nil {
t.Fatalf("Test %q failed: %v", k, err)
}
}
}
const defaultLinuxClientConf = `log_location STDOUT
chef_server_url "https://chef.local"
validation_client_name "validator"
node_name "nodename1"`
const proxyLinuxClientConf = `log_location STDOUT
chef_server_url "https://chef.local"
validation_client_name "validator"
node_name "nodename1"
http_proxy "http://proxy.local"
ENV['http_proxy'] = "http://proxy.local"
ENV['HTTP_PROXY'] = "http://proxy.local"
https_proxy "https://proxy.local"
ENV['https_proxy'] = "https://proxy.local"
ENV['HTTPS_PROXY'] = "https://proxy.local"
no_proxy "http://local.local,https://local.local"
ENV['no_proxy'] = "http://local.local,https://local.local"`
|
using Application.Common.Models;
using MediatR;
using Microsoft.Extensions.Logging;
namespace Application.Common.Behaviours;
public class UnhandledExceptionBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
where TResponse : CQRSResponse, new()
{
private readonly ILogger<UnhandledExceptionBehavior<TRequest, TResponse>> _logger;
public UnhandledExceptionBehavior(ILogger<UnhandledExceptionBehavior<TRequest, TResponse>> logger)
{
_logger = logger;
}
public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken,
RequestHandlerDelegate<TResponse> next)
{
try
{
return await next();
}
catch (Exception ex)
{
_logger.LogError(ex, "{Request} - Unhandled exception caught.", typeof(TRequest).Name);
var response = new TResponse();
response.ServerError();
return response;
}
}
}
|
import React from 'react';
import { Trans } from '@lingui/macro';
import styled from 'styled-components';
import RDatePicker from 'react-datepicker';
import 'react-datepicker/dist/react-datepicker.css';
import { darken } from 'polished';
import Flex from './Flex';
export const Form = styled.form`
display: flex;
flex-direction: column;
background: whitesmoke;
border-radius: 4px;
margin-top: 8px;
`;
export const FormElement = styled.div`
display: flex;
align-items: center;
margin: 8px 0;
`;
export const FormContent = styled.div`
padding: 8px;
`;
export const FormHeader = styled.div`
display: flex;
align-items: center;
cursor: pointer;
padding: 8px;
background: lightgrey;
border-radius: 4px 4px 0 0;
`;
export const FormHeaderTitle = styled.h2`
font-size: 1rem;
margin: 0;
flex: 1;
`;
export const FormHeaderIcon = styled.img`
width: 30px;
height: 30px;
`;
export const FormSubmit = styled.button`
border: 0;
outline: 0;
background: ${props => props.theme.primary};
border-radius: 0 0 4px 4px;
padding: 8px;
font-weight: bold;
cursor: pointer;
&:hover {
background: ${props => darken(0.1, props.theme.primary)};
}
`;
export const Input = styled.input`
border-radius: 4px;
padding: 0 25px;
height: 55px;
outline: none;
border: 2px solid lightgrey;
font-weight: bold;
color: grey;
line-height: 1.2;
box-sizing: border-box;
`;
export const Toggle = styled.button`
height: 50px;
cursor: pointer;
border: 2px solid lightgrey;
text-transform: uppercase;
font-weight: bold;
color: grey;
border-radius: 4px;
background-color: white;
background-color: ${props => (props.active ? props.theme.primary : null)};
`;
export const IconToggle = styled(Toggle)`
background-image: url(${props => props.src});
background-size: cover;
background-position: center;
width: 50px;
background-color: ${props => (props.active ? props.theme.primary : null)};
`;
export const Label = styled.label`
font-weight: bold;
flex: 1;
`;
class CustomInput extends React.Component {
render() {
const { value, onClick } = this.props;
return (
<Toggle type="button" onClick={onClick}>
{value}
</Toggle>
);
}
}
export const DatePicker = ({ onChange, ...props }) => {
return (
<Flex wrap="wrap" justifyContent="flex-end" spacing={5}>
<Toggle
onClick={() => {
onChange(new Date());
}}
type="button"
>
<Trans>Now</Trans>
</Toggle>
<RDatePicker
{...props}
onChange={onChange}
customInput={<CustomInput />}
/>
</Flex>
);
};
export const InputDatetime = RDatePicker;
|
import { DataObserver } from './data.observer';
import { DataSignature } from './data.signature';
import { Subject } from 'rxjs/Subject';
import { DataAbstract } from './data.abstract';
class DummyObservableModule extends DataAbstract {
constructor(data) {
super(data);
}
}
describe('DataObserver', () => {
const DO = new DataObserver();
const emptyDo = new DataObserver();
const emptyDo2 = new DataObserver();
it('should exist', () => {
expect(typeof DataObserver).toBe('function');
});
it('should have a constructor method defined', () => {
expect(DO.constructor).toBeDefined();
expect(typeof DO.constructor).toBe('function');
});
it('should have an _observables variable defined', () => {
expect(DO._observables).toBeDefined();
expect(typeof DO._observables).toBe('object');
expect(DO._observables).toEqual({});
});
it('should have an _signatures variable defined', () => {
expect(DO._signatures).toBeDefined();
expect(typeof DO._signatures).toBe('object');
});
it('should have an _subscriptions variable defined', () => {
expect(DO._subscriptions).toBeDefined();
expect(DO._subscriptions instanceof Map).toBe(true);
});
describe('#addSignature()', () => {
let signature = null;
beforeAll(() => {
signature = new DataSignature('key');
});
it('should exist', () => {
expect(typeof DO.addSignature).toBe('function');
});
it('should return DataObservable instance', () => {
expect(DO.addSignature(signature)).toEqual(DO);
});
it('should bind given signature to this._signatures', () => {
DO.addSignature(signature);
expect(DO._signatures.key).toBeDefined();
expect(DO._signatures.key.key).toBe('key');
});
it('should bind given signature to this._signatures and add .busy-property', () => {
DO.addSignature(signature);
expect(DO._signatures.key.busy).toBe(false);
});
});
describe('#removeSignature()', () => {
let signature = null;
beforeAll(() => {
signature = new DataSignature('key');
});
it('should exist', () => {
expect(typeof DO.removeSignature).toBe('function');
});
it('should return DataObservable instance', () => {
expect(DO.removeSignature('key')).toEqual(DO);
});
it('should remove an added signature', () => {
emptyDo.addSignature(signature);
expect(emptyDo._signatures.key).toBeDefined();
emptyDo.removeSignature(signature);
expect(emptyDo._signatures.key).not.toBeDefined();
});
it('should ignore an invalid key', () => {
expect(emptyDo2.removeSignature(signature)).toEqual(emptyDo2);
});
});
describe('#getSignature()', () => {
let signature = null;
beforeAll(() => {
signature = new DataSignature('key');
});
it('should exist', () => {
expect(typeof DO.getSignature).toBe('function');
});
it('should return a registered signature', () => {
DO.addSignature(signature);
expect(DO.getSignature('key').key).toEqual('key');
});
it('should return null if signature is not defined', () => {
expect(DO.getSignature('donotexist')).toEqual(null);
});
});
describe('#setSignatureBusy()', () => {
let signature = null;
beforeAll(() => {
signature = new DataSignature('key');
});
it('should exist', () => {
expect(typeof DO.setSignatureBusy).toBe('function');
});
it('should set signature property busy to true', () => {
DO.addSignature(signature);
DO.setSignatureBusy('key');
expect(DO.getSignature('key').busy).toBe(true);
});
it('should return instance of DataObservalbe', () => {
expect(DO.setSignatureBusy('key')).toEqual(DO);
});
it('should ignore invalid signature key', () => {
expect(DO.setSignatureBusy('kljwiqjq9w8dfjsadfkl')).toEqual(DO);
});
});
describe('#isSignatureBusy()', () => {
let signature = null;
beforeAll(() => {
signature = new DataSignature('key');
});
it('should exist', () => {
expect(typeof DO.isSignatureBusy).toBe('function');
});
it('should determine if a signature is busy', () => {
DO.addSignature(signature);
DO.setSignatureBusy('key');
expect(DO.isSignatureBusy('key')).toBe(true);
});
it('should return return false if signature is not busy anymore', () => {
DO._signatures.key.busy = false;
expect(DO.isSignatureBusy('key')).toBe(false);
});
it('should return false on invalid key', () => {
expect(DO.isSignatureBusy('alksdjfklawjflqk4jasldkjf')).toBe(false);
});
});
describe('#addObservable()', () => {
let fakeObserableModule = {
getObservable: () => null,
push: () => 1,
};
let fakeObserableModuleFalsy = {
getObservable: () => null,
push: 'iamnotafunction',
};
let fakeObserableModuleInvalid = {
getObservable: 'stringisnotgood',
};
it('should exist', () => {
expect(typeof DO.addObservable).toBe('function');
});
it('should return this', () => {
expect(DO.addObservable('a', fakeObserableModule)).toEqual(DO);
});
it('should add a given observable', () => {
DO.addObservable('observable.key', fakeObserableModule);
expect(DO._observables['observable.key'].observable).toBe(null);
expect(DO._observables['observable.key'].push()).toBe(1);
DO.addObservable('observable.falsypush', fakeObserableModuleFalsy);
expect(DO._observables['observable.falsypush'].observable).toBe(null);
expect(DO._observables['observable.falsypush'].push).toBe(null);
});
it('should ignore invalid observables', () => {
expect(DO.addObservable(fakeObserableModuleInvalid)).toEqual(DO);
expect(DO.addObservable(null, fakeObserableModuleInvalid)).toEqual(DO);
expect(DO.addObservable(null)).toEqual(DO);
expect(DO.addObservable()).toEqual(DO);
expect(DO.addObservable('taddaa')).toEqual(DO);
expect(DO.addObservable('taddaa', 'totoo')).toEqual(DO);
expect(DO.addObservable(undefined, fakeObserableModule)).toEqual(DO);
});
});
describe('#removeObservable()', () => {
let fakeObserableModule = {
getObservable: () => null,
push: () => 1,
};
it('should exist', () => {
expect(typeof DO.removeObservable).toBe('function');
});
it('should return this', () => {
expect(DO.removeObservable('a')).toEqual(DO);
});
it('should remove a given observable', () => {
DO.addObservable('observable.key.remove', fakeObserableModule);
expect(DO._observables['observable.key.remove'].observable).toBe(null);
expect(DO._observables['observable.key.remove'].push()).toBe(1);
DO.removeObservable('observable.key.remove');
expect(DO._observables['observable.key.remove']).toBeUndefined();
});
it('should ignore an invalid key', () => {
expect(DO.removeObservable('asldkfjasdl')).toEqual(DO);
expect(DO.removeObservable(null)).toEqual(DO);
expect(DO.removeObservable(false)).toEqual(DO);
expect(DO.removeObservable(NaN)).toEqual(DO);
expect(DO.removeObservable()).toEqual(DO);
expect(DO.removeObservable(() => null)).toEqual(DO);
});
});
describe('#_observableExists()', () => {
let fakeObserableModule = {
getObservable: () => {
return {
subscribe: (next) => {
return {
next,
};
},
};
},
push: () => 1,
};
let fakeObserableModuleInvalid = {
getObservable: () => null,
push: () => 1,
};
it('should exist', () => {
expect(typeof DO._observableExists).toBe('function');
});
it('should return boolean', () => {
expect(typeof DO._observableExists('a')).toBe('boolean');
expect(typeof DO._observableExists('asdf')).toBe('boolean');
expect(typeof DO._observableExists()).toBe('boolean');
expect(typeof DO._observableExists('observable.key')).toBe('boolean');
});
it('should return true if valid observable exists', () => {
DO.addObservable('superkey.valid', fakeObserableModule);
expect(DO._observableExists('superkey.valid')).toBe(true);
DO.addObservable('superkey.invalid', fakeObserableModuleInvalid);
expect(DO._observableExists('superkey.invalid')).toBe(false);
expect(DO._observableExists()).toBe(false);
expect(DO._observableExists(null)).toBe(false);
});
});
describe('#_signatureExists()', () => {
let signature = null;
beforeAll(() => {
signature = new DataSignature('key');
DO.addSignature(signature);
});
it('should exist', () => {
expect(typeof DO._signatureExists).toBe('function');
});
it('should return boolean', () => {
expect(typeof DO._signatureExists('a')).toBe('boolean');
expect(typeof DO._signatureExists('asdf')).toBe('boolean');
expect(typeof DO._signatureExists()).toBe('boolean');
expect(typeof DO._signatureExists('observable.key')).toBe('boolean');
});
it('should return true if valid signature exists', () => {
expect(DO._signatureExists('key')).toBe(true);
expect(DO._signatureExists('inexist')).toBe(false);
expect(DO._signatureExists()).toBe(false);
expect(DO._signatureExists(null)).toBe(false);
expect(DO._signatureExists(NaN)).toBe(false);
expect(DO._signatureExists({})).toBe(false);
});
});
describe('#_addSubscription()', () => {
let subject = new Subject();
let subscription = subject.subscribe((next) => {
});
it('should exist', () => {
expect(typeof DO._addSubscription).toBe('function');
});
it('should return this', () => {
expect(DO._addSubscription('a')).toEqual(DO);
expect(DO._addSubscription(this, 'key', {})).toEqual(DO);
expect(DO._addSubscription()).toEqual(DO);
});
it('should store a given subscription', () => {
DO._addSubscription(this, 'mykey', subscription);
expect(DO._subscriptions.has(this)).toBe(true);
let foundOrigin = DO._subscriptions.get(this);
let foundKey = Array.from(foundOrigin)
.filter((entry) => {
return entry.key === 'mykey';
});
expect(foundKey.length).toBe(1);
});
});
describe('#getSubscription()', () => {
let subject = new Subject();
let subscription = subject.subscribe((next) => {
});
it('should exist', () => {
expect(typeof DO.getSubscription).toBe('function');
});
it('should return subscription or null', () => {
expect(DO.getSubscription('asdfa434fasdf')).toBe(null);
expect(DO.getSubscription(this, 'keyasf3')).toBe(null);
expect(DO.getSubscription()).toBe(null);
DO._addSubscription('origin', 'mykey2', subscription);
expect(DO.getSubscription('origin', 'mykey2')).toEqual(subscription);
DO._addSubscription('origin2', 'kokey', null);
expect(DO.getSubscription('origin2', 'kokey')).toEqual(null);
});
});
describe('#subscriptionExists()', () => {
let dummySubscription = null;
let subject = new Subject();
let subscription = subject.subscribe((next) => {
});
DO._addSubscription('originX', 'mykey2', subscription);
beforeAll(() => {
dummySubscription = DO.getSubscription('originX');
});
it('should exist', () => {
expect(typeof DO.subscriptionExists).toBe('function');
});
it('should return boolean', () => {
expect(typeof DO.subscriptionExists('a')).toBe('boolean');
expect(typeof DO.subscriptionExists('asdf')).toBe('boolean');
expect(typeof DO.subscriptionExists()).toBe('boolean');
expect(typeof DO.subscriptionExists('observable.key')).toBe('boolean');
expect(typeof DO.subscriptionExists('originX', 'mykey2')).toBe('boolean');
});
it('should return true if valid subscription exists', () => {
expect(DO.subscriptionExists(null)).toBe(false);
expect(DO.subscriptionExists(null, {})).toBe(false);
expect(DO.subscriptionExists()).toBe(false);
expect(DO.subscriptionExists('observable.key')).toBe(false);
expect(DO.subscriptionExists('originX', 'mykey2')).toBe(true);
});
});
describe(`#subscribe()`, () => {
let dummySubscription = null;
let subject = new Subject();
let subscription = subject.subscribe((next) => {
});
DO._addSubscription('originX', 'mykey2', subscription);
let signature = new DataSignature('signature.key');
DO.addSignature(signature);
/* eslint-disable space-before-function-paren */
let validSignature = new DataSignature('signature.valid', async () => {
return new DummyObservableModule({});
});
let validSignature2 = new DataSignature('signature.valid', async () => {
return new DummyObservableModule({});
});
/* eslint-enable space-before-function-paren */
DO.addSignature(validSignature);
beforeAll(() => {
dummySubscription = DO.getSubscription('originX');
});
it('should exist', () => {
expect(typeof DO.subscribe).toBe('function');
});
it('should return this', () => {
expect(DO.subscribe('originY', 'signature.valid', (next) => {
})).toEqual(DO);
expect(DO.subscribe('originZ', 'signature.valid.two', {
cool: () => {
},
}, (error) => {
}, (complete) => {
}, {})).toEqual(DO);
expect(DO.subscribe('a')).toEqual(DO);
});
});
describe(`#unsubscribeFrom()`, () => {
it('should exist', () => {
expect(typeof DO.unsubscribeFrom).toBe('function');
});
it('should return this', () => {
expect(DO.unsubscribeFrom()).toEqual(DO);
expect(DO.unsubscribeFrom('a')).toEqual(DO);
expect(DO.unsubscribeFrom('originX', 'signature.key', () => null, () => null, () => null)).toEqual(DO);
expect(DO.unsubscribeFrom('originX', 'signature.valid')).toEqual(DO);
expect(DO.unsubscribeFrom('originY', 'signature.valid')).toEqual(DO);
expect(DO.unsubscribeFrom('originZ', 'signature.valid')).toEqual(DO);
});
});
describe(`#unsubscribeAll()`, () => {
it('should exist', () => {
expect(typeof DO.unsubscribeAll).toBe('function');
});
it('should return this', () => {
expect(DO.unsubscribeAll()).toEqual(DO);
expect(DO.unsubscribeAll('asdfklauriasldkfjasldf')).toEqual(DO);
expect(DO.unsubscribeAll('originX', 'signature.key', () => null, () => null, () => null)).toEqual(DO);
expect(DO.unsubscribeAll('originX', 'signature.valid')).toEqual(DO);
expect(DO.unsubscribeAll('originY', 'signature.valid')).toEqual(DO);
expect(DO.unsubscribeAll('originZ', 'signature.valid')).toEqual(DO);
});
});
describe(`#unsubscribe()`, () => {
it('should exist', () => {
expect(typeof DO.unsubscribe).toBe('function');
});
it('should return this', () => {
expect(DO.unsubscribe()).toEqual(DO);
expect(DO.unsubscribe('asdfklauriasldkfjasldf')).toEqual(DO);
expect(DO.unsubscribe('originX', 'signature.key', () => null, () => null, () => null)).toEqual(DO);
expect(DO.unsubscribe('originX', 'signature.valid')).toEqual(DO);
expect(DO.unsubscribe('originY', 'signature.valid')).toEqual(DO);
expect(DO.unsubscribe('originZ', 'signature.valid')).toEqual(DO);
});
});
describe(`#pushTo()`, () => {
it('should exist', () => {
expect(typeof DO.pushTo).toBe('function');
});
it('should return this', () => {
expect(DO.pushTo()).toEqual(DO);
expect(DO.pushTo('signature.valid', 'message')).toEqual(DO);
expect(DO.pushTo('originX', 'signature.valid')).toEqual(DO);
expect(DO.pushTo(undefined, 'signature.valid')).toEqual(DO);
});
});
});
|
/*------------------------------------------------------------------*-
Main.c (v1.00)
------------------------------------------------------------------
TEST PROGRAM FOR LCD LIBRARY CODE
* Designed for 2-line x 20-character HD44780-based display
* '4-BIT' INTERFACE (uses 6 pins...)
* Requires T0 (for delays and timeouts)
Required linker options (see Chapter 14 for details):
OVERLAY (main ~ (Elapsed_Time_LCD_Update,LCD_Update),
Sch_Dispatch_Tasks ! (Elapsed_Time_LCD_Update,LCD_Update))
COPYRIGHT
---------
This code is from the book:
PATTERNS FOR TIME-TRIGGERED EMBEDDED SYSTEMS by Michael J. Pont
[Pearson Education, 2001; ISBN: 0-201-33138-1].
This code is copyright (c) 2001 by Michael J. Pont.
See book for copyright details and other information.
-*------------------------------------------------------------------*/
#include "Main.h"
#include "LCD_A.h"
#include "2_01_12g.h"
#include "Elap_LCD.h"
/* ............................................................... */
void main(void)
{
// Initialisation can be problematic with some display / supply
// combinations. You may get away with calling this function
// twice (or once) but - for maximum reliability under a very wide range
// of conditions - it is called three times here.
LCD_Init(0);
LCD_Init(0);
LCD_Init(1);
// Prepare the elapsed time library
Elapsed_Time_LCD_Init();
// Prepare the scheduler
SCH_Init_T2();
// Add tasks to the scheduler
//
// Update the time every second (*** 1ms sched ticks ***)
SCH_Add_Task(Elapsed_Time_LCD_Update, 100, 1000);
// Update the whole display ~ every second
// - do this by updating a character once every 24 ms
// (assumes a 40 character display)
SCH_Add_Task(LCD_Update, 1000, 24);
// All tasks added: start running the scheduler
SCH_Start();
while(1)
{
SCH_Dispatch_Tasks();
}
}
/*------------------------------------------------------------------*-
---- END OF FILE -------------------------------------------------
-*------------------------------------------------------------------*/
|
import { moneyMarket } from '@anchor-protocol/types';
import {
mantle,
MantleParams,
WasmQuery,
WasmQueryData,
} from '@terra-money/webapp-fns';
export interface EarnEpochStatesWasmQuery {
moneyMarketEpochState: WasmQuery<
moneyMarket.market.EpochState,
moneyMarket.market.EpochStateResponse
>;
overseerEpochState: WasmQuery<
moneyMarket.overseer.EpochState,
moneyMarket.overseer.EpochStateResponse
>;
}
export type EarnEpochStates = WasmQueryData<EarnEpochStatesWasmQuery>;
export type EarnEpochStatesQueryParams = Omit<
MantleParams<EarnEpochStatesWasmQuery>,
'query' | 'variables'
> & {
lastSyncedHeight: () => Promise<number>;
};
export async function earnEpochStatesQuery({
mantleEndpoint,
wasmQuery,
lastSyncedHeight,
...params
}: EarnEpochStatesQueryParams): Promise<EarnEpochStates> {
const blockHeight = await lastSyncedHeight();
wasmQuery.moneyMarketEpochState.query.epoch_state.block_height =
blockHeight + 1;
return mantle<EarnEpochStatesWasmQuery>({
mantleEndpoint: `${mantleEndpoint}?earn--epoch-states`,
variables: {},
wasmQuery,
...params,
});
}
|
// conditionVariableAtomic.cpp
#include <atomic>
#include <condition_variable>
#include <iostream>
#include <thread>
std::mutex mutex_;
std::condition_variable condVar;
std::atomic<bool> dataReady{false};
void waitingForWork(){
std::cout << "Waiting " << std::endl;
std::unique_lock<std::mutex> lck(mutex_);
condVar.wait(lck, []{ return dataReady.load(); }); // (1)
std::cout << "Running " << std::endl;
}
void setDataReady(){
dataReady = true;
std::cout << "Data prepared" << std::endl;
condVar.notify_one();
}
int main(){
std::cout << std::endl;
std::thread t1(waitingForWork);
std::thread t2(setDataReady);
t1.join();
t2.join();
std::cout << std::endl;
}
|
Monkeystone Games MPC file extractor
====================================
This small utility extracts the contents of a Monkeystone MPC file into
the current directory. MPC files are a proprietary archive file format,
found in several games made by Monkeystone. This tool was tested against
'Hyperspace Deilvery Boy' only, but I'm confident that it'll work with
other games, too.
MPC file format
---------------
The MPC file format is yet another variant of the popular PAK files,
found in several older games like Quake I and II. Every MPC file starts
with a header:
0 to 3: char[4] Signature, the little endian string 'MPUC'.
4 to 7: uint32_t Directory offset from the end of the header.
8 to 11: uint32_t Unknown fild, maybe some kinf of party bit.
The directory can be located anywhere in the file, but it's a good idea
to place it at the end. So you'll need only to rewrite the directory and
not the whole MPC file if you're adding data to it. The directory starts
with a field containing the number of files in the directory. Remember
to add 12 bytes for the file header:
start_of_file + 12 + directory_offset: uint32_t number of files
The directory itself is just a bunch of entries, starting right after
the 'number of files' field at:
start_of_file + 12 + directory_offset + 4: First directory entry
Each entry consists of 5 fields with a total of 80 bytes:
0 to 63: char[64] Filename.
64 to 67: uint32_t Fileposition from the start of the MPC file.
68 to 71: uint32_t Filelength in byte.
72 to 75: uint32_t Unknown, same as byte 68 to 71.
76 to 79: uint32_t Unknown, maybe some kind of parity bit.
Reading a MPC file is easy:
* Read the header and check it's signature.
* Locate the directory and read the number of files in it.
* Walk through the directory, read each entry.
* Use the entries data to extract the file.
|
module SolidusCrm
module Event
class Order < Base
def initialize(order, event)
@order = order
@event = event
end
def emit
SolidusCrm::Connection.post(
endpoint,
Rabl::Renderer.json(
@order,
template,
view_path: view_path,
scope: view_context
),
headers
)
end
private
def template
'spree/api/orders/show.v1'
end
def endpoint
'/orders'
end
def headers
{}
end
end
end
end
|
package xyz.nietongxue.mindkit.source
import com.beust.klaxon.JsonArray
import com.beust.klaxon.JsonObject
import com.beust.klaxon.Parser
import xyz.nietongxue.mindkit.io.XMindFile
import xyz.nietongxue.mindkit.model.MindMap
import xyz.nietongxue.mindkit.model.Node
//TODO 不同的source跟不同的app有没有什么关系。
//TODO 应该没有，app可能会统一到action机制。
class XMindSource(val path: String) : Source {
override val description: String = "来自于XMind文件 - $path"
override fun mount(tree: Node, mountPoint: Node): List<Mounting> {
val xMindFile = XMindFile(path)
// val watcher = FileWatcher(File(".")) { file: File, eventType: String ->
// println(file.path)
// println(eventType)
// }
// val watcher2 = FileWatcher(File("./ppt.xmind")) { file: File, eventType: String ->
// print("2-----")
// println(file.path)
// println(eventType)
// }
val content = xMindFile.content() ?: return emptyList()
val json = Parser().parse(content) as JsonArray<JsonObject>
val mm = MindMap.fromJson(json,this)
return listOf(Mounting(tree, listOf(mm.sheets[0].root)))
}
}
|
<?php
namespace RavenDB\Tests\Client\Driver;
use Exception;
use RavenDB\Client\Util\StringUtils;
use RavenDB\Client\Util\System;
class RavenServerLocator
{
public static string $ENV_SERVER_PATH = "RAVENDB_JAVA_TEST_SERVER_PATH";
/**
* @throws Exception
*/
public function getServerPath(): string
{
$path = System::getenv(self::$ENV_SERVER_PATH);
if (StringUtils::isBlank($path)) {
throw new Exception("Unable to find RavenDB server path. " .
"Please make sure " . self::$ENV_SERVER_PATH . " environment variable is set and is valid " .
"(current value = " . $path . ")");
}
return $path;
}
public function getCommand(): string
{
return $this->getServerPath();
}
public function getCommandArguments(): array
{
return [];
}
/**
* @return string
* @throws Exception
*/
public function getServerCertificatePath(): string
{
throw new Exception(null);
}
/**
* @return string
* @throws Exception
*/
public function getServerCaPath(): string
{
throw new Exception(null);
}
}
|
<script src="{{asset('admin/assets/js/ace-extra.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery-2.1.4.min.js')}}"></script>
<script src="{{asset('admin/assets/Loading/src/js/jquery.preloader.js')}}"></script>
<script src="{{asset('js/menu-Scripts/menu.min.js')}}"></script>
<script src="{{asset('admin/assets/js/bootstrap.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery-ui.custom.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery.ui.touch-punch.min.js')}}"></script>
<script src="{{asset('admin/assets/js/chosen.jquery.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery.dataTables.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery.dataTables.bootstrap.min.js')}}"></script>
<script src="{{asset('admin/assets/js/spinbox.min.js')}}"></script>
<script src="{{asset('admin/assets/js/bootstrap-datepicker.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery.jqGrid.min.js')}}"></script>
<script src="{{asset('admin/assets/js/grid.locale-en.js')}}"></script>
<script src="{{asset('admin/assets/js/bootstrap-timepicker.min.js')}}"></script>
<script src="{{asset('admin/assets/js/moment.min.js')}}"></script>
<script src="{{asset('admin/assets/js/daterangepicker.min.js')}}"></script>
<script src="{{asset('admin/assets/js/bootstrap-datetimepicker.min.js')}}"></script>
<script src="{{asset('admin/assets/js/bootstrap-colorpicker.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery.knob.min.js')}}"></script>
<script src="{{asset('admin/assets/js/autosize.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery.inputlimiter.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery.maskedinput.min.js')}}"></script>
<script src="{{asset('admin/assets/js/bootstrap-tag.min.js')}}"></script>
<script src="{{asset('admin/assets/js/ace-elements.min.js')}}"></script>
<script src="{{asset('admin/assets/js/ace.min.js')}}"></script>
<script src="{{asset('admin/assets/js/bootbox.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery.easypiechart.min.js')}}"></script>
<script src="{{asset('admin/assets/js/jquery.gritter.min.js')}}"></script>
<script src="{{asset('admin/assets/js/spin.js')}}"></script>
|
module.exports = zip = (...arrays) => {
const maxLength = Math.max(...arrays.map(x => x.length));
return Array.from({ length: maxLength }).map((_, i) => {
return Array.from({ length: arrays.length }, (_, k) => arrays[k][i]);
});
};
|
// RobotBuilder Version: 2.0
//
// This file was generated by RobotBuilder. It contains sections of
// code that are automatically generated and assigned by robotbuilder.
// These sections will be updated in the future when you export to
// C++ from RobotBuilder. Do not put any code or make any change in
// the blocks indicating autogenerated code or it will be lost on an
// update. Deleting the comments indicating the section will prevent
// it from being updated in the future.
////////////////////////////////////////////
// Conditional compilation flags
//
// Control behavior in autonomous mode
//
// #define USE_SELECTED_AUTO_CMD
// #define DISABLE_AUTO_MODE
//
// Control lighting system.
//
// #define DISABLE_LIGHTING
#define USE_LIVE_LIGHTING
//
// Control lighting system.
//
#define ENABLE_USB_CAMERA
////////////////////////////////////////////
// Include files
#include "Robot.h"
#include <cassert>
#include "RobotMap.h"
#include "Commands/AutonomousCommand.h"
#include "Commands/SpyBoxAutonmous.h"
#include "Commands/TankDrive.h"
#include "Commands/DashboardUpdater.h"
#include "Commands/TimedMove.h"
#if defined(DISABLE_LIGHTING)
#include "Lighting/LightingControl.h"
typedef NullLightingControl LightingController;
#elif defined(USE_LIVE_LIGHTING)
#include "Lighting/SerialLightingControl.h"
typedef SerialLightingControl LightingController;
#else
#include "Lighting/SimulatedLightingControl.h"
typedef SerialLightingControl LightingController;
#endif // DISABLE_LIGHTING
////////////////////////////////////////////
// "Real Code...."
// BEGIN AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=INITIALIZATION
std::shared_ptr<DriveSystem> Robot::driveSystem;
std::shared_ptr<Intake> Robot::intake;
std::shared_ptr<IntakeArm> Robot::intakeArm;
std::unique_ptr<OI> Robot::oi;
// END AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=INITIALIZATION
std::unique_ptr<LightingControl> Robot::lightingControl;
void Robot::RobotInit() {
RobotMap::init();
// BEGIN AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=CONSTRUCTORS
driveSystem.reset(new DriveSystem());
intake.reset(new Intake());
intakeArm.reset(new IntakeArm());
// END AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=CONSTRUCTORS
// This MUST be here. If the OI creates Commands (which it very likely
// will), constructing it during the construction of CommandBase (from
// which commands extend), subsystems are not guaranteed to be
// yet. Thus, their requires() statements may grab null pointers. Bad
// news. Don't move it.
oi.reset(new OI());
// Set up the autonomous command (if appropriate)
#if defined(DISABLE_AUTO_MODE) || defined(USE_SELECTED_AUTO_CMD)
autonomousCommand.reset(nullptr);
#else
// BEGIN AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=AUTONOMOUS
autonomousCommand.reset(new AutonomousCommand(0));
// END AUTOGENERATED CODE, SOURCE=ROBOTBUILDER ID=AUTONOMOUS
#endif
tankModeCommand.reset(new TankDrive);
// Set up lighting control
lightingControl.reset(new LightingController);
#ifdef ENABLE_USB_CAMERA
CameraServer::GetInstance()->SetQuality(50);
// The camera name (ex "cam0") can be found through the roborio web interface
CameraServer::GetInstance()->StartAutomaticCapture("cam0");
#endif //ENABLE_USB_CAMERA
}
/**
* This function is called when the disabled button is hit.
* You can use it to reset subsystems before shutting down.
*/
void Robot::DisabledInit() {
updateLighting();
}
void Robot::DisabledPeriodic() {
Scheduler::GetInstance()->Run();
updateLighting();
}
// CODE_REVIEW(mjh): What is this supposed to do?
int autoTimer;
void Robot::AutonomousInit() {
// Updating lighting display
updateLighting();
// Start the command for autonomous mode.
#if !defined(DISABLE_AUTO_MODE) && defined(USE_SELECTED_AUTO_CMD)
int chosenAuto = int(std::fmax(0, std::fmin(6, SmartDashboard::GetNumber("Auto Chooser", 2))));
if (chosenAuto < 6) {
autonomousCommand.reset(new AutonomousCommand(chosenAuto));
}
else if (chosenAuto == 6) {
autonomousCommand.reset(new SpyBoxAutonmous());
}
#elif !defined(DISABLE_AUTO_MODE)
// CODE_REVIEW(mjh): Why aren't you just setting this up during the
// initialization of the robot (in the constructor), rather than building
// a new command every single time?
autonomousCommand.reset(new TimedMove(4, 50));
#endif // !DISABLE_AUTO_MODE && USE_SELECTED_AUTO_CMD
if (autonomousCommand.get() != nullptr) {
autonomousCommand->Start();
}
}
void Robot::AutonomousPeriodic() {
updateLighting();
Scheduler::GetInstance()->Run();
}
void Robot::TeleopInit() {
updateLighting();
// This makes sure that the autonomous stops running when
// teleop starts running. If you want the autonomous to
// continue until interrupted by another command, remove
// these lines or comment it out.
if (autonomousCommand.get() != nullptr) {
autonomousCommand->Cancel();
}
tankModeCommand->Start();
}
void Robot::TeleopPeriodic() {
updateLighting();
Scheduler::GetInstance()->Run();
}
void Robot::TestInit() {
updateLighting();
}
void Robot::TestPeriodic() {
updateLighting();
}
void Robot::updateLighting() {
assert(lightingControl != nullptr);
if (lightingControl != nullptr) {
lightingControl->LightingUpkeep();
}
}
START_ROBOT_CLASS(Robot);
|
using UnityBuildTooling.Editor.build_tooling.Scripts.Runtime.Utils;
using UnityEditor;
namespace UnityBuildTooling.Editor.build_tooling.Scripts.Runtime.Actions
{
public static class BuildingAction
{
[MenuItem("Build/Build Project &F9", false, 0)]
public static void BuildProject()
{
AssetDatabase.SaveAssets();
UnityBuilding.Build(UnityBuilding.BuildBehavior.BuildOnly);
}
[MenuItem("Build/Build && Run Project %&F9", false, 1)]
public static void BuildAndRunProject()
{
AssetDatabase.SaveAssets();
UnityBuilding.Build(UnityBuilding.BuildBehavior.BuildAndRun);
}
[MenuItem("Build/Build Scripts Only #F8", false, 2)]
public static void ScriptsOnlyProject()
{
AssetDatabase.SaveAssets();
UnityBuilding.Build(UnityBuilding.BuildBehavior.BuildScriptsOnly);
}
}
}
|
// Copyright 2014 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:stack_trace/stack_trace.dart' as stack_trace;
Future<void> main() async {
test('demangles stacks', () async {
// Test that the tester bindings unmangle stacks that come in as
// package:stack_trace types.
// Uses runTest directly so that the test does not get hung up waiting for
// the error reporter to be reset to the original one.
final Completer<FlutterErrorDetails> errorCompleter = Completer<FlutterErrorDetails>();
final TestExceptionReporter oldReporter = reportTestException;
reportTestException = (FlutterErrorDetails details, String testDescription) {
errorCompleter.complete(details);
reportTestException = oldReporter;
};
final AutomatedTestWidgetsFlutterBinding binding = AutomatedTestWidgetsFlutterBinding();
await binding.runTest(() async {
final Completer<String> completer = Completer<String>();
completer.future.then(
(String value) {},
onError: (Object error, StackTrace stack) {
assert(stack is stack_trace.Chain);
FlutterError.reportError(FlutterErrorDetails(
exception: error,
stack: stack,
));
}
);
completer.completeError(const CustomException());
}, () { });
final FlutterErrorDetails details = await errorCompleter.future;
expect(details, isNotNull);
expect(details.exception, isA<CustomException>());
reportTestException = oldReporter;
});
}
class CustomException implements Exception {
const CustomException();
}
|
<?php
namespace Suitcore\Notification\Adapters\GcmAdapter;
use Suitcore\Notification\Adapters\GcmAdapter\GcmNotifierAdapter as Adapter;
use Suitcore\Notification\Contracts\NotifierRecipientsInterface as Recipients;
use Suitcore\Notification\Adapters\GcmAdapter\GcmRecipientInterface;
use Illuminate\Support\Collection;
/**
*
*/
class GcmRecipients implements Recipients
{
protected $recipients = [];
public function setRecipients($recipients)
{
// if not array recipients and not collection, then make them array
if (!is_array($recipients) && ! $recipients instanceof Collection) $recipients = [$recipients];
foreach ($recipients as $recipient) {
// make sure they implement GcmRecipientInterface interface
if ($recipient instanceof GcmRecipientInterface)
{
if (count($recipient->gcmIds) == 0) continue;
foreach ($recipient->gcmIds as $gcmId) {
$this->recipients[] = $gcmId;
$gcmId->updateLastUsed();
}
}
}
return $this;
}
/**
* [getRecipientObj description]
* @param integer $index [description]
* @param [type] $limit [description]
* @return [type] [description]
*/
public function getRecipientObj($index = 0)
{
return $this->recipients[$index];
}
/**
* [getRecipientObjs description]
* @param integer $index [description]
* @param [type] $limit [description]
* @return [type] [description]
*/
public function getRecipientObjs($index = 0, $limit = null)
{
return array_slice($this->recipients, $index, $limit);
}
/**
* [getRecipients description]
* @param integer $index [description]
* @param [type] $limit [description]
* @return [type] [description]
*/
public function getRecipients($index = 0, $limit = null)
{
$result = [];
foreach ($this->getRecipientObjs($index, $limit) as $item) {
$result[] = $item->gcm_registration_id;
}
return $result;
}
public function toArray()
{
return $this->getRecipients();
}
}
|
require_relative 'user/list_command'
require_relative 'user/add_command'
require_relative 'user/remove_command'
class Kontena::Plugin::Cloud::Organization::UserCommand < Kontena::Command
include Kontena::Plugin::Cloud::Organization
subcommand ['list', 'ls'], 'List organizations', User::ListCommand
subcommand 'add', 'Add users to organization', User::AddCommand
subcommand ['remove', 'rm'], 'Remove users from organization', User::RemoveCommand
def execute
end
end
|
const t = require('../test-lib/test.js');
const assert = require('assert');
let apos;
const mockImages = [
{
type: '@apostrophecms/image',
slug: 'image-1',
visibility: 'public',
attachment: {
extension: 'jpg',
width: 500,
height: 400
}
},
{
type: '@apostrophecms/image',
slug: 'image-2',
visibility: 'public',
attachment: {
extension: 'jpg',
width: 500,
height: 400
}
},
{
type: '@apostrophecms/image',
slug: 'image-3',
visibility: 'public',
attachment: {
extension: 'jpg',
width: 150,
height: 150
}
},
{
type: '@apostrophecms/image',
slug: 'image-4',
visibility: 'public',
attachment: {
extension: 'svg'
}
}
];
describe('Images', function() {
this.timeout(t.timeout);
after(function() {
return t.destroy(apos);
});
it('should be a property of the apos object', async function() {
this.timeout(t.timeout);
this.slow(2000);
apos = await t.create({
root: module
});
assert(apos.image);
assert(apos.image.__meta.name === '@apostrophecms/image');
});
// Test pieces.list()
it('should clean up any existing images for testing', async function() {
try {
const response = await apos.doc.db.deleteMany({ type: '@apostrophecms/image' }
);
assert(response.result.ok === 1);
} catch (e) {
assert(false);
}
});
it('should add images for testing', async function() {
assert(apos.image.insert);
const req = apos.task.getReq();
const insertPromises = mockImages.map(async (image) => {
return apos.image.insert(req, image);
});
const inserted = await Promise.all(insertPromises);
assert(inserted.length === mockImages.length);
assert(inserted[0]._id);
});
it('should respect minSize filter (svg is always OK)', async function() {
const req = apos.task.getAnonReq();
const images = await apos.image.find(req).minSize([ 200, 200 ]).toArray();
assert(images.length === 3);
});
it('should respect minSize filter in toCount, which uses a cloned cursor', async function() {
const req = apos.task.getAnonReq();
const count = await apos.image.find(req).minSize([ 200, 200 ]).toCount();
assert(count === 3);
});
it('should generate a srcset string for an image', function() {
const srcset = apos.image.srcset({
name: 'test',
_id: 'test',
extension: 'jpg',
width: 1200,
height: 800
});
assert.strictEqual(srcset, [ '/uploads/attachments/test-test.max.jpg 1200w',
'/uploads/attachments/test-test.full.jpg 1140w',
'/uploads/attachments/test-test.two-thirds.jpg 760w',
'/uploads/attachments/test-test.one-half.jpg 570w',
'/uploads/attachments/test-test.one-third.jpg 380w',
'/uploads/attachments/test-test.one-sixth.jpg 190w' ].join(', '));
});
it('should not generate a srcset string for an SVG image', function() {
const srcset = apos.image.srcset({
name: 'test',
_id: 'test',
extension: 'svg',
width: 1200,
height: 800
});
assert.strictEqual(srcset, '');
});
});
|
# MetaCentrum Accounting Tool
This project contains command-line tools for
* storing data about physical machines and users comming from Perun
* computing daily statistics
|
using System;
using System.Drawing;
namespace calculate_yiq
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(getContrastYIQ("#212121"));
}
static string getContrastYIQ(string hexColor)
{
var color = ColorTranslator.FromHtml(hexColor);
var yiq = ((color.R * 299) + (color.G * 587) + (color.B * 114)) / 1000;
return yiq >= 128 ? "#000000" : "#FFFFFF";
}
}
}
|
import { Entity, FindOneOptions, getConnection, Like, QueryRunner } from 'typeorm';
import { OrmRepository } from 'typeorm-typedi-extensions';
import axios from 'axios';
import _ from 'lodash';
import uuid from 'uuid';
import { HttpError } from 'routing-controllers';
import { FarmDashBoardResponse } from '../../controllers/responses';
import { Logger, LoggerInterface } from '../../../decorators/Logger';
import {
AreaRepository,
ProductRepository,
FarmRepository,
ProcessRepository,
ProductObjectRepository,
LocationRepository, SectionRepository
} from '../../repositories';
import {
Area, Product, Farm, ProductObject, Process, Media, TargetType, MediaAble,
// MediaAble
} from '../../models';
import { CListData, ICrudOption } from '../index';
import { DbHelper } from '../common/DbHelper';
import { env } from '../../../env';
import { Helper } from '../../../common';
@Entity()
export class FarmService {
constructor(
@OrmRepository()
private farmRepository: FarmRepository,
@OrmRepository()
private categoryRepository: ProductRepository,
@OrmRepository()
private areaRepository: AreaRepository,
@OrmRepository()
private productObjectRepository: ProductObjectRepository,
@OrmRepository()
private processRepository: ProcessRepository,
@OrmRepository()
private sectionRepository: SectionRepository,
@OrmRepository()
private locationRepository: LocationRepository,
private dbHelper: DbHelper,
@Logger(__filename) private log: LoggerInterface
) {}
public async find(
option: ICrudOption = {}
): Promise<CListData<Farm> | undefined> {
this.log.info('Find all farm');
return this.dbHelper.findAndCount(this.farmRepository, option);
}
public async getValidCodeInTransaction(
queryRunner: QueryRunner,
farm: Farm
): Promise<string> {
const location = await this.locationRepository.findOne(farm.locationID);
if (!location) {
throw new HttpError(400, 'locationID is invalid');
}
const [provinceCode, nameCode] = await Promise.all([
Helper.combineFirstCharacterAndLastWord(location.province),
Helper.combineFirstCharacterAndLastWord(farm.name),
]);
const prefixCode = `${provinceCode}-${nameCode}`;
const findOneOptions: FindOneOptions<Farm> = {
where: { code: Like(`${prefixCode}%`) },
order: { createdAt: 'DESC' },
select: ['code'],
};
return this.dbHelper.getValidCodeInTransaction(queryRunner, Farm, findOneOptions, prefixCode, 4);
}
public async create(
farm: Farm,
medias: any[],
token: string,
option: ICrudOption = {}): Promise<Farm> {
this.log.info('Create a new farm');
farm.id = uuid.v1();
farm.productsTotal = 0;
const queryRunner = getConnection().createQueryRunner();
await queryRunner.connect();
await queryRunner.startTransaction('SERIALIZABLE');
try {
farm.code = await this.getValidCodeInTransaction(queryRunner, farm);
const result = await queryRunner.manager.save(farm);
if (medias && medias.length !== 0) {
let awaiter = [];
// 0: image, 1: video, 2: document
for (const media of medias) {
const mediaEntity = new Media();
mediaEntity.id = uuid.v1();
mediaEntity.type = media.type;
mediaEntity.url = media.url;
mediaEntity.urlThumbnail = media.urlThumbnail;
awaiter.push(queryRunner.manager.save(mediaEntity));
}
const mediaEntities = await Promise.all(awaiter);
const targetType = await queryRunner.manager.findOne(TargetType, { name: 'farm'});
awaiter = [];
for (const mediaEntity of mediaEntities) {
const mediaAble = new MediaAble();
mediaAble.id = uuid.v1();
mediaAble.targetID = result.id;
mediaAble.targetTypeID = targetType.id;
mediaAble.mediaID = mediaEntity.id;
awaiter.push(queryRunner.manager.save(mediaAble));
}
await Promise.all(awaiter);
}
// sync farm ID amd user ID in Identity Service
const identResponse = await axios.create({baseURL: env.farmhub.identityService})({
url: '/farm',
headers: {'Token-ID': token},
method: 'POST',
data: {farmId: farm.id, userId: farm.userID},
});
const isVerifiedPhoneNumber = identResponse.data.data.isVerifiedPhoneNumber as boolean;
if (isVerifiedPhoneNumber) {
await queryRunner.manager.update(Farm, farm.id, { isVerifiedPhoneNumber: true });
result.isVerifiedPhoneNumber = true;
}
await queryRunner.commitTransaction();
return result;
} catch (err: any) {
await queryRunner.rollbackTransaction();
if (err.response) {
this.log.error(`[Identity Service response] ${err.response.status} ${err.response.data.message}`);
throw new HttpError(500, err.response.data.message + ' at IdentityService');
} else {
throw err;
}
} finally {
await queryRunner.release();
}
}
public async findOne(id: string, option: ICrudOption = {}): Promise<Farm | undefined> {
this.log.info('Find one farm');
return this.dbHelper.findOne(this.farmRepository, id, option);
}
public async findOneDashboard(id: string, option: ICrudOption = {}): Promise<FarmDashBoardResponse | undefined> {
this.log.info('Find one farm dash board');
const result = await Promise.all([
this.areaRepository.count({where: { farmID: id}}),
this.dbHelper.count(this.productObjectRepository, {where: {product: { farmID: id}}}),
this.dbHelper.count(this.sectionRepository, {where: {process: {farmID: id}}}),
]);
return {
id,
areasTotal: result[0],
productObjectsTotal: result[1],
sectionsTotal: result[2],
};
}
public async update(
id: string,
farm: Farm,
option?: ICrudOption
): Promise<Farm | undefined> {
this.log.info('Update some fields a farm');
delete farm.productsTotal;
await this.farmRepository.update(id, farm);
return this.farmRepository.findOne(id);
}
public async delete(
id: string,
option?: ICrudOption
): Promise<Farm | undefined> {
this.log.info('Delete a farm');
const item = await this.farmRepository.findOne(id);
if (item === undefined) {
return undefined;
}
await this.farmRepository.delete(id);
return item;
}
public async getProducts(
id: string,
option?: ICrudOption
): Promise<CListData<Product> | undefined> {
this.log.info('Get products of farm');
const [items, count] = await this.categoryRepository.findAndCount({
select: option.select,
where: {
farmID: id,
...option.where,
},
relations: option.relations,
skip: option.skip,
take: option.take,
order: option.order,
});
return {
list: items,
count,
};
}
public async getAreas(
id: string,
option?: ICrudOption
): Promise<CListData<Area> | undefined> {
this.log.info('Get areas of farm');
const [items, count] = await this.areaRepository.findAndCount({
select: option.select,
where: {
farmID: id,
...option.where,
},
relations: option.relations,
skip: option.skip,
take: option.take,
order: option.order,
});
return {
list: items,
count,
};
}
public async getProductObjects(
id: string,
option?: ICrudOption
): Promise<CListData<ProductObject> | undefined> {
this.log.info('Get product objects of farm');
const [items, count] = await this.productObjectRepository.findAndCount({
select: option.select,
where: {
farmID: id,
...option.where,
},
relations: option.relations,
skip: option.skip,
take: option.take,
order: option.order,
});
return {
list: items,
count,
};
}
public async getProcesses(
id: string,
option?: ICrudOption
): Promise<CListData<Process> | undefined> {
this.log.info('Get processes of farm');
const [items, count] = await this.processRepository.findAndCount({
select: option.select,
where: {
farmID: id,
...option.where,
},
relations: option.relations,
skip: option.skip,
take: option.take,
order: option.order,
});
return {
list: items,
count,
};
}
}
|
// https://www.youtube.com/watch?v=H-9jCNhLe-Q
const particles = [];
function setup() {
let canvas = createCanvas(740, 500);
const particlesLength = Math.floor(width / 10);
for (let i = 0; i < particlesLength; i++) {
particles.push(new Particle());
}
}
function draw() {
background(55, 100, 144);
particles.forEach((p, index) => {
p.update();
p.draw();
p.checkParticles(particles);
// p.checkParticles(particles.slice(index));
});
// })
}
class Particle {
constructor() {
this.pos = createVector(random(width), random(height));
// this.size = random(3, 10);
this.size = 6;
this.vel = createVector(random(-2, 2), random(-2, 2));
this.numConnections = 0;
}
draw() {
noStroke();
fill("rgba(255,255,255,0.5)");
if (this.numConnections > 0) {
this.size = this.numConnections * 5;
} else {
this.size = 5;
}
circle(this.pos.x, this.pos.y, this.size);
}
update() {
this.pos.add(this.vel);
this.edges();
}
edges() {
if (this.pos.x < 0 || this.pos.x > width) {
this.vel.x *= -1;
}
if (this.pos.y < 0 || this.pos.y > height) {
this.vel.y *= -1;
}
}
checkParticles(particles) {
particles.forEach((particle) => {
const d = dist(this.pos.x, this.pos.y, particle.pos.x, particle.pos.y);
if (d < 70) {
stroke("rgba(255,255,255,0.5)");
line(this.pos.x, this.pos.y, particle.pos.x, particle.pos.y);
this.numConnections += 1;
particle.numConnections += 1;
} else {
if (this.numConnections > 0) {
this.numConnections -= 1;
}
}
});
}
}
|
// wengwengweng
use super::*;
/// Mesh Data with Vertices & Indices
#[derive(Clone, Serialize, Deserialize)]
pub struct MeshData {
pub vertices: Vec<Vertex>,
pub indices: Vec<u32>,
}
/// A Buffered GPU Mesh
#[derive(Clone, PartialEq)]
pub struct Mesh {
vbuf: VertexBuffer<Vertex>,
ibuf: IndexBuffer,
count: usize,
}
impl Mesh {
/// create a mesh from vertices and indices
pub fn new(ctx: &impl GLCtx, verts: &[Vertex], indices: &[u32]) -> Result<Self> {
let vbuf = VertexBuffer::<Vertex>::from(ctx, &verts)?;
let ibuf = IndexBuffer::from(ctx, &indices)?;
return Ok(Self {
vbuf,
ibuf,
count: indices.len(),
});
}
/// create a mesh from [`MeshData`](struct.MeshData.html)
pub fn from_meshdata(ctx: &impl GLCtx, data: &MeshData) -> Result<Self> {
return Self::new(ctx, &data.vertices, &data.indices);
}
pub(super) fn vbuf(&self) -> &VertexBuffer<Vertex> {
return &self.vbuf;
}
pub(super) fn ibuf(&self) -> &IndexBuffer {
return &self.ibuf;
}
pub(super) fn count(&self) -> usize {
return self.count;
}
}
|
using Microsoft.Build.Logging.StructuredLogger;
using Xunit;
namespace StructuredLogger.Tests
{
public class ItemGroupParserTests
{
[Fact]
public void AddItemWithMultilineMetadata()
{
var result = ItemGroupParser.ParsePropertyOrItemList(@"Added Item(s):
Link=
tmp
AcceptableNonZeroExitCodes=
AdditionalDependencies=kernel32.lib;user32.lib;
;", MessageProcessor.OutputItemsMessagePrefix, new StringCache());
}
}
}
|
using System.ComponentModel.DataAnnotations;
namespace SESMTTech.Gestor.RazorPages.RestClients.Cipas.Reunioes
{
public class ReunioesAtasAusentesPut
{
[Required]
public JustificativaAusencia? Justificativa { get; set; }
}
}
|
package seedu.mycrm.logic.parser.products;
import static java.util.Objects.requireNonNull;
import static seedu.mycrm.commons.core.Messages.MESSAGE_INVALID_COMMAND_FORMAT;
import static seedu.mycrm.logic.parser.CliSyntax.PREFIX_PRODUCT_DESCRIPTION;
import static seedu.mycrm.logic.parser.CliSyntax.PREFIX_PRODUCT_MANUFACTURER;
import static seedu.mycrm.logic.parser.CliSyntax.PREFIX_PRODUCT_NAME;
import static seedu.mycrm.logic.parser.CliSyntax.PREFIX_PRODUCT_TYPE;
import java.util.Optional;
import seedu.mycrm.commons.core.index.Index;
import seedu.mycrm.logic.commands.products.EditProductCommand;
import seedu.mycrm.logic.parser.ArgumentMultimap;
import seedu.mycrm.logic.parser.ArgumentTokenizer;
import seedu.mycrm.logic.parser.Parser;
import seedu.mycrm.logic.parser.ParserUtil;
import seedu.mycrm.logic.parser.exceptions.ParseException;
import seedu.mycrm.model.product.Description;
import seedu.mycrm.model.product.Manufacturer;
import seedu.mycrm.model.product.ProductName;
import seedu.mycrm.model.product.Type;
/** Parses input arguments and creates a EditProductCommand object. */
public class EditProductCommandParser implements Parser<EditProductCommand> {
private EditProductCommand.EditProductDescriptor descriptor;
private ArgumentMultimap map;
/**
* Parses the given {@code String} of arguments in the context of the {@code EditProductCommand}
* and returns a {@code EditProductCommand} object for execution.
*
* @throws ParseException if the user input does not conform to the expected format.
*/
@Override
public EditProductCommand parse(String args) throws ParseException {
requireNonNull(args);
this.map = ArgumentTokenizer.tokenize(args, PREFIX_PRODUCT_NAME, PREFIX_PRODUCT_TYPE,
PREFIX_PRODUCT_MANUFACTURER, PREFIX_PRODUCT_DESCRIPTION);
Index index;
try {
index = ParserUtil.parseIndex(map.getPreamble());
} catch (ParseException e) {
throw new ParseException(
String.format(MESSAGE_INVALID_COMMAND_FORMAT, EditProductCommand.MESSAGE_USAGE), e);
}
descriptor = new EditProductCommand.EditProductDescriptor();
editName();
editType();
editManufacturer();
editDescription();
if (!descriptor.isAnyFieldEdited()) {
throw new ParseException(EditProductCommand.MESSAGE_NOT_EDITED);
}
return new EditProductCommand(index, descriptor);
}
private void editName() {
Optional<String> nameWrapper = map.getValue(PREFIX_PRODUCT_NAME);
if (nameWrapper.orElse("").length() > 0) {
// name is not empty
descriptor.setProductName(ProductName.getName(nameWrapper));
}
}
private void editType() {
descriptor.setType(
Type.getType(map.getValue(PREFIX_PRODUCT_TYPE)));
}
private void editManufacturer() {
descriptor.setManufacturer(
Manufacturer.getManufacturer(map.getValue(PREFIX_PRODUCT_MANUFACTURER)));
}
private void editDescription() {
descriptor.setDescription(
Description.getDescription(map.getValue(PREFIX_PRODUCT_DESCRIPTION)));
}
}
|
import os
cwd = os.path.dirname(os.path.realpath(__file__))
class APKDecompile:
def __init__( self, apkfile ):
self.apkfile = apkfile
def inFolder(self,folder):
os.system(cwd+'/needs/jadx/bin/jadx -d '+str(folder)+' '+str(self.apkfile))
|
# lens
A simple PNG decoder
## Usage
```
npm start
```
# References
https://www.w3.org/TR/PNG
https://en.wikipedia.org/wiki/Portable_Network_Graphics
https://github.com/arian/pngjs
http://yahoo.github.io/pngjs-image/
|
package com.desertkun.brainout.playstate.special;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.utils.Array;
import com.desertkun.brainout.BrainOutServer;
import com.desertkun.brainout.client.Client;
import com.desertkun.brainout.content.active.Active;
import com.desertkun.brainout.data.Map;
import com.desertkun.brainout.data.active.ActiveData;
import com.desertkun.brainout.data.active.PlayerData;
import com.desertkun.brainout.data.components.RandomJumpComponentData;
import com.desertkun.brainout.data.components.ServerPickupCallbackComponentData;
import com.desertkun.brainout.mode.GameMode;
public class CandiesGame extends SpecialGame
{
private static Array<String> candies = new Array<>(new String[]{
"active-candy-1",
"active-candy-2",
"active-candy-3"
});
@Override
public void init()
{
}
@Override
public void onClientDeath(Client client, PlayerData playerData)
{
GameMode mode = BrainOutServer.Controller.getGameMode();
if (mode == null)
return;
switch (mode.getID())
{
case editor:
case editor2:
case free:
case lobby:
{
return;
}
}
Map map = playerData.getMap();
if (map == null)
return;;
int amount = MathUtils.random(3, 5);
for (int i = 0; i < amount; i++)
{
Active candy = BrainOutServer.ContentMgr.get(candies.random(), Active.class);
ActiveData data = candy.getData(map.getDimension());
ServerPickupCallbackComponentData callback = data.getComponent(ServerPickupCallbackComponentData.class);
if (callback != null)
{
callback.setCallback(picker -> picker.addStat("candies", 1));
}
data.setPosition(playerData.getX(), playerData.getY());
RandomJumpComponentData j = data.getComponent(RandomJumpComponentData.class);
j.jump(true);
map.addActive(map.generateServerId(), data, true);
}
}
@Override
public void release()
{
}
}
|
# CoreWatcher
Automation tool for .core file stack analyse
|
require 'spec_helper'
describe Blather do
describe "while accessing to Logger object" do
it "should return a Logger instance" do
expect(Blather.logger).to be_instance_of Logger
end
end
end
|
class Order < ApplicationRecord
belongs_to :driver, :foreign_key => 'driver_id'
belongs_to :user, :foreign_key => 'user_id'
end
|
--
-- PostgreSQL database dump
--
-- Dumped from database version 9.6.5
-- Dumped by pg_dump version 9.6.6
-- Started on 2018-01-17 07:25:58 CET
SET statement_timeout = 0;
SET lock_timeout = 0;
SET idle_in_transaction_session_timeout = 0;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = on;
SET check_function_bodies = false;
SET client_min_messages = warning;
SET row_security = off;
--
-- TOC entry 1 (class 3079 OID 12390)
-- Name: plpgsql; Type: EXTENSION; Schema: -; Owner:
--
CREATE EXTENSION IF NOT EXISTS plpgsql WITH SCHEMA pg_catalog;
--
-- TOC entry 2170 (class 0 OID 0)
-- Dependencies: 1
-- Name: EXTENSION plpgsql; Type: COMMENT; Schema: -; Owner:
--
COMMENT ON EXTENSION plpgsql IS 'PL/pgSQL procedural language';
SET search_path = public, pg_catalog;
--
-- TOC entry 185 (class 1259 OID 16386)
-- Name: app_app_id_seq; Type: SEQUENCE; Schema: public; Owner: linuxstore
--
CREATE SEQUENCE app_app_id_seq
START WITH 3052
INCREMENT BY 1
NO MINVALUE
NO MAXVALUE
CACHE 1;
ALTER TABLE app_app_id_seq OWNER TO linuxstore;
SET default_tablespace = '';
SET default_with_oids = false;
--
-- TOC entry 188 (class 1259 OID 16399)
-- Name: app; Type: TABLE; Schema: public; Owner: linuxstore
--
CREATE TABLE app (
app_id integer DEFAULT nextval('app_app_id_seq'::regclass) NOT NULL,
name character varying(128),
summary character varying(1024),
description character varying(4096),
project_license character varying(1024),
homepage_url character varying(2048),
bugtracker_url character varying(2048),
current_release_version character varying,
flatpak_repo_id integer,
flatpak_app_id character varying(128),
first_release_date timestamp with time zone,
first_release_version character varying(1024),
current_release_date timestamp with time zone,
rating double precision,
rating_votes integer
);
ALTER TABLE app OWNER TO linuxstore;
--
-- TOC entry 189 (class 1259 OID 40970)
-- Name: app_category; Type: TABLE; Schema: public; Owner: linuxstore
--
CREATE TABLE app_category (
app_id integer NOT NULL,
category_id integer NOT NULL
);
ALTER TABLE app_category OWNER TO linuxstore;
--
-- TOC entry 191 (class 1259 OID 41004)
-- Name: category; Type: TABLE; Schema: public; Owner: linuxstore
--
CREATE TABLE category (
category_id integer NOT NULL,
name character varying(256) NOT NULL
);
ALTER TABLE category OWNER TO linuxstore;
--
-- TOC entry 190 (class 1259 OID 41002)
-- Name: category_category_id_seq; Type: SEQUENCE; Schema: public; Owner: linuxstore
--
CREATE SEQUENCE category_category_id_seq
START WITH 1
INCREMENT BY 1
NO MINVALUE
NO MAXVALUE
CACHE 1;
ALTER TABLE category_category_id_seq OWNER TO linuxstore;
--
-- TOC entry 2171 (class 0 OID 0)
-- Dependencies: 190
-- Name: category_category_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: linuxstore
--
ALTER SEQUENCE category_category_id_seq OWNED BY category.category_id;
--
-- TOC entry 186 (class 1259 OID 16388)
-- Name: flatpak_repo_flatpak_repo_id_seq; Type: SEQUENCE; Schema: public; Owner: linuxstore
--
CREATE SEQUENCE flatpak_repo_flatpak_repo_id_seq
START WITH 32
INCREMENT BY 1
NO MINVALUE
NO MAXVALUE
CACHE 1;
ALTER TABLE flatpak_repo_flatpak_repo_id_seq OWNER TO linuxstore;
--
-- TOC entry 187 (class 1259 OID 16390)
-- Name: flatpak_repo; Type: TABLE; Schema: public; Owner: linuxstore
--
CREATE TABLE flatpak_repo (
flatpak_repo_id integer DEFAULT nextval('flatpak_repo_flatpak_repo_id_seq'::regclass) NOT NULL,
name character varying(128),
description character varying(1024),
url character varying(2048),
homepage_url character varying(2048),
default_branch character varying(128),
gpgkey character varying(16384),
download_flatpakrepo_url character varying(2048)
);
ALTER TABLE flatpak_repo OWNER TO linuxstore;
--
-- TOC entry 193 (class 1259 OID 49156)
-- Name: screenshot; Type: TABLE; Schema: public; Owner: linuxstore
--
CREATE TABLE screenshot (
screenshot_id integer NOT NULL,
thumb_url character varying(2048),
img_mobile_url character varying(2048),
img_desktop_url character varying(2048),
app_id integer NOT NULL
);
ALTER TABLE screenshot OWNER TO linuxstore;
--
-- TOC entry 192 (class 1259 OID 49154)
-- Name: screenshot_screenshot_id_seq; Type: SEQUENCE; Schema: public; Owner: linuxstore
--
CREATE SEQUENCE screenshot_screenshot_id_seq
START WITH 1
INCREMENT BY 1
NO MINVALUE
NO MAXVALUE
CACHE 1;
ALTER TABLE screenshot_screenshot_id_seq OWNER TO linuxstore;
--
-- TOC entry 2029 (class 2604 OID 41007)
-- Name: category category_id; Type: DEFAULT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY category ALTER COLUMN category_id SET DEFAULT nextval('category_category_id_seq'::regclass);
--
-- TOC entry 2033 (class 2606 OID 16407)
-- Name: app app_pkey; Type: CONSTRAINT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY app
ADD CONSTRAINT app_pkey PRIMARY KEY (app_id);
--
-- TOC entry 2037 (class 2606 OID 41017)
-- Name: category category_name_unique; Type: CONSTRAINT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY category
ADD CONSTRAINT category_name_unique UNIQUE (name);
--
-- TOC entry 2039 (class 2606 OID 41009)
-- Name: category category_pkey; Type: CONSTRAINT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY category
ADD CONSTRAINT category_pkey PRIMARY KEY (category_id);
--
-- TOC entry 2031 (class 2606 OID 16398)
-- Name: flatpak_repo flatpak_repo_pkey; Type: CONSTRAINT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY flatpak_repo
ADD CONSTRAINT flatpak_repo_pkey PRIMARY KEY (flatpak_repo_id);
--
-- TOC entry 2042 (class 2606 OID 49163)
-- Name: screenshot screenshot_pkey; Type: CONSTRAINT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY screenshot
ADD CONSTRAINT screenshot_pkey PRIMARY KEY (screenshot_id);
--
-- TOC entry 2034 (class 1259 OID 40984)
-- Name: fki_app_category_app_id_fkey; Type: INDEX; Schema: public; Owner: linuxstore
--
CREATE INDEX fki_app_category_app_id_fkey ON app_category USING btree (app_id);
--
-- TOC entry 2035 (class 1259 OID 41015)
-- Name: fki_app_category_category_id_fkey; Type: INDEX; Schema: public; Owner: linuxstore
--
CREATE INDEX fki_app_category_category_id_fkey ON app_category USING btree (category_id);
--
-- TOC entry 2040 (class 1259 OID 49169)
-- Name: fki_screenshot_app_id_fkey; Type: INDEX; Schema: public; Owner: linuxstore
--
CREATE INDEX fki_screenshot_app_id_fkey ON screenshot USING btree (app_id);
--
-- TOC entry 2044 (class 2606 OID 40985)
-- Name: app_category app_category_app_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY app_category
ADD CONSTRAINT app_category_app_id_fkey FOREIGN KEY (app_id) REFERENCES app(app_id);
--
-- TOC entry 2045 (class 2606 OID 41010)
-- Name: app_category app_category_category_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY app_category
ADD CONSTRAINT app_category_category_id_fkey FOREIGN KEY (category_id) REFERENCES category(category_id);
--
-- TOC entry 2043 (class 2606 OID 16408)
-- Name: app app_flatpak_repo_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY app
ADD CONSTRAINT app_flatpak_repo_id_fkey FOREIGN KEY (flatpak_repo_id) REFERENCES flatpak_repo(flatpak_repo_id);
--
-- TOC entry 2046 (class 2606 OID 49164)
-- Name: screenshot screenshot_app_id_fkey; Type: FK CONSTRAINT; Schema: public; Owner: linuxstore
--
ALTER TABLE ONLY screenshot
ADD CONSTRAINT screenshot_app_id_fkey FOREIGN KEY (app_id) REFERENCES app(app_id);
-- Completed on 2018-01-17 07:25:58 CET
--
-- PostgreSQL database dump complete
--
|
#ifndef SEARCHER_H
#define SEARCHER_H
#include <string>
#include <vector>
class Searcher
{
public:
virtual bool search(std::string text, bool isCompleteLine) = 0;
virtual void reset() = 0;
virtual void resetPattern(std:: string pattern) = 0;
virtual int count() = 0;
};
#endif
|
/*
* Copyright (c) 2022 Alexandr <re-knownout> knownout@hotmail.com
* Licensed under the GNU Affero General Public License v3.0 License (AGPL-3.0)
* https://github.com/re-knownout/mineco-application
*/
import verifyAuthentication from "../control-panel/cms-lib/verify-authentication";
import { Account } from "../control-panel/cms-types/account";
import CacheController, { cacheKeysList } from "./cache-controller";
import { appRoutesList } from "./routes-list";
import useRecaptcha from "./use-recaptcha";
import { RequestOptions } from "./types/requests";
/**
* Function for requiring full authentication data and recaptcha token
*/
export async function useFullAuthentication () {
const cacheController = new CacheController(localStorage);
// Verify is user authorized and get fresh account data
const authResult = await verifyAuthentication();
const accountData = cacheController.getItem<Account.Response>(cacheKeysList.accountData);
// Verify authentication
if (!authResult || !accountData) {
cacheController.removeItem(cacheKeysList.accountData);
window.location.href = appRoutesList.auth;
throw new Error("Не удалось проверить данные аккаунта");
}
const token = await useRecaptcha();
const formDataEntries = {
[RequestOptions.recaptchaToken]: token,
[RequestOptions.accountLogin]: accountData.login,
[RequestOptions.accountHash]: accountData.hash
};
return { token, accountData, formDataEntries };
}
|
import * as React from 'react';
import {
Button,
Icon,
ListView,
ListViewIcon,
ListViewItem,
Paginator,
Sort,
ToolbarRightContent
} from 'patternfly-react';
import { Link } from 'react-router-dom';
import { FilterSelected, StatefulFilters } from '../../components/Filters/StatefulFilters';
import { PfColors } from '../../components/Pf/PfColors';
import * as API from '../../services/Api';
import Namespace from '../../types/Namespace';
import { ActiveFilter } from '../../types/Filters';
import { ServiceList, ServiceListItem } from '../../types/ServiceList';
import { authentication } from '../../utils/Authentication';
import { CancelablePromise, makeCancelablePromise, removeDuplicatesArray } from '../../utils/Common';
import RateIntervalToolbarItem from './RateIntervalToolbarItem';
import ItemDescription from './ItemDescription';
import { ListPage } from '../../components/ListPage/ListPage';
import { ServiceListFilters } from './FiltersAndSorts';
import './ServiceListComponent.css';
import { SortField } from '../../types/SortFilters';
import { ListComponent } from '../../components/ListPage/ListComponent';
import { HistoryManager, URLParams } from '../../app/History';
import { IstioLogo } from '../../logos';
interface ServiceListComponentState extends ListComponent.State<ServiceListItem> {
rateInterval: number;
}
interface ServiceListComponentProps extends ListComponent.Props<ServiceListItem> {
rateInterval: number;
}
class ServiceListComponent extends ListComponent.Component<
ServiceListComponentProps,
ServiceListComponentState,
ServiceListItem
> {
private nsPromise?: CancelablePromise<API.Response<Namespace[]>>;
private servicesPromise?: CancelablePromise<API.Response<ServiceList>[]>;
private sortPromise?: CancelablePromise<ServiceListItem[]>;
constructor(props: ServiceListComponentProps) {
super(props);
this.state = {
listItems: [],
pagination: this.props.pagination,
currentSortField: this.props.currentSortField,
isSortAscending: this.props.isSortAscending,
rateInterval: this.props.rateInterval
};
}
componentDidMount() {
this.updateListItems();
}
componentDidUpdate(prevProps: ServiceListComponentProps, prevState: ServiceListComponentState, snapshot: any) {
if (!this.paramsAreSynced(prevProps)) {
this.setState({
pagination: this.props.pagination,
currentSortField: this.props.currentSortField,
isSortAscending: this.props.isSortAscending,
rateInterval: this.props.rateInterval
});
this.updateListItems();
}
}
componentWillUnmount() {
this.cancelAsyncs();
}
paramsAreSynced(prevProps: ServiceListComponentProps) {
return (
prevProps.pagination.page === this.props.pagination.page &&
prevProps.pagination.perPage === this.props.pagination.perPage &&
prevProps.rateInterval === this.props.rateInterval &&
prevProps.isSortAscending === this.props.isSortAscending &&
prevProps.currentSortField.title === this.props.currentSortField.title
);
}
rateIntervalChangedHandler = (key: number) => {
HistoryManager.setParam(URLParams.DURATION, String(key));
this.setState({ rateInterval: key });
};
sortItemList(services: ServiceListItem[], sortField: SortField<ServiceListItem>, isAscending: boolean) {
let lastSort: Promise<ServiceListItem[]>;
const sorter = unsorted => {
this.sortPromise = makeCancelablePromise(ServiceListFilters.sortServices(services, sortField, isAscending));
this.sortPromise.promise
.then(() => {
this.sortPromise = undefined;
})
.catch(() => {
this.sortPromise = undefined;
});
return this.sortPromise.promise;
};
if (!this.sortPromise) {
// If there is no "sortPromise" set, take the received (unsorted) list of services to sort
// them and update the UI with the sorted list.
lastSort = sorter(services);
} else {
// If there is a "sortPromise", there may be an ongoing fetch/refresh. So, the received <services> list argument
// shoudn't be used as it may represent the "old" data before the refresh. Instead, append a callback to the
// "sortPromise" to re-sort once the data is fetched. This ensures that the list will display the new data with
// the right sorting.
// (See other comments in the fetchServices method)
lastSort = this.sortPromise.promise.then(sorter);
}
return lastSort;
}
updateListItems(resetPagination?: boolean) {
this.cancelAsyncs();
const activeFilters: ActiveFilter[] = FilterSelected.getSelected();
let namespacesSelected: string[] = activeFilters
.filter(activeFilter => activeFilter.category === 'Namespace')
.map(activeFilter => activeFilter.value);
/** Remove Duplicates */
namespacesSelected = removeDuplicatesArray(namespacesSelected);
if (namespacesSelected.length === 0) {
this.nsPromise = makeCancelablePromise(API.getNamespaces(authentication()));
this.nsPromise.promise
.then(namespacesResponse => {
const namespaces: Namespace[] = namespacesResponse['data'];
this.fetchServices(
namespaces.map(namespace => namespace.name),
activeFilters,
this.state.rateInterval,
resetPagination
);
this.nsPromise = undefined;
})
.catch(namespacesError => {
if (!namespacesError.isCanceled) {
this.handleAxiosError('Could not fetch namespace list.', namespacesError);
}
});
} else {
this.fetchServices(namespacesSelected, activeFilters, this.state.rateInterval, resetPagination);
}
}
getServiceItem(data: ServiceList, rateInterval: number): ServiceListItem[] {
if (data.services) {
return data.services.map(service => ({
name: service.name,
istioSidecar: service.istioSidecar,
namespace: data.namespace.name,
healthPromise: API.getServiceHealth(authentication(), data.namespace.name, service.name, rateInterval)
}));
}
return [];
}
fetchServices(namespaces: string[], filters: ActiveFilter[], rateInterval: number, resetPagination?: boolean) {
const servicesPromises = namespaces.map(ns => API.getServices(authentication(), ns));
this.servicesPromise = makeCancelablePromise(Promise.all(servicesPromises));
this.servicesPromise.promise
.then(responses => {
const currentPage = resetPagination ? 1 : this.state.pagination.page;
let serviceListItems: ServiceListItem[] = [];
responses.forEach(response => {
ServiceListFilters.filterBy(response.data, filters);
serviceListItems = serviceListItems.concat(this.getServiceItem(response.data, rateInterval));
});
if (this.sortPromise) {
this.sortPromise.cancel();
}
// Promises for sorting are needed, because the user may have the list sorted using health/error rates
// and these data can be fetched only after the list is retrieved. If the user is sorting using these
// criteria, the update of the list is deferred after sorting is possible. This way, it's avoided the
// illusion of double-fetch or flickering list.
this.sortPromise = makeCancelablePromise(
ServiceListFilters.sortServices(serviceListItems, this.state.currentSortField, this.state.isSortAscending)
);
this.sortPromise.promise
.then(sorted => {
this.setState(prevState => {
return {
listItems: sorted,
pagination: {
page: currentPage,
perPage: prevState.pagination.perPage,
perPageOptions: ListPage.perPageOptions
}
};
});
this.sortPromise = undefined;
})
.catch(err => {
if (!err.isCanceled) {
console.debug(err);
}
this.sortPromise = undefined;
});
this.servicesPromise = undefined;
})
.catch(err => {
if (!err.isCanceled) {
console.debug(err);
}
});
}
render() {
let serviceList: any = [];
let pageStart = (this.state.pagination.page - 1) * this.state.pagination.perPage;
let pageEnd = pageStart + this.state.pagination.perPage;
pageEnd = pageEnd < this.state.listItems.length ? pageEnd : this.state.listItems.length;
for (let i = pageStart; i < pageEnd; i++) {
const serviceItem = this.state.listItems[i];
const to = '/namespaces/' + serviceItem.namespace + '/services/' + serviceItem.name;
serviceList.push(
<Link key={to} to={to} style={{ color: PfColors.Black }}>
<ListViewItem
leftContent={<ListViewIcon type="pf" name="service" />}
heading={
<div className="ServiceList-Heading">
<div className="ServiceList-IstioLogo">
{serviceItem.istioSidecar && <img className="IstioLogo" src={IstioLogo} alt="Istio sidecar" />}
</div>
<div className="ServiceList-Title">
{serviceItem.name}
<small>{serviceItem.namespace}</small>
</div>
</div>
}
// Prettier makes irrelevant line-breaking clashing with tslint
// prettier-ignore
description={<ItemDescription item={serviceItem} />}
/>
</Link>
);
}
return (
<div>
<StatefulFilters
initialFilters={ServiceListFilters.availableFilters}
pageHooks={this.props.pageHooks}
onFilterChange={this.onFilterChange}
>
<Sort>
<Sort.TypeSelector
sortTypes={ServiceListFilters.sortFields}
currentSortType={this.state.currentSortField}
onSortTypeSelected={this.updateSortField}
/>
<Sort.DirectionSelector
isNumeric={this.state.currentSortField.isNumeric}
isAscending={this.state.isSortAscending}
onClick={this.updateSortDirection}
/>
</Sort>
<RateIntervalToolbarItem
rateIntervalSelected={this.state.rateInterval}
onRateIntervalChanged={this.rateIntervalChangedHandler}
/>
<ToolbarRightContent>
<Button onClick={this.updateListItems}>
<Icon name="refresh" />
</Button>
</ToolbarRightContent>
</StatefulFilters>
<ListView>{serviceList}</ListView>
<Paginator
viewType="list"
pagination={this.state.pagination}
itemCount={this.state.listItems.length}
onPageSet={this.pageSet}
onPerPageSelect={this.perPageSelect}
/>
</div>
);
}
private cancelAsyncs = () => {
if (this.nsPromise) {
this.nsPromise.cancel();
this.nsPromise = undefined;
}
if (this.servicesPromise) {
this.servicesPromise.cancel();
this.servicesPromise = undefined;
}
if (this.sortPromise) {
this.sortPromise.cancel();
this.sortPromise = undefined;
}
};
}
export default ServiceListComponent;
|
import { yupResolver } from "@hookform/resolvers/yup"
import { FormProvider, useForm } from "react-hook-form"
import * as yup from "yup"
import {
numberValidationMessage,
textValidationMessage,
} from "../../validation"
import { ButtonPrimary } from "../Button"
import {
Form,
FormCheckbox,
FormCheckboxLabel,
FormFileInput,
FormNumberInput,
FormRadioSelect,
FormRadioSwitch,
FormRow,
FormSelect,
FormSelectMultiple,
FormTextAreaInput,
FormTextInput,
} from "."
export default {
title: "Components/Form",
}
type TextFormData = {
message: string
}
const textConstraints = { min: 4, max: 20 }
const textSchema = yup
.object({
message: yup
.string()
.trim()
.min(textConstraints.min)
.max(textConstraints.max),
})
.required()
export const FormTextControl = () => {
const methods = useForm<TextFormData, {}>({
defaultValues: { message: "Hello" },
resolver: yupResolver(textSchema),
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="message"
control={<FormTextInput />}
validationMessage={(value: string, error) =>
textValidationMessage(value, error, textConstraints)
}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormTextControl.storyName = "Text Input Field"
export const FormTextControlFullExample = () => {
const methods = useForm<TextFormData>({
defaultValues: { message: "Hello" },
resolver: yupResolver(textSchema),
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Username"
name="message"
control={<FormTextInput />}
help={
<>
Your user name must be 4-20 characters long, contain letters and
numbers, and must not contain spaces, special characters, or
emoji.
</>
}
validationMessage={(value: string, error) =>
textValidationMessage(value, error, textConstraints)
}
optional
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormTextControlFullExample.storyName = "Text Input Field Full Example"
export const FormTextAreaControl = () => {
const methods = useForm<TextFormData, {}>({
defaultValues: { message: "Hello" },
resolver: yupResolver(textSchema),
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="message"
control={<FormTextAreaInput />}
validationMessage={(value: string, error) =>
textValidationMessage(value, error, textConstraints)
}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormTextAreaControl.storyName = "Text Area Input Field"
type BoolFormData = {
checked: boolean
}
export const FormCheckboxControl = () => {
const methods = useForm<BoolFormData, {}>({
defaultValues: { checked: false },
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="checked"
control={<FormCheckbox />}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormCheckboxControl.storyName = "Checkbox Field"
export const FormCheckboxLabelControl = () => {
const methods = useForm<BoolFormData, {}>({
defaultValues: { checked: false },
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="checked"
control={
<FormCheckboxLabel label="Accept terms and services">
<FormCheckbox />
</FormCheckboxLabel>
}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormCheckboxLabelControl.storyName = "Checkbox Field With Label"
export const FormToggleSwitchControl = () => {
const methods = useForm<BoolFormData, {}>({
defaultValues: { checked: false },
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="checked"
control={
<FormCheckboxLabel label="Accept terms and services" toggle>
<FormCheckbox switchRole />
</FormCheckboxLabel>
}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormToggleSwitchControl.storyName = "Toggle Field With Label"
export const FormRadioSwitchControl = () => {
const methods = useForm<BoolFormData, {}>({
defaultValues: { checked: true },
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="checked"
control={<FormRadioSwitch on="Threads" off="Categories" />}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormRadioSwitchControl.storyName = "Radio Switch Field"
type SelectFormData = {
choice: string
}
export const FormSelectControl = () => {
const methods = useForm<SelectFormData, {}>({
defaultValues: { choice: "" },
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="choice"
control={
<FormSelect
options={[
{ value: "", name: "" },
{ value: "user", name: "User" },
{ value: "mod", name: "Moderator" },
{ value: "admin", name: "Administrator" },
]}
/>
}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormSelectControl.storyName = "Select Field"
export const FormRadioSelectControl = () => {
const methods = useForm<SelectFormData, {}>({
defaultValues: { choice: "user" },
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="choice"
control={
<FormRadioSelect
options={[
{ value: "user", name: "User" },
{ value: "mod", name: "Moderator" },
{ value: "admin", name: "Administrator" },
]}
/>
}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormRadioSelectControl.storyName = "Radio Select Field"
type SelectMultipleFormData = {
choices: Array<string>
}
export const FormSelectMultipleControl = () => {
const methods = useForm<SelectMultipleFormData, {}>({
defaultValues: { choices: [] },
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="choices"
control={
<FormSelectMultiple
options={[
{ value: "user", name: "User" },
{ value: "mod", name: "Moderator" },
{ value: "admin", name: "Administrator" },
]}
/>
}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormSelectMultipleControl.storyName = "Select Multiple Field"
type FileFormData = {
file: File | null
}
export const FormFileControl = () => {
const methods = useForm<FileFormData, {}>({
defaultValues: { file: null },
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="file"
control={<FormFileInput accept="image/*" />}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormFileControl.storyName = "File Input Field"
export const FormDisabled = () => {
const methods = useForm<TextFormData, {}>({
defaultValues: { message: "Hello" },
resolver: yupResolver(textSchema),
})
return (
<Form disabled onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="message"
control={<FormTextInput />}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormDisabled.storyName = "Disabled"
type NumberFormData = {
age: string | number | null
}
const ageConstraints = { min: 18, max: 64 }
const ageSchema = yup
.object({
age: yup
.number()
.integer()
.min(ageConstraints.min)
.max(ageConstraints.max)
.transform((value, orgValue) => (orgValue === "" ? null : value))
.nullable(),
})
.required()
export const FormNumberControl = () => {
const methods = useForm<NumberFormData, {}>({
defaultValues: { age: 24 },
resolver: yupResolver(ageSchema),
})
return (
<Form onSubmit={methods.handleSubmit(() => {})}>
<FormProvider {...methods}>
<FormRow
label="Example field"
name="age"
control={<FormNumberInput />}
validationMessage={(value: string, error) =>
numberValidationMessage(value, error, ageConstraints)
}
/>
</FormProvider>
<hr />
<ButtonPrimary>Submit</ButtonPrimary>
</Form>
)
}
FormNumberControl.storyName = "Number Input Field"
|
import Api from '../api';
type Episode = {
_id: string;
title: string;
audioUrl: string;
description: string;
releaseDate: string;
members: string;
thumbnail: string;
audioLength: number;
}
interface EpisodesResponse {
data: Array<Episode>
page: number
pageSize: number
totalPages: number
}
export default class EpisodesService extends Api {
constructor(token: string) {
super(token)
}
async getMostRecentEpisodes(userId: string): Promise<EpisodesResponse> {
const response = await this.api.get<EpisodesResponse>(`/episodes/${userId}`)
return response.data
}
async getEpisodes(userId: string, page: number): Promise<EpisodesResponse> {
const response = await this.api.get<EpisodesResponse>(`/episodes/${userId}?page=${page}`)
return response.data
}
async getOneEpisodeById(userId: string, episodeId: string): Promise<Episode> {
const body = { episodeId }
const response = await this.api.get<Episode>(`/episodes/${userId}/detail`, { data: body })
return response.data
}
}
|
/**********************************************************
DO NOT EDIT
This file was generated from stone specification "team"
Part of "Ardi - the organizer" project.
osoft4ardi@gmail.com
www.prokarpaty.net
***********************************************************/
#pragma once
#include "dropbox/endpoint/ApiUtil.h"
namespace dropboxQt{
namespace team{
class MobileClientPlatform{
/**
field: iphone: Official Dropbox iPhone client
field: ipad: Official Dropbox iPad client
field: android: Official Dropbox Android client
field: windows_phone: Official Dropbox Windows phone client
field: blackberry: Official Dropbox Blackberry client
*/
public:
enum Tag{
/*Official Dropbox iPhone client*/
MobileClientPlatform_IPHONE,
/*Official Dropbox iPad client*/
MobileClientPlatform_IPAD,
/*Official Dropbox Android client*/
MobileClientPlatform_ANDROID,
/*Official Dropbox Windows phone client*/
MobileClientPlatform_WINDOWS_PHONE,
/*Official Dropbox Blackberry client*/
MobileClientPlatform_BLACKBERRY,
/*None*/
MobileClientPlatform_OTHER
};
MobileClientPlatform(){}
MobileClientPlatform(Tag v):m_tag(v){}
virtual ~MobileClientPlatform(){}
Tag tag()const{return m_tag;}
public:
operator QJsonObject ()const;
virtual void fromJson(const QJsonObject& js);
virtual void toJson(QJsonObject& js, QString name)const;
virtual QString toString(bool multiline = true)const;
class factory{
public:
static std::unique_ptr<MobileClientPlatform> create(const QByteArray& data);
static std::unique_ptr<MobileClientPlatform> create(const QJsonObject& js);
};
protected:
Tag m_tag;
};//MobileClientPlatform
}//team
}//dropboxQt
|
#[macro_use]
extern crate lazy_static;
use crate::commands::Kokai;
pub use crate::error::{Error, IntoError};
mod commands;
mod error;
mod format;
mod git;
mod parser;
pub fn release(repository: &str, r#ref: &str) -> Result<String, Box<dyn std::error::Error>> {
let release = commands::release::Release {
repository: ".".to_string(),
name: None,
tag_from_ref: false,
git_url: Some(format!("https://github.comm/{}", repository)),
add_links: Some("github:commits,issues".to_string()),
no_emoji: false,
r#ref: r#ref.to_string(),
};
let mut buffer = std::io::BufWriter::new(Vec::new());
release.exec(&mut buffer)?;
let bytes = buffer.into_inner()?;
let res = String::from_utf8(bytes)?;
Ok(res)
}
|
CREATE TABLE {{ identifier .Parameters.tableName }}
(
shard_id varchar(64),
object varchar(64),
relation varchar(64),
subject varchar(256), /* can be <namespace:object#relation> or <user_id> */
commit_time timestamp,
PRIMARY KEY (shard_id, object, relation, subject, commit_time)
);
CREATE INDEX {{ identifier .Parameters.tableName }}_object_idx ON {{ identifier .Parameters.tableName }} (object);
CREATE INDEX {{ identifier .Parameters.tableName }}_user_set_idx ON {{ identifier .Parameters.tableName }} (object, relation);
|
import 'package:brewed/ui/beer/Beer.dart';
import 'package:brewed/ui/beer/beer_list_tile.dart';
import 'package:flutter/material.dart';
class BeerListView extends StatefulWidget {
final List<Beer> _beers;
BeerListView(this._beers);
@override
_BeerListViewState createState() => _BeerListViewState(_beers);
}
class _BeerListViewState extends State<BeerListView> {
final List<Beer> _beers;
_BeerListViewState(this._beers);
@override
Widget build(BuildContext context) {
if (_beers != null) {
final tiles = _beers.map(
(Beer beer) {
return BeerListTile(beer: beer);
},);
final beerTilesDivided = ListTile.divideTiles(context: context ,tiles: tiles).toList();
return ListView(children: beerTilesDivided,);
}
return Container();
}
}
|
/*
* Copyright (c) 2020. JetBrains s.r.o.
* Use of this source code is governed by the MIT license that can be found in the LICENSE file.
*/
package jetbrains.livemap.searching
import jetbrains.datalore.base.typedGeometry.*
import kotlin.math.abs
import kotlin.math.atan2
import kotlin.math.pow
import kotlin.math.sqrt
object LocatorUtil {
fun <TypeT> calculateAngle(coord1: Vec<TypeT>, coord2: Vec<TypeT>): Double {
val dx: Double = (coord2.x - coord1.x)
val dy: Double = (coord2.y - coord1.y)
return atan2(dy, dx)
}
fun <TypeT> distance(coord1: Vec<TypeT>, coord2: Vec<TypeT>): Double {
return sqrt(
(coord1.x - coord2.x).pow(2.0) + (coord1.y - coord2.y).pow(2.0)
)
}
fun <TypeT> coordInExtendedRect(
coord: Vec<TypeT>,
rect: Rect<TypeT>,
delta: Double
): Boolean {
return rect.contains(coord)
|| abs(coord.x - rect.left) <= delta
|| abs(coord.x - rect.right) <= delta
|| abs(coord.y - rect.bottom) <= delta
|| abs(coord.y - rect.top) <= delta
}
fun <TypeT> pathContainsCoordinate(
coord: Vec<TypeT>,
path: List<Vec<TypeT>>,
strokeWidth: Double
): Boolean {
for (i in 0 until path.size - 1) {
if (calculateSquareDistanceToPathSegment(coord, path, i) <= strokeWidth.pow(2.0)) {
return true
}
}
return false
}
private fun <TypeT> calculateSquareDistanceToPathSegment(
coord: Vec<TypeT>,
path: List<Vec<TypeT>>,
segmentNum: Int
): Double {
val next = segmentNum + 1
val dx: Double = path[next].x - path[segmentNum].x
val dy: Double = path[next].y - path[segmentNum].y
val scalar: Double = dx * (coord.x - path[segmentNum].x) + dy * (coord.y - path[segmentNum].y)
if (scalar <= 0) {
return calculateSquareDistanceToPathPoint(coord, path, segmentNum)
}
val segmentSquareLength = dx * dx + dy * dy
val baseSquareLength = scalar * scalar / segmentSquareLength
return if (baseSquareLength >= segmentSquareLength) {
calculateSquareDistanceToPathPoint(coord, path, next)
} else calculateSquareDistanceToPathPoint(coord, path, segmentNum) - baseSquareLength
}
private fun <TypeT> calculateSquareDistanceToPathPoint(
coord: Vec<TypeT>,
path: List<Vec<TypeT>>,
pointNum: Int
): Double {
val dx: Double = coord.x - path[pointNum].x
val dy: Double = coord.y - path[pointNum].y
return dx * dx + dy * dy
}
fun <TypeT> ringContainsCoordinate(ring: List<Vec<TypeT>>, coord: Vec<TypeT>): Boolean {
var intersectionCount = 0
for (i in 1 until ring.size) {
val start = i - 1
if (ring[start].y >= coord.y && ring[i].y >= coord.y ||
ring[start].y < coord.y && ring[i].y < coord.y
) {
continue
}
val x: Double = ring[start].x + (coord.y - ring[start].y) *
(ring[i].x - ring[start].x) / (ring[i].y - ring[start].y)
if (x <= coord.x) {
intersectionCount++
}
}
return intersectionCount % 2 != 0
}
}
|
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use Mail;
class MainMailController extends Controller
{
function index(){
return view('maintenance.formmail');
}
function post(Request $request)
{
$request->validate([
'email'=>'required',
'subject'=>'required',
'message'=>'required',
]);
$data=[
'email'=>$request->email,
'subject'=>$request->subject,
'bodyMessage'=>$request->message,
];
Mail::send('Maintenance.mail',$data,function($message) use($data) {
$message->from('thanathip.luis@gmail.com','maintenace');
$message->to($data['email']);
$message->subject($data['subject']);
});
return back()->with('success', 'Send E-mail Successfully');
}
}
|
# -*- coding: utf-8 -*-
import sys
from PyQt5.QtGui import QGuiApplication
from src import main
app = QGuiApplication(sys.argv)
main.run(app)
|
require 'rails_helper'
RSpec.describe V1::AuthenticationController, '#access_token', type: :request do
let(:params) { { email: email, password: password } }
let(:setup) {}
before do
setup
post v1_auth_access_token_path, params: params
end
context 'when the params are missing' do
let(:params) { {} }
it { expect(response).to have_http_status(:bad_request) }
end
context 'when the user credentials are valid' do
let(:email) { 'john@mail.com' }
let(:password) { 'correct_password' }
let(:user) { create(:user, email: email, password: password) }
let(:setup) { user }
it { expect(response).to have_http_status(:ok) }
it do
token = Token.last
expected_access_token = JWT.encode(
token.access_token_payload,
Figaro.env.secret_key_base
)
expected_refresh_token = RefreshToken.last.encrypted_token
expect(response_body).to include('access_token' => expected_access_token)
.and include('refresh_token' => expected_refresh_token)
end
end
context 'when the user credentials are invalid' do
let(:email) { 'invalid@mail.com' }
let(:password) { 'wrong_password' }
it { expect(response).to have_http_status(:unauthorized) }
it { expect(response_body).to include('message' => 'Unauthorized') }
end
end
|
package com.baeldung.cglib.proxy;
import com.baeldung.cglib.mixin.Class1;
import com.baeldung.cglib.mixin.Class2;
import com.baeldung.cglib.mixin.Interface1;
import com.baeldung.cglib.mixin.Interface2;
import com.baeldung.cglib.mixin.MixinInterface;
import net.sf.cglib.proxy.Mixin;
import org.junit.Test;
import static junit.framework.TestCase.assertEquals;
public class MixinUnitTest {
@Test
public void givenTwoClasses_whenMixedIntoOne_thenMixinShouldHaveMethodsFromBothClasses() throws Exception {
//when
Mixin mixin = Mixin.create(
new Class[]{Interface1.class, Interface2.class, MixinInterface.class},
new Object[]{new Class1(), new Class2()}
);
MixinInterface mixinDelegate = (MixinInterface) mixin;
//then
assertEquals("first behaviour", mixinDelegate.first());
assertEquals("second behaviour", mixinDelegate.second());
}
}
|
#! /bin/bash
# Copyright 2020 - 2021 MONAI Consortium
# 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.
# script for running all tests
set -e
# output formatting
separator=""
blue=""
green=""
red=""
noColor=""
if [[ -t 1 ]]; then # stdout is a terminal
separator=$'--------------------------------------------------------------------------------\n'
blue="$(
tput bold
tput setaf 4
)"
green="$(
tput bold
tput setaf 2
)"
red="$(
tput bold
tput setaf 1
)"
noColor="$(tput sgr0)"
fi
# configuration values
doCoverage=false
doQuickTests=false
doNetTests=false
doDryRun=false
doUnitTests=false
doBlackFormat=false
doBlackFix=false
doIsortFormat=false
doIsortFix=false
doFlake8Format=false
doPytypeFormat=false
doMypyFormat=false
doCleanup=false
NUM_PARALLEL=1
LINE_LENGTH=120
PY_EXE=${MONAILABEL_PY_EXE:-$(which python3)}
function print_usage() {
echo "runtests.sh [--codeformat] [--autofix] [--isort] [--flake8] [--pytype] [--mypy]"
echo " [--unittests] [--net] [--dryrun] [-j number] [--clean] [--help] [--version]"
echo ""
echo "MONAILABEL testing utilities."
echo ""
echo "Examples:"
echo "./runtests.sh --codeformat # run static checks"
echo "./runtests.sh --autofix # run automatic code formatting using \"isort\" and \"black\"."
echo "./runtests.sh --unittests # run unit tests with code coverage"
echo "./runtests.sh --net # run integration tests (monailabel PIP package should have been installed)"
echo "./runtests.sh --clean # clean up temporary files and run \"${PY_EXE} setup.py develop --uninstall\"."
echo ""
echo "Code style check options:"
echo " --black : perform \"black\" code format checks"
echo " --autofix : format code using \"isort\" and \"black\""
echo " --isort : perform \"isort\" import sort checks"
echo " --flake8 : perform \"flake8\" code format checks"
echo ""
echo "Python type check options:"
echo " --pytype : perform \"pytype\" static type checks"
echo " --mypy : perform \"mypy\" static type checks"
echo " -j, --jobs : number of parallel jobs to run \"pytype\" (default $NUM_PARALLEL)"
echo ""
echo "MONAILABEL unit testing options:"
echo " -u, --unittests : perform unit testing"
echo " --net : perform integration testing"
echo ""
echo "Misc. options:"
echo " --dryrun : display the commands to the screen without running"
echo " -f, --codeformat : shorthand to run all code style and static analysis tests"
echo " -c, --clean : clean temporary files from tests and exit"
echo " -h, --help : show this help message and exit"
echo " -v, --version : show MONAILABEL and system version information and exit"
echo ""
echo "${separator}For bug reports and feature requests, please file an issue at:"
echo " https://github.com/Project-MONAI/MONAILabel/issues/new/choose"
echo ""
echo "To choose an alternative python executable, set the environmental variable, \"MONAILABEL_PY_EXE\"."
exit 1
}
function check_import() {
echo "python: ${PY_EXE}"
${cmdPrefix}${PY_EXE} -c "import monailabel"
}
function print_version() {
${cmdPrefix}${PY_EXE} -c 'import monailabel; monailabel.print_config()'
}
function install_deps() {
echo "Pip installing MONAILABEL development dependencies and compile MONAILABEL extensions..."
${cmdPrefix}${PY_EXE} -m pip install -r requirements-dev.txt
}
function clean_py() {
TO_CLEAN="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
echo "Removing temporary files in ${TO_CLEAN}"
rm -rf sample-apps/*/logs
rm -rf sample-apps/*/.venv
rm -rf sample-apps/*/model/*
rm -rf sample-apps/*/bin
rm -rf tests/data/*
rm -rf monailabel/endpoints/static/ohif
rm -rf pytest.log
rm -rf htmlcov
rm -rf coverage.xml
rm -rf junit
rm -rf docs/build/
rm -rf docs/source/apidocs/
rm -rf test-output.xml
find ${TO_CLEAN} -type f -name "*.py[co]" -delete
find ${TO_CLEAN} -type f -name "*.so" -delete
find ${TO_CLEAN} -type d -name "__pycache__" -delete
find ${TO_CLEAN} -type d -name ".pytest_cache" -exec rm -r "{}" +
find ${TO_CLEAN} -maxdepth 1 -type f -name ".coverage.*" -delete
find ${TO_CLEAN} -depth -maxdepth 1 -type d -name ".eggs" -exec rm -r "{}" +
find ${TO_CLEAN} -depth -maxdepth 1 -type d -name "monailabel.egg-info" -exec rm -r "{}" +
find ${TO_CLEAN} -depth -maxdepth 1 -type d -name "build" -exec rm -r "{}" +
find ${TO_CLEAN} -depth -maxdepth 1 -type d -name "dist" -exec rm -r "{}" +
find ${TO_CLEAN} -depth -maxdepth 1 -type d -name ".mypy_cache" -exec rm -r "{}" +
find ${TO_CLEAN} -depth -maxdepth 1 -type d -name ".pytype" -exec rm -r "{}" +
find ${TO_CLEAN} -depth -maxdepth 1 -type d -name ".coverage" -exec rm -r "{}" +
find ${TO_CLEAN} -depth -maxdepth 1 -type d -name "__pycache__" -exec rm -r "{}" +
}
function torch_validate() {
${cmdPrefix}${PY_EXE} -c 'import torch; print(torch.__version__); print(torch.rand(5,3))'
}
function print_error_msg() {
echo "${red}Error: $1.${noColor}"
echo ""
}
function print_style_fail_msg() {
echo "${red}Check failed!${noColor}"
echo "Please run auto style fixes: ${green}./runtests.sh --autofix${noColor}"
}
function is_pip_installed() {
return $(${PY_EXE} -c "import sys, pkgutil; sys.exit(0 if pkgutil.find_loader(sys.argv[1]) else 1)" $1)
}
if [ -z "$1" ]; then
print_error_msg "Too few arguments to $0"
print_usage
fi
# parse arguments
while [[ $# -gt 0 ]]; do
key="$1"
case $key in
--net)
doNetTests=true
;;
--dryrun)
doDryRun=true
;;
-u | --u*) # allow --unittest | --unittests | --unittesting etc.
doUnitTests=true
;;
-f | --codeformat)
doBlackFormat=true
doIsortFormat=true
doFlake8Format=true
doPytypeFormat=true
doMypyFormat=true
;;
--black)
doBlackFormat=true
;;
--autofix)
doIsortFix=true
doBlackFix=true
doIsortFormat=true
doBlackFormat=true
;;
--isort)
doIsortFormat=true
;;
--flake8)
doFlake8Format=true
;;
--pytype)
doPytypeFormat=true
;;
--mypy)
doMypyFormat=true
;;
-j | --jobs)
NUM_PARALLEL=$2
shift
;;
-c | --clean)
doCleanup=true
;;
-h | --help)
print_usage
;;
-v | --version)
print_version
exit 1
;;
--nou*) # allow --nounittest | --nounittests | --nounittesting etc.
print_error_msg "nounittest option is deprecated, no unit tests is the default setting"
print_usage
;;
*)
print_error_msg "Incorrect commandline provided, invalid key: $key"
print_usage
;;
esac
shift
done
# home directory
homedir="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd "$homedir"
# python path
export PYTHONPATH="$homedir:$PYTHONPATH"
echo "PYTHONPATH: $PYTHONPATH"
# by default do nothing
cmdPrefix=""
if [ $doDryRun = true ]; then
echo "${separator}${blue}dryrun${noColor}"
# commands are echoed instead of ran
cmdPrefix="dryrun "
function dryrun() { echo " " "$@"; }
else
check_import
fi
if [ $doCleanup = true ]; then
echo "${separator}${blue}clean${noColor}"
clean_py
echo "${green}done!${noColor}"
exit
fi
# unconditionally report on the state of monailabel
print_version
if [ $doIsortFormat = true ]; then
set +e # disable exit on failure so that diagnostics can be given on failure
if [ $doIsortFix = true ]; then
echo "${separator}${blue}isort-fix${noColor}"
else
echo "${separator}${blue}isort${noColor}"
fi
# ensure that the necessary packages for code format testing are installed
if ! is_pip_installed isort; then
install_deps
fi
${cmdPrefix}${PY_EXE} -m isort --version
if [ $doIsortFix = true ]; then
${cmdPrefix}${PY_EXE} -m isort -l ${LINE_LENGTH} --profile black "$(pwd)"
else
${cmdPrefix}${PY_EXE} -m isort -l ${LINE_LENGTH} --profile black --check "$(pwd)"
fi
isort_status=$?
if [ ${isort_status} -ne 0 ]; then
print_style_fail_msg
exit ${isort_status}
else
echo "${green}passed!${noColor}"
fi
set -e # enable exit on failure
fi
if [ $doBlackFormat = true ]; then
set +e # disable exit on failure so that diagnostics can be given on failure
if [ $doBlackFix = true ]; then
echo "${separator}${blue}black-fix${noColor}"
else
echo "${separator}${blue}black${noColor}"
fi
# ensure that the necessary packages for code format testing are installed
if ! is_pip_installed black; then
install_deps
fi
${cmdPrefix}${PY_EXE} -m black --version
if [ $doBlackFix = true ]; then
${cmdPrefix}${PY_EXE} -m black -l ${LINE_LENGTH} "$(pwd)"
else
${cmdPrefix}${PY_EXE} -m black -l ${LINE_LENGTH} --check "$(pwd)"
fi
black_status=$?
if [ ${black_status} -ne 0 ]; then
print_style_fail_msg
exit ${black_status}
else
echo "${green}passed!${noColor}"
fi
set -e # enable exit on failure
fi
if [ $doFlake8Format = true ]; then
set +e # disable exit on failure so that diagnostics can be given on failure
echo "${separator}${blue}flake8${noColor}"
# ensure that the necessary packages for code format testing are installed
if ! is_pip_installed flake8; then
install_deps
fi
${cmdPrefix}${PY_EXE} -m flake8 --version
${cmdPrefix}${PY_EXE} -m flake8 "$(pwd)" --count --statistics --max-line-length ${LINE_LENGTH}
flake8_status=$?
if [ ${flake8_status} -ne 0 ]; then
print_style_fail_msg
exit ${flake8_status}
else
echo "${green}passed!${noColor}"
fi
set -e # enable exit on failure
fi
if [ $doPytypeFormat = true ]; then
set +e # disable exit on failure so that diagnostics can be given on failure
echo "${separator}${blue}pytype${noColor}"
# ensure that the necessary packages for code format testing are installed
if ! is_pip_installed pytype; then
install_deps
fi
${cmdPrefix}${PY_EXE} -m pytype --version
${cmdPrefix}${PY_EXE} -m pytype -j ${NUM_PARALLEL} --python-version="$(${PY_EXE} -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")"
pytype_status=$?
if [ ${pytype_status} -ne 0 ]; then
echo "${red}failed!${noColor}"
exit ${pytype_status}
else
echo "${green}passed!${noColor}"
fi
set -e # enable exit on failure
fi
if [ $doMypyFormat = true ]; then
set +e # disable exit on failure so that diagnostics can be given on failure
echo "${separator}${blue}mypy${noColor}"
# ensure that the necessary packages for code format testing are installed
if ! is_pip_installed mypy; then
install_deps
fi
${cmdPrefix}${PY_EXE} -m mypy --version
if [ $doDryRun = true ]; then
${cmdPrefix}MYPYPATH="$(pwd)"/monailabel ${PY_EXE} -m mypy "$(pwd)"
else
MYPYPATH="$(pwd)"/monailabel ${PY_EXE} -m mypy "$(pwd)" # cmdPrefix does not work with MYPYPATH
fi
mypy_status=$?
if [ ${mypy_status} -ne 0 ]; then
: # mypy output already follows format
exit ${mypy_status}
else
: # mypy output already follows format
fi
set -e # enable exit on failure
fi
# testing command to run
cmd="${PY_EXE}"
# unit tests
if [ $doUnitTests = true ]; then
echo "${separator}${blue}unittests${noColor}"
torch_validate
${cmdPrefix}${PY_EXE} tests/setup.py
${cmdPrefix}${cmd} -m pytest -x --forked --doctest-modules --junitxml=junit/test-results.xml --cov-report xml --cov-report html --cov-report term --cov monailabel tests/unit
fi
function check_server_running() {
local code=$(curl --write-out "%{http_code}\n" -s "http://127.0.0.1:${MONAILABEL_SERVER_PORT:-8000}/" --output /dev/null)
echo ${code}
}
# network training/inference/eval integration tests
if [ $doNetTests = true ]; then
echo "${separator}${blue}integration${noColor}"
torch_validate
${cmdPrefix}${PY_EXE} tests/setup.py
echo "Starting MONAILabel server..."
monailabel start_server -a sample-apps/segmentation_left_atrium -s tests/data/dataset/local/heart -p ${MONAILABEL_SERVER_PORT:-8000} &
wait_time=0
server_is_up=0
start_time_out=120
while [[ $wait_time -le ${start_time_out} ]]; do
if [ "$(check_server_running)" == "200" ]; then
server_is_up=1
break
fi
sleep 5
wait_time=$((wait_time + 5))
echo "Waiting for MONAILabel to be up and running..."
done
echo ""
if [ "$server_is_up" == "1" ]; then
echo "MONAILabel server is up and running."
else
echo "Failed to start MONAILabel server. Exiting..."
exit 1
fi
{
${cmdPrefix}${cmd} -m pytest -v tests/integration --no-summary -x
} || {
kill -9 $(ps -ef | grep monailabel | grep -v grep | awk '{print $2}')
}
fi
|
describe :grab_text do
it "pops the following text" do
o = Moron_Text.new(<<-EOF)
DUCK /*
QUACK
BIRD /*
Whistle
EOF
sounds = []
o.run do |name, line, moron|
case name
when 'DUCK'
sounds << moron.grab_text
when 'BIRD'
sounds << moron.grab_text
else
moron.typo!
end
end
sounds.should == %w{ QUACK Whistle }
end
it "pops multiple lines of text" do
o = Moron_Text.new(<<-EOF)
DUCK /*
This is one line.
This is another line.
EOF
txt = nil
o.run { |name, line, moron|
if name == 'DUCK'
txt = moron.grab_text
else
moron.typo!
end
}
txt.should == <<-EOF.strip
This is one line.
This is another line.
EOF
end
end # === describe :text
|
package ali
import (
"fmt"
"sync"
"go.uber.org/zap/buffer"
"go.uber.org/zap/zapcore"
)
var _ zapcore.Encoder = &MapObjEncoder{}
var encoderPool = sync.Pool{New: func() interface{} {
return &MapObjEncoder{MapObjectEncoder: zapcore.NewMapObjectEncoder()}
}}
func getEncoder() *MapObjEncoder {
return encoderPool.Get().(*MapObjEncoder)
}
func putEncoder(enc *MapObjEncoder) {
enc.MapObjectEncoder = zapcore.NewMapObjectEncoder()
encoderPool.Put(enc)
}
// MapObjEncoder ...
type MapObjEncoder struct {
*zapcore.EncoderConfig
parentFields []zapcore.Field
*zapcore.MapObjectEncoder
}
// NewMapObjEncoder ...
func NewMapObjEncoder(cfg zapcore.EncoderConfig) *MapObjEncoder {
return &MapObjEncoder{
EncoderConfig: &cfg,
MapObjectEncoder: zapcore.NewMapObjectEncoder(),
}
}
// Clone ...
func (e *MapObjEncoder) Clone() zapcore.Encoder {
return e.clone()
}
func (e *MapObjEncoder) clone() *MapObjEncoder {
clone := getEncoder()
clone.EncoderConfig = e.EncoderConfig
// copy parentFields
clone.parentFields = make([]zapcore.Field, 0, len(e.parentFields))
clone.parentFields = append(clone.parentFields, e.parentFields...)
// copy fields
for k, v := range e.MapObjectEncoder.Fields {
clone.MapObjectEncoder.Fields[k] = v
}
return clone
}
// EncodeEntry ...
func (e *MapObjEncoder) EncodeEntry(ent zapcore.Entry, fields []zapcore.Field) (*buffer.Buffer, error) {
// do nothing, just implement zapcore.Encoder.EncodeEntry()
return nil, nil
}
func (e *MapObjEncoder) encodeEntry(ent zapcore.Entry, fields []zapcore.Field) *MapObjEncoder {
final := e.clone()
if final.LevelKey != "" {
final.AddString(final.LevelKey, ent.Level.String())
}
if final.TimeKey != "" {
final.AddInt64(final.TimeKey, ent.Time.Unix())
}
if ent.LoggerName != "" && final.NameKey != "" {
final.AddString(final.NameKey, ent.LoggerName)
}
if ent.Caller.Defined && final.CallerKey != "" {
final.AddString(final.CallerKey, ent.Caller.String())
}
if final.MessageKey != "" {
final.AddString(final.MessageKey, ent.Message)
}
if ent.Stack != "" && final.StacktraceKey != "" {
final.AddString(final.StacktraceKey, ent.Stack)
}
addFields(final, fields)
return final
}
// NewCore creates a Core that writes logs to a WriteSyncer.
func NewCore(ops ...Option) (zapcore.Core, func() error) {
var c config
for _, o := range ops {
o(&c)
}
aliLs, err := newWriter(c)
if err != nil {
panic(fmt.Errorf("NewCore fail, %w", err))
}
core := &ioCore{
LevelEnabler: c.levelEnabler,
enc: c.encoder,
writer: aliLs,
}
closeFunc := func() error {
core.writer.cancel()
return core.writer.flush()
}
return core, closeFunc
}
func addFields(enc zapcore.ObjectEncoder, fields []zapcore.Field) {
for i := range fields {
fields[i].AddTo(enc)
}
}
type ioCore struct {
zapcore.LevelEnabler
enc zapcore.Encoder
writer *writer
}
func (c *ioCore) With(fields []zapcore.Field) zapcore.Core {
c.enc.(*MapObjEncoder).parentFields = fields
clone := c.clone()
// NOTICE: we must reset parentFields otherwise parent logger with also print parent fields
c.enc.(*MapObjEncoder).parentFields = nil
return clone
}
func (c *ioCore) Check(ent zapcore.Entry, ce *zapcore.CheckedEntry) *zapcore.CheckedEntry {
if c.Enabled(ent.Level) {
return ce.AddCore(ent, c)
}
return ce
}
func (c *ioCore) Write(ent zapcore.Entry, fields []zapcore.Field) (err error) {
clone := c.enc.(*MapObjEncoder).encodeEntry(ent, fields)
addFields(clone, append(fields, clone.parentFields...))
if err := c.writer.write(clone.Fields); err != nil {
return err
}
if ent.Level > zapcore.ErrorLevel {
err = c.Sync()
}
putEncoder(clone)
return
}
func (c *ioCore) Sync() error {
return c.writer.flush()
}
func (c *ioCore) clone() *ioCore {
return &ioCore{
LevelEnabler: c.LevelEnabler,
enc: c.enc.Clone(),
writer: c.writer,
}
}
|
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.testing;
import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension;
import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.kafka.core.KafkaTemplate;
import org.testcontainers.containers.KafkaContainer;
import org.testcontainers.containers.wait.strategy.Wait;
import org.testcontainers.utility.DockerImageName;
public abstract class AbstractSpringKafkaTest {
private static final Logger logger = LoggerFactory.getLogger(AbstractSpringKafkaTest.class);
@RegisterExtension
protected static final InstrumentationExtension testing = AgentInstrumentationExtension.create();
static KafkaContainer kafka;
static ConfigurableApplicationContext applicationContext;
protected static KafkaTemplate<String, String> kafkaTemplate;
@SuppressWarnings("unchecked")
@BeforeAll
static void setUp() {
kafka =
new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:5.4.3"))
.waitingFor(Wait.forLogMessage(".*started \\(kafka.server.KafkaServer\\).*", 1))
.withStartupTimeout(Duration.ofMinutes(1));
kafka.start();
Map<String, Object> props = new HashMap<>();
props.put("spring.jmx.enabled", false);
props.put("spring.main.web-application-type", "none");
props.put("spring.kafka.bootstrap-servers", kafka.getBootstrapServers());
props.put("spring.kafka.consumer.auto-offset-reset", "earliest");
props.put("spring.kafka.consumer.linger-ms", 10);
// wait 1s between poll() calls
props.put("spring.kafka.listener.idle-between-polls", 1000);
props.put("spring.kafka.producer.transaction-id-prefix", "test-");
SpringApplication app = new SpringApplication(ConsumerConfig.class);
app.setDefaultProperties(props);
applicationContext = app.run();
kafkaTemplate = applicationContext.getBean("kafkaTemplate", KafkaTemplate.class);
}
@AfterAll
static void tearDown() {
kafka.stop();
if (applicationContext != null) {
applicationContext.stop();
}
}
protected void sendBatchMessages(Map<String, String> keyToData) throws InterruptedException {
// This test assumes that messages are sent and received as a batch. Occasionally it happens
// that the messages are not received as a batch, but one by one. This doesn't match what the
// assertion expects. To reduce flakiness we retry the test when messages weren't received as
// a batch.
int maxAttempts = 5;
for (int i = 1; i <= maxAttempts; i++) {
BatchRecordListener.reset();
testing.runWithSpan(
"producer",
() -> {
kafkaTemplate.executeInTransaction(
ops -> {
keyToData.forEach((key, data) -> ops.send("testBatchTopic", key, data));
return 0;
});
});
BatchRecordListener.waitForMessages();
if (BatchRecordListener.getLastBatchSize() == 2) {
break;
} else if (i < maxAttempts) {
testing.waitForTraces(2);
Thread.sleep(1_000); // sleep a bit to give time for all the spans to arrive
testing.clearData();
logger.info("Messages weren't received as batch, retrying");
}
}
}
}
|
#include <list>
#include <stdio.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include "core/Utils.hh"
#include "core/myricom/MyricomSNFNetworkInterface.hh"
#include "LatencyMeter.hh"
LatencyMeter::LatencyMeter(MyricomSNFNetworkInterface * recvInterface,
int coreToRunOn, uint64_t _expectedNumPackets)
: NetBump(recvInterface, /* outInterface */ NULL, coreToRunOn),
expectedNumPackets(_expectedNumPackets)
{
shouldShutDown = false;
sentTimes.reserve(_expectedNumPackets);
receivedTimes.reserve(_expectedNumPackets);
numPktsReceived = 0;
totalNumBytes = 0;
}
LatencyMeter::~LatencyMeter()
{ }
void LatencyMeter::recordIncomingPacket(Packet p)
{
// record the time the packet was originally sent
uint64_t sentTime;
memcpy(&sentTime, (uint8_t *)p.data+42, sizeof(uint64_t));
sentTimes[numPktsReceived] = sentTime;
// record the time the packet actually got to us
receivedTimes[numPktsReceived] = p.timestamp;
totalNumBytes += p.length;
numPktsReceived++;
}
void LatencyMeter::work()
{
Packet p;
uint64_t startTime = 0, endTime = 0;
while (!shouldShutDown && (numPktsReceived < expectedNumPackets)) {
recvPacket(p);
if (p.length > 0) {
if (startTime == 0) {
startTime = Utils::utime();
}
recordIncomingPacket(p);
}
}
endTime = Utils::utime();
for (uint64_t i = 0; i < numPktsReceived; i++) {
printf("%jd\n", (receivedTimes[i]/1000 - sentTimes[i]));
}
fprintf(stderr, "Received %jd / %jd packets (rate = %g)\n",
numPktsReceived, expectedNumPackets,
(numPktsReceived/expectedNumPackets*1.0));
fprintf(stderr, "Received %jd bytes in %jd microseconds\n",
totalNumBytes, (endTime - startTime));
return;
}
|
-- :name update_article :affected
UPDATE Article
SET
first_snapshot_at = :first_snapshot_at,
last_snapshot_at = :last_snapshot_at,
next_snapshot_at = :next_snapshot_at,
snapshot_count = :snapshot_count
WHERE
article_id = :article_id
|
# Specify the dataset split for which to generate predictions
SPLIT="test"
python generate.py --split=${SPLIT}
|
#include "genetic_algorithm.h"
#include <fstream>
#include <iostream>
#include <unordered_map>
#include <utility>
using namespace ga;
/* Layout Indexes
** | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
** | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 |
** | 19 | 20 | 21 | 22 | 23 | 24 | 25 |
*/
struct pair_hash {
template <class T1, class T2>
std::size_t operator() (const std::pair<T1, T2> &pair) const {
return std::hash<T1>()(pair.first) ^ std::hash<T2>()(pair.second);
}
};
using FrequencyDataMap = std::unordered_map<std::pair<char, char>, double, pair_hash>;
FrequencyDataMap char_pair_frequency;
int ga::loadFrequency() {
std::ifstream data("frequency_data.txt");
if (!data) {
std::cout << "missing data" << std::endl;
return 0;
}
char c1, c2;
double f;
int count = 0;
std::cout << "---------------data------------------\n";
while (!data.eof()) {
data >> c1 >> c2 >> f;
if (f < 1.0e-8)
continue;
std::cout << c1 << " " << c2 << " " << f << std::endl;
char_pair_frequency[std::make_pair(c1, c2)] = f;
count++;
}
std::cout << "-------------------------------------\n";
return count;
}
enum HAND { LEFT, RIGHT };
const HAND hand[26]{
LEFT, LEFT, LEFT, LEFT, LEFT, RIGHT, RIGHT, RIGHT, RIGHT, RIGHT,
LEFT, LEFT, LEFT, LEFT, LEFT, RIGHT, RIGHT, RIGHT, RIGHT,
LEFT, LEFT, LEFT, LEFT, LEFT, RIGHT, RIGHT
};
enum FINGER { INDEX1, INDEX2, MIDDLE, RING, PINKY };
FINGER checkFinger(size_t index) {
static FINGER finger[] = {
PINKY, RING, MIDDLE, INDEX2, INDEX1, INDEX1, INDEX2, MIDDLE, RING, PINKY
};
if (index < 10)
return finger[index];
else if (index < 19)
return finger[index - 10];
else
return finger[index - 19];
}
double finger_weight[] = { 3, 2, 1, 4.5, 4.5 };
const int row[26] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2
};
const double row_weight[3] = {
2.0, 1.0, 3.0
};
double Individual::calcFitness() {
_fitness = 0;
size_t memo[26];
int i = 0;
for (auto c : _layout) {
memo[c - 'a'] = i++;
}
for (auto two_gram : char_pair_frequency) {
double freq = two_gram.second; // Frequency
size_t i1, i2;
// index of key1
i1 = memo[two_gram.first.first - 'a'];
// index of key2
i2 = memo[two_gram.first.second - 'a'];
auto f1 = checkFinger(i1);
auto f2 = checkFinger(i2);
double h = std::abs(hand[i1] - hand[i2]); // Hand Transition
double r = h == 0 ? std::abs(row[i1] - row[i2]) : 0; // Row Transition
double f = h == 0 ? std::abs(f1 - f2) : 0; // Finger Transition
double R = row_weight[row[i1]] + row_weight[row[i2]]; // Row Weight
double F = finger_weight[f1] + finger_weight[f2]; // Finger Weight
_fitness += (185.8 - 40.0*h + 18.3*r - 11.0*f + 0.514*R + 1.07*F) * freq;
}
return _fitness;
}
|
#!/bin/bash
rm salidahanoi.dat
contador=1000
while [ $contador -lt 100000 ]; do
./hanoi $contador >> salidahanoi.dat
let "contador+=1000"
done
|
package oversecured.ovaa.objects;
import android.os.Parcel;
import android.os.Parcelable;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class MemoryCorruptionParcelable implements Parcelable {
public static final Parcelable.Creator<MemoryCorruptionParcelable> CREATOR = new Parcelable.Creator<MemoryCorruptionParcelable>() {
@Override
public MemoryCorruptionParcelable[] newArray(int i) {
return new MemoryCorruptionParcelable[i];
}
@Override
public MemoryCorruptionParcelable createFromParcel(Parcel parcel) {
return new MemoryCorruptionParcelable(parcel);
}
};
private static final Gson GSON = new GsonBuilder().create();
public Object data;
private MemoryCorruptionParcelable(Parcel parcel) {
try {
Class clazz = Class.forName(parcel.readString());
data = GSON.fromJson(parcel.readString(), clazz);
}
catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel parcel, int i) {
parcel.writeString(data.getClass().getCanonicalName());
parcel.writeString(GSON.toJson(data));
}
}
|
####################################################
# Copyright 2013 VMware, Inc. All rights reserved.
####################################################
#
# @file JsonApiRequest.pm
# The file implements JasonApiRequest perl module.
#
# @copy 2013, VMware Inc.
#
#
# @class JsonApiRequest
# Class to represent a INVOKE_METHOD JSON RPC 2.0 request.
#
package Com::Vmware::Vapi::Protocol::Common::Json::JsonApiRequest;
#
# Core Perl modules
#
use strict;
use warnings;
#
# Vapi Perl modules
#
use Com::Vmware::Vapi::Util::Logger
qw(log_info log_error log_verbose log_warning log_framework log_dumper);
use base qw(Com::Vmware::Vapi::Protocol::Common::Json::JsonBaseRequest);
use Com::Vmware::Vapi::Protocol::Common::Json::JsonConstants;
#
# @method new
# Constructor
# @param id Identifier to be used in the JSON-RPC 2.0 request
# @param request_params Arguments for the INVOKE_METHOD request
#
# @return Blessed object
#
sub new {
my ( $class, %args ) = @_;
my $id = $args{id};
$class = ref($class) || $class;
my $self = $class->SUPER::new(
id => $id,
method =>
Com::Vmware::Vapi::Protocol::Common::Json::JsonConstants::INVOKE
);
$self->{request_params} = $args{request_params};
return bless( $self, $class );
}
#
# @method set_request_params
# Sets Arguments for the INVOKE_METHOD request
#
# @param request_params INVOKE_METHOD request
#
# @return None
#
sub set_request_params {
my ( $self, %args ) = @_;
$self->{request_params} = $args{request_params};
}
#
# @method get_request_params
# Get requestParams
#
# @param None
#
# @return request_params argument for the INVOKE_METHOD request
#
sub get_request_params {
my $self = shift;
return $self->{request_params};
}
#
# @method accept
# visit each data objects
#
# @param visitor
#
# @return None
#
sub accept {
my ( $self, %args ) = @_;
my $visitor = $args{visitor};
$visitor->visit( vapi_data_object => $self );
}
1;
|
package ch.m3ts.eventbus.event.ball;
import ch.m3ts.detection.EventDetectionListener;
public class DetectionTimeOutData implements EventDetectorEventData {
@Override
public void call(EventDetectionListener eventDetectionListener) {
eventDetectionListener.onTimeout();
}
}
|
-- @testpoint: left函数入参个数超过固定值，合理报错
select left('xiexiaoyu','gaoxin',5);
select left('xiexiaoyu','gaoxin',4,5);
|
package router_http
import (
"strconv"
"github.com/eolinker/apinto/plugin"
"github.com/eolinker/eosc"
)
var _ IRouters = (*Routers)(nil)
//IRouters 路由树管理器实现的接口
type IRouters interface {
Set(port int, id string, conf *Config) (IRouter, bool, error)
Del(port int, id string) (IRouter, bool)
}
//Routers 路由树管理器的结构体
type Routers struct {
data eosc.IUntyped
pluginManager plugin.IPluginManager
}
//Set 将路由配置加入到对应端口的路由树中
func (rs *Routers) Set(port int, id string, conf *Config) (IRouter, bool, error) {
name := strconv.Itoa(port)
r, has := rs.data.Get(name)
//若对应端口不存在路由树，则新建
if !has {
globalRouterFilter := rs.pluginManager.CreateRouter(name, map[string]*plugin.Config{})
router := NewRouter(globalRouterFilter)
err := router.SetRouter(id, conf)
if err != nil {
return nil, false, err
}
rs.data.Set(name, router)
return router, true, nil
}
router := r.(IRouter)
err := router.SetRouter(id, conf)
if err != nil {
return nil, false, err
}
return router, false, nil
}
//NewRouters 新建路由树管理器
func NewRouters(pluginManager plugin.IPluginManager) *Routers {
rs := &Routers{
data: eosc.NewUntyped(),
pluginManager: pluginManager,
}
return rs
}
//Del 将路由配置从对应端口的路由树中删去
func (rs *Routers) Del(port int, id string) (IRouter, bool) {
name := strconv.Itoa(port)
if i, has := rs.data.Get(name); has {
r := i.(IRouter)
count := r.Del(id)
if count == 0 {
rs.data.Del(name)
}
return r, true
}
return nil, false
}
|
package db
// User represents an authenticated Facebook user.
type User struct {
ID int64
// Each user authenticates with one or more of these services
GoogleID string `gorm:"not null"`
FacebookID string `gorm:"not null"`
// This data is filled in with the most recent login method
Name string `gorm:"not null"`
Email string `gorm:"not null"`
Picture string `gorm:"not null"`
// Management data
IsAdmin bool `gorm:"not null"`
// Profile data
Link string `gorm:"not null"`
IsMale bool `gorm:"not null"`
IsFemale bool `gorm:"not null"`
}
|
# composerDemo
This is just for learn composer, not for use.
本项目用于临时学习
|
package de.htwg.se.kingoftokyo.controller.controllerComponent
object State extends Enumeration {
type GameState = Value
val WaitForPlayerNames, WaitFor1stThrow, WaitFor2ndThrow, ThrowComplete, WaitForKotDecision, End,
WaitForBuy = Value
val map = Map[GameState, String] (
WaitForPlayerNames -> "Bitte Spielernamen kommagetrennt eingeben",
WaitFor1stThrow -> "Ihre Auswahl",
WaitFor2ndThrow -> "Ihre Auswahl",
ThrowComplete -> "Wurf wird ausgewertet",
WaitForBuy -> "Möchten sie 5 Energy für 1 Heart oder Star ausgeben? (heart/star)",
WaitForKotDecision -> "Wollen Sie King of Tokyo bleiben ?(yes/no)",
End -> "Spiel beendet"
)
def message(state: GameState): String = {
map(state)
}
def mapStringtoState(string: String): GameState = string match {
case "WaitFor1stThrow" => WaitFor1stThrow
case "WaitForPlayerNames" => WaitForPlayerNames
case "WaitFor2ndThrow" => WaitFor2ndThrow
case "ThrowComplete" => ThrowComplete
case "WaitForKotDecision" => WaitForKotDecision
case "End" => End
}
}
|
package agents.piers;
import hanabAI.Action;
import hanabAI.State;
public class ActionRule implements IRule {
private Func<State, Action> _actionFactory;
public ActionRule(Func<State, Action> actionFactory) {
this._actionFactory = actionFactory;
}
@Override
public Action play(State s) {
return this._actionFactory.apply(s);
}
}
|
import { BrowserModule } from '@angular/platform-browser';
import { ErrorHandler, NgModule } from '@angular/core';
import { IonicApp, IonicErrorHandler, IonicModule } from 'ionic-angular';
import { MyApp } from './app.component';
import { ProfilePage } from '../pages/profile/profile';
import { StatusBar } from '@ionic-native/status-bar';
import { SplashScreen } from '@ionic-native/splash-screen';
import {LoginPage} from "../pages/login/login";
import {RegisterPage} from "../pages/register/register";
import { UserServiceProvider } from '../providers/user-service/user-service';
import {ToastController} from "ionic-angular/components/toast/toast-controller";
import {LoadingController} from "ionic-angular/components/loading/loading-controller";
import { HttpClientModule } from '@angular/common/http';
import {FileChooser} from "@ionic-native/file-chooser";
import {RankingPage} from "../pages/ranking/ranking";
import {UserdetailPage} from "../pages/userdetail/userdetail";
import {ChallengesPage, ChallengesTabs} from "../pages/challenges/challenges";
import { ChallengeServiceProvider } from '../providers/challenge-service/challenge-service';
import {ChallengedetailPage} from "../pages/challengedetail/challengedetail";
import {HomePage} from "../pages/home/home";
import {ModelwallPage} from "../pages/modelwall/modelwall";
import { IonicImageViewerModule } from 'ionic-img-viewer';
import {UsertabsPage} from "../pages/usertabs/usertabs";
import {UserchallengesPage} from "../pages/userchallenges/userchallenges";
import {UseranswersPage} from "../pages/useranswers/useranswers";
import {UserlogsPage} from "../pages/userlogs/userlogs";
@NgModule({
declarations: [
MyApp,
HomePage,
ProfilePage,
RankingPage,
LoginPage,
RegisterPage,
UserdetailPage,
ChallengesPage,
ChallengedetailPage,
ModelwallPage,
ChallengesTabs,
UsertabsPage,
UserchallengesPage,
UseranswersPage,
UserlogsPage,
],
imports: [
BrowserModule,
HttpClientModule,
IonicImageViewerModule,
IonicModule.forRoot(MyApp),
],
bootstrap: [IonicApp],
entryComponents: [
MyApp,
HomePage,
ProfilePage,
RankingPage,
LoginPage,
RegisterPage,
UserdetailPage,
ChallengesPage,
ChallengedetailPage,
ModelwallPage,
ChallengesTabs,
UsertabsPage,
UserchallengesPage,
UseranswersPage,
UserlogsPage,
],
providers: [
StatusBar,
SplashScreen,
{provide: ErrorHandler, useClass: IonicErrorHandler},
UserServiceProvider,
ChallengeServiceProvider,
LoadingController,
ToastController,
FileChooser,
ChallengeServiceProvider,
]
})
export class AppModule {}
|
import { Reducer } from "redux";
import { AppThunk, QuestionListItemData } from "../types";
import { fetchy } from "../utils/fetch";
export const Actions = {
LIST_QUESTIONS: "LIST_QUESTIONS",
LIST_QUESTIONS_SUCCESS: "LIST_QUESTIONS_SUCCESS"
};
const syncActions = {
listQuestionsSuccess: (items: listQuestionsSuccessPayload) => {
return { type: Actions.LIST_QUESTIONS_SUCCESS, payload: items };
}
};
const asyncActions = {
listQuestions: (): AppThunk => async dispatch => {
const asyncResp = await fetchy("questions").then(res => res.json());
dispatch(syncActions.listQuestionsSuccess(asyncResp));
}
};
export const actions = { ...syncActions, ...asyncActions };
type listQuestionsSuccessPayload = { items: QuestionListItemData[] };
export type State = listQuestionsSuccessPayload;
const initialState: State = {
items: []
};
export const reducer: Reducer<State> = (state = initialState, action) => {
console.log(action);
switch (action.type) {
case Actions.LIST_QUESTIONS_SUCCESS:
return { ...state, ...action.payload };
default:
return state;
}
};
|
<?php
namespace LanguageServerProtocol;
class ClientCapabilitiesGeneral
{
/**
* Client capabilities specific to regular expressions.
*
* @since 3.16.0
*
* @var RegularExpressionsClientCapabilities|null
*/
public $regularExpressions;
/**
* Client capabilities specific to the client's markdown parser.
*
* @since 3.16.0
*
* @var MarkdownClientCapabilities|null
*/
public $markdown;
public function __construct(
RegularExpressionsClientCapabilities $regularExpressions = null,
MarkdownClientCapabilities $markdown = null
)
{
$this->regularExpressions = $regularExpressions;
$this->markdown = $markdown;
}
}
|
# kodepos-indonesia.sql
MySQL Database Kodepos Indonesia.
<h3>Table:</h3>
- tbl_propinsi <code>(34)</code>
- id
- nama
- tbl_kodepos <code>(86406)</code>
- id
- id_propinsi
- kota_kab
- kecamatan
- kelurahan
- kodepos
|
use std::{
io::ErrorKind,
pin::Pin,
sync::Arc,
task::{Context, Poll},
};
use async_broadcast::Receiver as ActiveReceiver;
use async_channel::Receiver;
use futures_core::{ready, stream, Future};
use futures_util::{
future::{select, Either},
StreamExt,
};
use static_assertions::assert_impl_all;
use crate::{Connection, Error, Message, Result};
/// A [`stream::Stream`] implementation that yields [`Message`] items.
///
/// You can convert a [`Connection`] to this type.
///
/// **NOTE**: You must ensure a `MessageStream` is continuously polled or you will experience hangs.
/// If you don't need to continuously poll the `MessageStream` but need to keep it around for later
/// use, keep the connection around and convert it into a `MessageStream` when needed. The
/// conversion is not an expensive operation so you don't need to worry about performance, unless
/// you do it very frequently. If you need to convert back and forth frequently, you may want to
/// consider keeping both a connection and stream around.
#[derive(Clone, Debug)]
#[must_use = "streams do nothing unless polled"]
pub struct MessageStream {
msg_receiver: ActiveReceiver<Arc<Message>>,
error_receiver: Receiver<Error>,
}
assert_impl_all!(MessageStream: Send, Sync, Unpin);
impl stream::Stream for MessageStream {
type Item = Result<Arc<Message>>;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let this = self.get_mut();
let msg_fut = this.msg_receiver.next();
let err_fut = this.error_receiver.next();
let mut select_fut = select(msg_fut, err_fut);
match ready!(Pin::new(&mut select_fut).poll(cx)) {
Either::Left((msg, _)) => Poll::Ready(msg.map(Ok)),
Either::Right((error, _)) => Poll::Ready(
error
.map(|e| match &e {
Error::Io(io_error) => {
let kind = io_error.kind();
if kind == ErrorKind::UnexpectedEof || kind == ErrorKind::BrokenPipe {
None
} else {
Some(Err(e))
}
}
_ => Some(Err(e)),
})
.flatten(),
),
}
}
}
impl From<Connection> for MessageStream {
fn from(conn: Connection) -> Self {
let msg_receiver = conn.msg_receiver.activate();
let error_receiver = conn.error_receiver;
Self {
msg_receiver,
error_receiver,
}
}
}
impl From<&Connection> for MessageStream {
fn from(conn: &Connection) -> Self {
Self::from(conn.clone())
}
}
|
import { renderProjenInitOptions } from '../../src/javascript/render-options';
import { Projenrc } from '../../src/projenrc-json';
import { synthSnapshot, TestProject } from '../util';
test('projenrc.json default project', () => {
// GIVEN
const project = new TestProject();
// WHEN
new Projenrc(project);
// THEN
expect(synthSnapshot(project)).toMatchSnapshot();
});
test('projenrc.json with typed options', () => {
// GIVEN
const project = new TestProject(renderProjenInitOptions('projen.typescript.TypeScriptProject', {
staleOptions: {
issues: {
daysBeforeStale: 100, // number, nested option
},
pullRequest: {
enabled: false, // boolean, nested option
},
},
name: '@example/foo', // string
npmAccess: 'public', // enum provided as string
}));
// WHEN
new Projenrc(project);
// THEN
expect(synthSnapshot(project)).toMatchSnapshot();
});
|
namespace Accounting.DesktopClient.IoC
{
using Accounting.DesktopClient.Navigation;
using Accounting.DesktopClient.Controls;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Unity;
using Accounting.Core.External_Services;
using Accounting.Data;
internal static class IoC
{
public static IUnityContainer CreateContainer(MasterWindow masterWindow)
{
var container = new UnityContainer();
container.RegisterInstance(masterWindow);
container.RegisterSingleton<INavigation, Navigation>();
container.RegisterSingleton<IDatabase, Database>();
container.RegisterSingleton<ITextPicker, UserInputTextPicker>();
container.RegisterSingleton<ApplicantsControl>();
return container;
}
}
}
|
require 'spec_helper'
require 'ostruct'
describe User do
describe "using AT&T auth" do
let(:auth) do
OpenStruct.new(
uid: 'att-abcd1234',
provider: 'att',
credentials: OpenStruct.new(token: 'zyxwvut4321'),
info: OpenStruct.new(
first_name: 'Test',
last_name: 'User',
email: 'test@example.com',
phone_number: '14045551234'
)
)
end
it %q{should find a user who has previously logged in via AT&T} do
user = FactoryGirl.build(:user)
user.uid = auth.uid
user.provider = auth.provider
user.save!
User.find_or_create_from_auth_hash(:att, auth).should == user
end
it %q{should create a new user when no previous AT&T login and no matching email address} do
found_user = User.find_or_create_from_auth_hash(:att, auth)
found_user.first_name.should == 'Test'
found_user.last_name.should == 'User'
found_user.email.should == 'test@example.com'
found_user.persisted?.should be true
end
end
describe '#admin' do
it "should not be possible to mass assign :admin" do
user = FactoryGirl.build(:user)
expect { user.update_attributes({admin: true}) }.to raise_error
end
it %q{should disable admin_mode when removing admin bit} do
user = FactoryGirl.build :user
user.admin = true
user.admin_mode = true
user.save!
user.reload
user.admin.should be true
user.admin_mode.should be true
user.admin = false
user.save!
user.reload
user.admin_mode.should be false
end
end
end
|
require "rails_helper"
RSpec.describe "New Sake's Date and Time" do
let(:user) { FactoryBot.create(:user) }
some_date = %r{[0-9]+/[0-9]+/[0-9]+}
before do
sign_in(user)
visit new_sake_path
fill_in("textfield-name", with: "new sake name")
end
describe "creating sealed sake" do
before do
select(I18n.t("enums.sake.bottle_level.sealed"), from: "select-bottle-level")
click_button("form-submit")
end
it "creates sake having created_at" do
created_at = find(:test_id, "created-at").text
expect(created_at).to have_text(some_date)
end
it "creates sake not having opened_at" do
expect(find(:test_id, "opened-at")).not_to have_text(some_date)
end
it "creates sake not having emptied_at" do
expect(find(:test_id, "emptied-at")).not_to have_text(some_date)
end
it "creates sake having updated_at" do
updated_at = find(:test_id, "updated-at").text
expect(updated_at).to have_text(some_date)
end
it "creates sake having close date between created_at and updated_at" do
created_at = Time.zone.parse(find(:test_id, "created-at").text)
updated_at = Time.zone.parse(find(:test_id, "updated-at").text)
delta = 1.second
expect(updated_at).to be_within(delta).of(created_at)
end
end
describe "creating opened sake" do
before do
select(I18n.t("enums.sake.bottle_level.opened"), from: "select-bottle-level")
click_button("form-submit")
end
it "creates sake having created_at" do
created_at = find(:test_id, "created-at").text
expect(created_at).to have_text(some_date)
end
it "creates sake having opened_at" do
expect(find(:test_id, "opened-at")).to have_text(some_date)
end
it "creates sake not having emptied_at" do
expect(find(:test_id, "emptied-at")).not_to have_text(some_date)
end
it "creates sake having updated_at" do
updated_at = find(:test_id, "updated-at").text
expect(updated_at).to have_text(some_date)
end
it "creates sake having close date between created_at and opened_at" do
created_at = Time.zone.parse(find(:test_id, "created-at").text)
updated_at = Time.zone.parse(find(:test_id, "opened-at").text)
delta = 1.second
expect(updated_at).to be_within(delta).of(created_at)
end
it "creates sake having close date between created_at and updated_at" do
created_at = Time.zone.parse(find(:test_id, "created-at").text)
updated_at = Time.zone.parse(find(:test_id, "updated-at").text)
delta = 1.second
expect(updated_at).to be_within(delta).of(created_at)
end
end
describe "creating empty sake" do
before do
select(I18n.t("enums.sake.bottle_level.empty"), from: "select-bottle-level")
click_button("form-submit")
end
it "creates sake having created_at" do
created_at = find(:test_id, "created-at").text
expect(created_at).to have_text(some_date)
end
it "creates sake having opened_at" do
expect(find(:test_id, "opened-at")).to have_text(some_date)
end
it "creates sake having emptied_at" do
expect(find(:test_id, "emptied-at")).to have_text(some_date)
end
it "creates sake having updated_at" do
updated_at = find(:test_id, "updated-at").text
expect(updated_at).to have_text(some_date)
end
it "creates sake having close date between created_at and opened_at" do
created_at = Time.zone.parse(find(:test_id, "created-at").text)
updated_at = Time.zone.parse(find(:test_id, "opened-at").text)
delta = 1.second
expect(updated_at).to be_within(delta).of(created_at)
end
it "creates sake having close date between created_at and emptied_at" do
created_at = Time.zone.parse(find(:test_id, "created-at").text)
updated_at = Time.zone.parse(find(:test_id, "emptied-at").text)
delta = 1.second
expect(updated_at).to be_within(delta).of(created_at)
end
it "creates sake having close date between created_at and updated_at" do
created_at = Time.zone.parse(find(:test_id, "created-at").text)
updated_at = Time.zone.parse(find(:test_id, "updated-at").text)
delta = 1.second
expect(updated_at).to be_within(delta).of(created_at)
end
end
end
|
import mongoose from 'mongoose';
const insuranceCompanySchema = new mongoose.Schema({
companyName: {
type: String
},
businessEmail: {
type: String
},
pocPhoneNumber: {
type: String
},
pocFullname: {
type: String
},
idNumber: {
type: String
},
createdAt: {
type: Date,
default: Date.now
}
});
export default mongoose.model('insuranceCompany', insuranceCompanySchema);
|
export * from './get-params';
export * from './share-url.service';
export * from './share.component';
export * from './share.module';
export * from './share.service';
|
require 'haml'
require 'haml/template'
if Haml::Options.buffer_option_keys.include?(:ugly)
Haml::Template.options[:ugly] = true
end
|
#ifndef FILE_H
#define FILE_H
#include <fstream>
using namespace std;
char get_char_at_pos(int x, int y, fstream* f);
fstream* open_file(char* filename);
#endif
|
./clean.sh
# build db in legacy style
javac -d db/build \
`find db/src/main/java -name "*.java"`
# build db jar
jar --create --file=lib/codetojoy.db.jar \
-C db/build .
# This WON'T WORK without using automatic modules. See Notes.md
javac -d build/modules \
-classpath db/build \
--module-source-path src \
`find src -name "*.java"`
|
import _ from 'lodash';
import React, { useState } from 'react';
interface LayoutContext {
setSubTitle: (subTitle: string | null) => void;
setTitle: (subTitle: string | null) => void;
subTitle?: string | null;
title?: string | null;
}
const initialContext: LayoutContext = {
setSubTitle: () => {},
setTitle: () => {},
subTitle: null,
title: null,
};
const LayoutContext = React.createContext<LayoutContext>(initialContext);
const LayoutProvider: React.FunctionComponent = ({ children }) => {
const [subTitle, setSubTitle] = useState<string | null>(null);
const [title, setTitle] = useState<string | null>(null);
return (
<LayoutContext.Provider
value={{
setSubTitle,
setTitle,
subTitle,
title,
}}
>
{children}
</LayoutContext.Provider>
);
};
export { LayoutProvider, LayoutContext };
|
using ParallelAccelerator
@acc function blurxy()
w = 64
h = 128
inp = zeros(w,h)
inp = map(i -> i[1],enumerate(inp))
blur = map(i -> (inp[max(i[1]-1,1)]+inp[i[1]]+inp[min(i[1]+1,length(inp))])/3,enumerate(inp))
return blur
end
function main()
tic()
blur_out = blurxy()
time = toq()
#println("result = ", blur_out)
println("SELFTIMED ", time)
#benchmark()
end
function benchmark()
maxt = 0
mint = Inf
totalt = 0
for i in 1:100
tic()
centroids_out = kmeans()
t = toq()
println("finished ",i)
if t > maxt
maxt = t
end
if t < mint
mint = t
end
totalt += t
end
println("SELFTIMED AVERAGE ", totalt/100.0)
println("SELFTIMED MINIMUM", mint)
println("SELFTIMED MAXIMUM", maxt)
end
main()
|
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
int main()
{
long long high = 2 * pow(10, 9), low = 1, mid = (high+low)/2;
cout << mid << endl;
string res;
cin >> res;
while (res != "OK") {
if (res == "SINKS")
low = mid + 1;
else if (res == "FLOATS")
high = mid - 1;
mid = (high + low) / 2;
cout << mid << endl;
cin >> res;
}
return 0;
}
|
import buildRequestId from './requestIdBuilder';
import requestRepeatMapBuilder from './requestRepeatMapBuilder';
describe('requestRepeatMapBuilder', () => {
const buildRequest = (method, url) => ({ request: { method, url } });
it('should produce the correct map for a single requests', () => {
const requests = [
buildRequest('GET', 'http://url1.com'),
];
expect(requestRepeatMapBuilder(requests)).toEqual({
[buildRequestId(requests[0].request)]: {
repeated: 1,
invocations: 0,
},
});
});
it('should produce the correct map for a repeating request', () => {
const requests = [
buildRequest('GET', 'http://url1.com'),
buildRequest('GET', 'http://url1.com'),
];
expect(requestRepeatMapBuilder(requests)).toEqual({
[buildRequestId(requests[0].request)]: {
repeated: 2,
invocations: 0,
},
});
});
it('should produce the correct map for a single request and a repeated request', () => {
const requests = [
buildRequest('GET', 'http://url1.com'),
buildRequest('GET', 'http://url1.com'),
buildRequest('GET', 'http://url2.com'),
];
expect(requestRepeatMapBuilder(requests)).toEqual({
[buildRequestId(requests[0].request)]: {
repeated: 2,
invocations: 0,
},
[buildRequestId(requests[2].request)]: {
repeated: 1,
invocations: 0,
},
});
});
it('should produce the correct map for two repeated requests', () => {
const requests = [
buildRequest('GET', 'http://url1.com'),
buildRequest('GET', 'http://url1.com'),
buildRequest('GET', 'http://url2.com'),
buildRequest('GET', 'http://url2.com'),
];
expect(requestRepeatMapBuilder(requests)).toEqual({
[buildRequestId(requests[0].request)]: {
repeated: 2,
invocations: 0,
},
[buildRequestId(requests[2].request)]: {
repeated: 2,
invocations: 0,
},
});
});
it('should produce the correct map for no requests', () => {
expect(requestRepeatMapBuilder([])).toEqual({});
});
it('should produce the correct map for a null request object', () => {
expect(requestRepeatMapBuilder(null)).toEqual({});
});
});
|
#!/bin/bash -xe
#
# This script is run by the bootstrap.sh script in the docker image.
#
# It expects to find the synapse source in /src, and a virtualenv in /venv.
# It installs synapse into the virtualenv, configures sytest according to the
# env vars, and runs sytest.
#
# Run the sytests.
set -e
cd "$(dirname $0)/.."
mkdir -p /work
# start the redis server, if desired
if [ -n "$REDIS" ]; then
/usr/bin/redis-server /etc/redis/redis.conf
fi
# PostgreSQL setup
if [ -n "$MULTI_POSTGRES" ] || [ -n "$POSTGRES" ]; then
sed -i -r "s/^max_connections.*$/max_connections = 500/" "$PGDATA/postgresql.conf"
echo "fsync = off" >> "$PGDATA/postgresql.conf"
echo "full_page_writes = off" >> "$PGDATA/postgresql.conf"
# Start the database
echo "starting postgres..."
su -c 'eatmydata /usr/lib/postgresql/*/bin/pg_ctl -w start -s' postgres
echo "postgres started"
fi
# Now create the databases
if [ -n "$MULTI_POSTGRES" ]; then
# In this mode we want to run synapse against multiple split out databases.
# Make the test databases for the two Synapse servers that will be spun up
su -c psql postgres <<EOF
CREATE DATABASE pg1_main;
CREATE DATABASE pg1_state;
CREATE DATABASE pg2_main;
CREATE DATABASE pg2_state;
EOF
mkdir -p "/work/server-0"
mkdir -p "/work/server-1"
# We leave user, password, host blank to use the defaults (unix socket and
# local auth)
cat > "/work/server-0/databases.yaml" << EOF
main:
name: psycopg2
data_stores:
- main
args:
database: pg1_main
user: postgres
password: $PGPASSWORD
host: localhost
sslmode: disable
state_db:
name: psycopg2
data_stores:
- state
args:
database: pg1_state
user: postgres
password: $PGPASSWORD
host: localhost
sslmode: disable
EOF
cat > "/work/server-1/databases.yaml" << EOF
main:
name: psycopg2
data_stores:
- main
args:
database: pg2_main
user: postgres
password: $PGPASSWORD
host: localhost
sslmode: disable
state_db:
name: psycopg2
data_stores:
- state
args:
database: pg2_state
user: postgres
password: $PGPASSWORD
host: localhost
sslmode: disable
EOF
elif [ -n "$POSTGRES" ]; then
# Env vars used by prep_sytest_for_postgres script.
export PGUSER=postgres
export POSTGRES_DB_1=pg1
export POSTGRES_DB_2=pg2
# Write out the configuration for a PostgreSQL using Synapse
./scripts/prep_sytest_for_postgres.sh
# Make the test databases for the two Synapse servers that will be spun up
su -c 'psql -c "CREATE DATABASE pg1;"' postgres
su -c 'psql -c "CREATE DATABASE pg2;"' postgres
fi
# default value for SYNAPSE_SOURCE
: ${SYNAPSE_SOURCE:=/src}
# if we're running against a source directory, turn it into a tarball. pip
# will then unpack it to a temporary location, and build it. (As of pip 20.1,
# it will otherwise try to build it in-tree, which means writing changes to the
# source volume outside the container.)
#
if [ -d "$SYNAPSE_SOURCE" ]; then
echo "Creating tarball from synapse source"
tar -C "$SYNAPSE_SOURCE" -czf /tmp/synapse.tar.gz \
synapse scripts setup.py README.rst synctl MANIFEST.in
SYNAPSE_SOURCE="/tmp/synapse.tar.gz"
elif [ ! -r "$SYNAPSE_SOURCE" ]; then
echo "Unable to read synapse source at $SYNAPSE_SOURCE" >&2
exit 1
fi
if [ -n "$OFFLINE" ]; then
# if we're in offline mode, just put synapse into the virtualenv, and
# hope that the deps are up-to-date.
#
# --no-use-pep517 works around what appears to be a pip issue
# (https://github.com/pypa/pip/issues/5402 possibly) where pip wants
# to reinstall any requirements for the build system, even if they are
# already installed.
/venv/bin/pip install --no-index --no-use-pep517 "$SYNAPSE_SOURCE"
else
# We've already created the virtualenv, but lets double check we have all
# deps.
/venv/bin/pip install -q --upgrade --no-cache-dir "$SYNAPSE_SOURCE"[redis]
/venv/bin/pip install -q --upgrade --no-cache-dir \
lxml psycopg2 coverage codecov tap.py coverage_enable_subprocess
# Make sure all Perl deps are installed -- this is done in the docker build
# so will only install packages added since the last Docker build
./install-deps.pl
fi
if [ -z "$BLACKLIST" ]; then
BLACKLIST=sytest-blacklist
fi
# Run the tests
echo >&2 "+++ Running tests"
export COVERAGE_PROCESS_START="/src/.coveragerc"
RUN_TESTS=(
perl -I "$SYTEST_LIB" /sytest/run-tests.pl --python=/venv/bin/python --synapse-directory=/src -B "/src/$BLACKLIST" --coverage -O tap --all
--work-directory="/work"
)
if [ -n "$WORKERS" ]; then
RUN_TESTS+=(-I Synapse::ViaHaproxy --workers)
else
RUN_TESTS+=(-I Synapse)
fi
if [ -n "$REDIS" ]; then
RUN_TESTS+=(--redis-host=localhost)
fi
mkdir -p /logs
TEST_STATUS=0
"${RUN_TESTS[@]}" "$@" >/logs/results.tap &
pid=$!
# make sure that we kill the test runner on SIGTERM, SIGINT, etc
trap 'kill $pid' TERM INT
wait $pid || TEST_STATUS=$?
trap - TERM INT
if [ $TEST_STATUS -ne 0 ]; then
echo >&2 -e "run-tests \e[31mFAILED\e[0m: exit code $TEST_STATUS"
else
echo >&2 -e "run-tests \e[32mPASSED\e[0m"
fi
echo >&2 "--- Copying assets"
# Copy out the logs
rsync --ignore-missing-args --min-size=1B -av /work/server-0 /work/server-1 /logs --include "*/" --include="*.log.*" --include="*.log" --exclude="*"
#cp /.coverage.* /src || true
#cd /src
#export TOP=/src
#/venv/bin/coverage combine
# Generate annotate.md. This is Buildkite-specific.
if [ -n "$BUILDKITE_LABEL" ] && [ $TEST_STATUS -ne 0 ]; then
# Build the annotation
perl /sytest/scripts/format_tap.pl /logs/results.tap "$BUILDKITE_LABEL" >/logs/annotate.md
fi
exit $TEST_STATUS
|
class Solution:
def smallestCommonElement(self, mat: List[List[int]]) -> int:
# using bisect algorithm to binary search for the element
from bisect import bisect_left
def index(a, x):
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
else:
return -1
# Greedy algorithm to find the lowest element
head_line = mat[0]
for low in head_line:
exist_in_all = True
for array in mat[1:]:
loc = index(array, low)
if loc == -1:
exist_in_all = False
break
if exist_in_all:
return low
return -1
class SolutionMergeK:
def smallestCommonElement(self, mat: List[List[int]]) -> int:
k_cursors = [0 for _ in range(len(mat))]
cursor_num = len(k_cursors)
row_length = len(mat[0])
curr_max, curr_cnt = 0, 0
while True:
for k in range(cursor_num):
cursor = k_cursors[k]
while cursor < row_length and mat[k][cursor] < curr_max:
cursor += 1
# exceed one of the rows
if cursor == row_length:
return -1
k_cursors[k] = cursor
if mat[k][cursor] > curr_max:
# reset the max value and its counter
curr_max = mat[k][cursor]
curr_cnt = 1
else: # mat[k][cursor] == curr_max
curr_cnt += 1
if curr_cnt == cursor_num:
return curr_max
|
require "app"
require "test_helper"
describe "help" do
before do
@app = FactoryBot.build(:app)
end
it "prints help with no args" do
cmd = @app.run
assert_includes(cmd.stdout, "Usage")
assert_includes(cmd.stdout, "help (default)")
end
it "prints help with no args from cli" do
out = `./run`
assert_includes(out, "Usage")
assert_includes(out, "help (default)")
end
end
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.