text stringlengths 9 39.2M | dir stringlengths 26 295 | lang stringclasses 185
values | created_date timestamp[us] | updated_date timestamp[us] | repo_name stringlengths 1 97 | repo_full_name stringlengths 7 106 | star int64 1k 183k | len_tokens int64 1 13.8M |
|---|---|---|---|---|---|---|---|---|
```xml
import fastify from '../../fastify'
import { expectType } from 'tsd'
type TestType = void
declare module '../../fastify' {
interface FastifyRequest {
testProp: TestType;
}
interface FastifyReply {
testProp: TestType;
}
}
fastify().get('/', (req, res) => {
expectType<TestType>(req.testProp)
expectType<TestType>(res.testProp)
})
``` | /content/code_sandbox/test/types/decorate-request-reply.test-d.ts | xml | 2016-09-28T19:10:14 | 2024-08-16T19:06:24 | fastify | fastify/fastify | 31,648 | 96 |
```xml
import { ConflictParams, ConflictType, HttpRequest } from '@standardnotes/responses'
import { AccountSyncOperation } from '@Lib/Services/Sync/Account/Operation'
import {
LoggerInterface,
Uuids,
extendArray,
isNotUndefined,
isNullOrUndefined,
removeFromIndex,
sleep,
subtractFromArray,
} from '@standardnotes/utils'
import { ItemManager } from '@Lib/Services/Items/ItemManager'
import { OfflineSyncOperation } from '@Lib/Services/Sync/Offline/Operation'
import { PayloadManager } from '../Payloads/PayloadManager'
import { LegacyApiService } from '../Api/ApiService'
import { HistoryManager } from '../History/HistoryManager'
import { SNLog } from '@Lib/Log'
import { SessionManager } from '../Session/SessionManager'
import { DiskStorageService } from '../Storage/DiskStorageService'
import { SyncPromise } from './Types'
import { ServerSyncResponse } from '@Lib/Services/Sync/Account/Response'
import { ServerSyncResponseResolver } from '@Lib/Services/Sync/Account/ResponseResolver'
import { SyncSignal, SyncStats } from '@Lib/Services/Sync/Signals'
import { UuidString } from '../../Types/UuidString'
import {
PayloadSource,
CreateDecryptedItemFromPayload,
FilterDisallowedRemotePayloadsAndMap,
DeltaOutOfSync,
ImmutablePayloadCollection,
CreatePayload,
isEncryptedPayload,
isDecryptedPayload,
EncryptedPayloadInterface,
DecryptedPayloadInterface,
ItemsKeyContent,
FullyFormedPayloadInterface,
DeletedPayloadInterface,
DecryptedPayload,
CreateEncryptedServerSyncPushPayload,
ServerSyncPushContextualPayload,
isDeletedItem,
DeletedItemInterface,
DecryptedItemInterface,
CreatePayloadSplit,
CreateDeletedServerSyncPushPayload,
ItemsKeyInterface,
CreateNonDecryptedPayloadSplit,
DeltaOfflineSaved,
FilteredServerItem,
PayloadEmitSource,
getIncrementedDirtyIndex,
getCurrentDirtyIndex,
ItemContent,
KeySystemItemsKeyContent,
KeySystemItemsKeyInterface,
FullyFormedTransferPayload,
ItemMutator,
isDecryptedOrDeletedItem,
MutationType,
} from '@standardnotes/models'
import {
AbstractService,
SyncEvent,
SyncSource,
InternalEventHandlerInterface,
InternalEventBusInterface,
StorageKey,
InternalEventInterface,
IntegrityEvent,
IntegrityEventPayload,
SyncMode,
SyncOptions,
SyncQueueStrategy,
SyncServiceInterface,
EncryptionService,
DeviceInterface,
isFullEntryLoadChunkResponse,
isChunkFullEntry,
SyncEventReceivedSharedVaultInvitesData,
SyncEventReceivedRemoteSharedVaultsData,
SyncEventReceivedNotificationsData,
SyncEventReceivedAsymmetricMessagesData,
SyncOpStatus,
ApplicationSyncOptions,
WebSocketsServiceEvent,
WebSocketsService,
SyncBackoffServiceInterface,
} from '@standardnotes/services'
import { OfflineSyncResponse } from './Offline/Response'
import {
CreateDecryptionSplitWithKeyLookup,
CreateEncryptionSplitWithKeyLookup,
KeyedDecryptionSplit,
SplitPayloadsByEncryptionType,
} from '@standardnotes/encryption'
import { CreatePayloadFromRawServerItem } from './Account/Utilities'
import { DecryptedServerConflictMap, TrustedServerConflictMap } from './Account/ServerConflictMap'
import { ContentType } from '@standardnotes/domain-core'
import { SyncFrequencyGuardInterface } from './SyncFrequencyGuardInterface'
const DEFAULT_MAJOR_CHANGE_THRESHOLD = 15
const INVALID_SESSION_RESPONSE_STATUS = 401
const TOO_MANY_REQUESTS_RESPONSE_STATUS = 429
const DEFAULT_AUTO_SYNC_INTERVAL = 30_000
/** Content types appearing first are always mapped first */
const ContentTypeLocalLoadPriorty = [
ContentType.TYPES.ItemsKey,
ContentType.TYPES.KeySystemRootKey,
ContentType.TYPES.KeySystemItemsKey,
ContentType.TYPES.VaultListing,
ContentType.TYPES.TrustedContact,
ContentType.TYPES.UserPrefs,
ContentType.TYPES.Component,
ContentType.TYPES.Theme,
]
/**
* The sync service orchestrates with the model manager, api service, and storage service
* to ensure consistent state between the three. When a change is made to an item, consumers
* call the sync service's sync function to first persist pending changes to local storage.
* Then, the items are uploaded to the server. The sync service handles server responses,
* including mapping any retrieved items to application state via model manager mapping.
* After each sync request, any changes made or retrieved are also persisted locally.
* The sync service largely does not perform any task unless it is called upon.
*/
export class SyncService
extends AbstractService<SyncEvent>
implements SyncServiceInterface, InternalEventHandlerInterface
{
private dirtyIndexAtLastPresyncSave?: number
private lastSyncDate?: Date
private outOfSync = false
private opStatus: SyncOpStatus
private resolveQueue: SyncPromise[] = []
private spawnQueue: SyncPromise[] = []
/* A DownloadFirst sync must always be the first sync completed */
public completedOnlineDownloadFirstSync = false
private majorChangeThreshold = DEFAULT_MAJOR_CHANGE_THRESHOLD
private clientLocked = false
private databaseLoaded = false
private syncToken?: string
private cursorToken?: string
private syncLock = false
private _simulate_latency?: { latency: number; enabled: boolean }
private dealloced = false
public lastSyncInvokationPromise?: Promise<unknown>
public currentSyncRequestPromise?: Promise<void>
private autoSyncInterval?: NodeJS.Timer
private wasNotifiedOfItemsChangeOnServer = false
constructor(
private itemManager: ItemManager,
private sessionManager: SessionManager,
private encryptionService: EncryptionService,
private storageService: DiskStorageService,
private payloadManager: PayloadManager,
private apiService: LegacyApiService,
private historyService: HistoryManager,
private device: DeviceInterface,
private identifier: string,
private readonly options: ApplicationSyncOptions,
private logger: LoggerInterface,
private sockets: WebSocketsService,
private syncFrequencyGuard: SyncFrequencyGuardInterface,
private syncBackoffService: SyncBackoffServiceInterface,
protected override internalEventBus: InternalEventBusInterface,
) {
super(internalEventBus)
this.opStatus = this.initializeStatus()
}
/**
* If the database has been newly created (because its new or was previously destroyed)
* we want to reset any sync tokens we have.
*/
public async onNewDatabaseCreated(): Promise<void> {
if (await this.getLastSyncToken()) {
await this.clearSyncPositionTokens()
}
}
private get launchPriorityUuids() {
return this.storageService.getValue<string[]>(StorageKey.LaunchPriorityUuids) ?? []
}
public setLaunchPriorityUuids(launchPriorityUuids: string[]) {
this.storageService.setValue(StorageKey.LaunchPriorityUuids, launchPriorityUuids)
}
public override deinit(): void {
this.dealloced = true
if (this.autoSyncInterval) {
clearInterval(this.autoSyncInterval)
}
;(this.autoSyncInterval as unknown) = undefined
;(this.sessionManager as unknown) = undefined
;(this.itemManager as unknown) = undefined
;(this.encryptionService as unknown) = undefined
;(this.payloadManager as unknown) = undefined
;(this.storageService as unknown) = undefined
;(this.apiService as unknown) = undefined
this.opStatus.reset()
;(this.opStatus as unknown) = undefined
this.resolveQueue.length = 0
this.spawnQueue.length = 0
super.deinit()
}
private initializeStatus() {
return new SyncOpStatus(setInterval, (event) => {
void this.notifyEvent(event)
})
}
public lockSyncing(): void {
this.clientLocked = true
}
public unlockSyncing(): void {
this.clientLocked = false
}
public isOutOfSync(): boolean {
return this.outOfSync
}
public getLastSyncDate(): Date | undefined {
return this.lastSyncDate
}
public getSyncStatus(): SyncOpStatus {
return this.opStatus
}
/**
* Called by application when sign in or registration occurs.
*/
public resetSyncState(): void {
this.dirtyIndexAtLastPresyncSave = undefined
this.lastSyncDate = undefined
this.outOfSync = false
}
public isDatabaseLoaded(): boolean {
return this.databaseLoaded
}
private async processPriorityItemsForDatabaseLoad(items: FullyFormedPayloadInterface[]): Promise<void> {
if (items.length === 0) {
return
}
const encryptedPayloads = items.filter(isEncryptedPayload)
const alreadyDecryptedPayloads = items.filter(isDecryptedPayload) as DecryptedPayloadInterface<ItemsKeyContent>[]
const encryptionSplit = SplitPayloadsByEncryptionType(encryptedPayloads)
const decryptionSplit = CreateDecryptionSplitWithKeyLookup(encryptionSplit)
const newlyDecryptedPayloads = await this.encryptionService.decryptSplit(decryptionSplit)
await this.payloadManager.emitPayloads(
[...alreadyDecryptedPayloads, ...newlyDecryptedPayloads],
PayloadEmitSource.LocalDatabaseLoaded,
)
}
public async loadDatabasePayloads(): Promise<void> {
this.logger.debug('Loading database payloads')
if (this.databaseLoaded) {
throw 'Attempting to initialize already initialized local database.'
}
const chunks = await this.device.getDatabaseLoadChunks(
{
batchSize: this.options.loadBatchSize,
contentTypePriority: ContentTypeLocalLoadPriorty,
uuidPriority: this.launchPriorityUuids,
},
this.identifier,
)
const itemsKeyEntries = isFullEntryLoadChunkResponse(chunks)
? chunks.fullEntries.itemsKeys.entries
: await this.device.getDatabaseEntries(this.identifier, chunks.keys.itemsKeys.keys)
const keySystemRootKeyEntries = isFullEntryLoadChunkResponse(chunks)
? chunks.fullEntries.keySystemRootKeys.entries
: await this.device.getDatabaseEntries(this.identifier, chunks.keys.keySystemRootKeys.keys)
const keySystemItemsKeyEntries = isFullEntryLoadChunkResponse(chunks)
? chunks.fullEntries.keySystemItemsKeys.entries
: await this.device.getDatabaseEntries(this.identifier, chunks.keys.keySystemItemsKeys.keys)
const createPayloadFromEntry = (entry: FullyFormedTransferPayload) => {
try {
return CreatePayload(entry, PayloadSource.LocalDatabaseLoaded)
} catch (e) {
console.error('Creating payload failed', e)
return undefined
}
}
await this.processPriorityItemsForDatabaseLoad(itemsKeyEntries.map(createPayloadFromEntry).filter(isNotUndefined))
await this.processPriorityItemsForDatabaseLoad(
keySystemRootKeyEntries.map(createPayloadFromEntry).filter(isNotUndefined),
)
await this.processPriorityItemsForDatabaseLoad(
keySystemItemsKeyEntries.map(createPayloadFromEntry).filter(isNotUndefined),
)
/**
* Map in batches to give interface a chance to update. Note that total decryption
* time is constant regardless of batch size. Decrypting 3000 items all at once or in
* batches will result in the same time spent. It's the emitting/painting/rendering
* that requires batch size optimization.
*/
const payloadCount = chunks.remainingChunksItemCount
let totalProcessedCount = 0
const remainingChunks = isFullEntryLoadChunkResponse(chunks)
? chunks.fullEntries.remainingChunks
: chunks.keys.remainingChunks
let chunkIndex = 0
const ChunkIndexOfContentTypePriorityItems = 0
for (const chunk of remainingChunks) {
const dbEntries = isChunkFullEntry(chunk)
? chunk.entries
: await this.device.getDatabaseEntries(this.identifier, chunk.keys)
const payloads = dbEntries
.map((entry) => {
try {
return CreatePayload(entry, PayloadSource.LocalDatabaseLoaded)
} catch (e) {
console.error('Creating payload failed', e)
return undefined
}
})
.filter(isNotUndefined)
await this.processPayloadBatch(payloads, totalProcessedCount, payloadCount)
const shouldSleepOnlyAfterFirstRegularBatch = chunkIndex > ChunkIndexOfContentTypePriorityItems
if (shouldSleepOnlyAfterFirstRegularBatch) {
await sleep(this.options.sleepBetweenBatches, false, 'Sleeping to allow interface to update')
}
totalProcessedCount += payloads.length
chunkIndex++
}
this.databaseLoaded = true
this.opStatus.setDatabaseLoadStatus(0, 0, true)
}
beginAutoSyncTimer(): void {
this.autoSyncInterval = setInterval(this.autoSync.bind(this), DEFAULT_AUTO_SYNC_INTERVAL)
}
private autoSync(): void {
if (!this.sockets.isWebSocketConnectionOpen()) {
this.logger.debug('WebSocket connection is closed, doing autosync')
void this.sync({ sourceDescription: 'Auto Sync' })
return
}
if (this.wasNotifiedOfItemsChangeOnServer) {
this.logger.debug('Was notified of items changed on server, doing autosync')
this.wasNotifiedOfItemsChangeOnServer = false
void this.sync({ sourceDescription: 'WebSockets Event - Items Changed On Server' })
}
}
private async processPayloadBatch(
batch: FullyFormedPayloadInterface<ItemContent>[],
currentPosition?: number,
payloadCount?: number,
) {
this.logger.debug('Processing batch at index', currentPosition, 'length', batch.length)
const encrypted: EncryptedPayloadInterface[] = []
const nonencrypted: (DecryptedPayloadInterface | DeletedPayloadInterface)[] = []
for (const payload of batch) {
if (isEncryptedPayload(payload)) {
encrypted.push(payload)
} else {
nonencrypted.push(payload)
}
}
const encryptionSplit = SplitPayloadsByEncryptionType(encrypted)
const decryptionSplit = CreateDecryptionSplitWithKeyLookup(encryptionSplit)
const results = await this.encryptionService.decryptSplit(decryptionSplit)
await this.payloadManager.emitPayloads([...nonencrypted, ...results], PayloadEmitSource.LocalDatabaseLoaded)
void this.notifyEvent(SyncEvent.LocalDataIncrementalLoad)
if (currentPosition != undefined && payloadCount != undefined) {
this.opStatus.setDatabaseLoadStatus(currentPosition, payloadCount, false)
}
}
private setLastSyncToken(token: string) {
this.syncToken = token
return this.storageService.setValue(StorageKey.LastSyncToken, token)
}
private async setPaginationToken(token: string) {
this.cursorToken = token
if (token) {
return this.storageService.setValue(StorageKey.PaginationToken, token)
} else {
return this.storageService.removeValue(StorageKey.PaginationToken)
}
}
private async getLastSyncToken(): Promise<string> {
if (!this.syncToken) {
this.syncToken = (await this.storageService.getValue(StorageKey.LastSyncToken)) as string
}
return this.syncToken
}
private async getPaginationToken(): Promise<string> {
if (!this.cursorToken) {
this.cursorToken = (await this.storageService.getValue(StorageKey.PaginationToken)) as string
}
return this.cursorToken
}
private async clearSyncPositionTokens() {
this.syncToken = undefined
this.cursorToken = undefined
await this.storageService.removeValue(StorageKey.LastSyncToken)
await this.storageService.removeValue(StorageKey.PaginationToken)
}
private itemsNeedingSync() {
const dirtyItems = this.itemManager.getDirtyItems()
const itemsWithoutBackoffPenalty = dirtyItems.filter((item) => !this.syncBackoffService.isItemInBackoff(item))
return itemsWithoutBackoffPenalty
}
public async markAllItemsAsNeedingSyncAndPersist(): Promise<void> {
this.logger.debug('Marking all items as needing sync')
const items = this.itemManager.items
const payloads = items.map((item) => {
return new DecryptedPayload({
...item.payload.ejected(),
dirty: true,
dirtyIndex: getIncrementedDirtyIndex(),
})
})
await this.payloadManager.emitPayloads(payloads, PayloadEmitSource.LocalChanged)
/**
* When signing into an 003 account (or an account that is not the latest), the temporary items key will be 004
* and will not match user account version, triggering a key not found exception. This error resolves once the
* download first sync completes and the correct key is downloaded. We suppress any persistence
* exceptions here to avoid showing an error to the user.
*/
const hidePersistErrorDueToWaitingOnKeyDownload = true
await this.persistPayloads(payloads, { throwError: !hidePersistErrorDueToWaitingOnKeyDownload })
}
/**
* Return the payloads that need local persistence, before beginning a sync.
* This way, if the application is closed before a sync request completes,
* pending data will be saved to disk, and synced the next time the app opens.
*/
private popPayloadsNeedingPreSyncSave(from: (DecryptedPayloadInterface | DeletedPayloadInterface)[]) {
const lastPreSyncSave = this.dirtyIndexAtLastPresyncSave
if (lastPreSyncSave == undefined) {
return from
}
const payloads = from.filter((candidate) => {
return !candidate.dirtyIndex || candidate.dirtyIndex > lastPreSyncSave
})
this.dirtyIndexAtLastPresyncSave = getCurrentDirtyIndex()
return payloads
}
private queueStrategyResolveOnNext(): Promise<unknown> {
return new Promise((resolve, reject) => {
this.resolveQueue.push({ resolve, reject })
})
}
private queueStrategyForceSpawnNew(options: SyncOptions) {
return new Promise((resolve, reject) => {
this.spawnQueue.push({ resolve, reject, options })
})
}
/**
* For timing strategy SyncQueueStrategy.ForceSpawnNew, we will execute a whole sync request
* and pop it from the queue.
*/
private popSpawnQueue() {
if (this.spawnQueue.length === 0) {
return null
}
const promise = this.spawnQueue[0]
removeFromIndex(this.spawnQueue, 0)
this.logger.debug('Syncing again from spawn queue')
return this.sync({
queueStrategy: SyncQueueStrategy.ForceSpawnNew,
source: SyncSource.SpawnQueue,
...promise.options,
})
.then(() => {
promise.resolve()
})
.catch(() => {
promise.reject()
})
}
private async payloadsByPreparingForServer(
payloads: (DecryptedPayloadInterface | DeletedPayloadInterface)[],
): Promise<ServerSyncPushContextualPayload[]> {
const payloadSplit = CreatePayloadSplit(payloads)
const encryptionSplit = SplitPayloadsByEncryptionType(payloadSplit.decrypted)
const keyLookupSplit = CreateEncryptionSplitWithKeyLookup(encryptionSplit)
const encryptedResults = await this.encryptionService.encryptSplit(keyLookupSplit)
const contextPayloads = [
...encryptedResults.map(CreateEncryptedServerSyncPushPayload),
...payloadSplit.deleted.map(CreateDeletedServerSyncPushPayload),
]
return contextPayloads
}
public async downloadFirstSync(waitTimeOnFailureMs: number, otherSyncOptions?: Partial<SyncOptions>): Promise<void> {
const maxTries = 5
for (let i = 0; i < maxTries; i++) {
await this.sync({
mode: SyncMode.DownloadFirst,
queueStrategy: SyncQueueStrategy.ForceSpawnNew,
source: SyncSource.External,
...otherSyncOptions,
}).catch(console.error)
if (this.completedOnlineDownloadFirstSync) {
return
} else {
await sleep(waitTimeOnFailureMs)
}
}
console.error(`Failed downloadFirstSync after ${maxTries} tries`)
}
public async awaitCurrentSyncs(): Promise<void> {
await this.lastSyncInvokationPromise
await this.currentSyncRequestPromise
}
public async sync(options: Partial<SyncOptions> = {}): Promise<unknown> {
if (this.clientLocked) {
this.logger.debug('Sync locked by client')
return
}
const fullyResolvedOptions: SyncOptions = {
source: SyncSource.External,
...options,
}
this.lastSyncInvokationPromise = this.performSync(fullyResolvedOptions)
return this.lastSyncInvokationPromise
}
private async prepareForSync(options: SyncOptions) {
const items = this.itemsNeedingSync()
/**
* Freeze the begin date immediately after getting items needing sync. This way an
* item dirtied at any point after this date is marked as needing another sync
*/
const beginDate = new Date()
const frozenDirtyIndex = getCurrentDirtyIndex()
/**
* Items that have never been synced and marked as deleted should not be
* uploaded to server, and instead deleted directly after sync completion.
*/
const neverSyncedDeleted: DeletedItemInterface[] = items.filter((item) => {
return item.neverSynced && isDeletedItem(item)
}) as DeletedItemInterface[]
subtractFromArray(items, neverSyncedDeleted)
const decryptedPayloads = items.map((item) => {
return item.payloadRepresentation()
})
const payloadsNeedingSave = this.popPayloadsNeedingPreSyncSave(decryptedPayloads)
const hidePersistErrorDueToWaitingOnKeyDownload = options.mode === SyncMode.DownloadFirst
await this.persistPayloads(payloadsNeedingSave, { throwError: !hidePersistErrorDueToWaitingOnKeyDownload })
if (options.onPresyncSave) {
options.onPresyncSave()
}
return { items, beginDate, frozenDirtyIndex, neverSyncedDeleted }
}
/**
* Allows us to lock this function from triggering duplicate network requests.
* There are two types of locking checks:
* 1. syncLocked(): If a call to sync() call has begun preparing to be sent to the server.
* but not yet completed all the code below before reaching that point.
* (before reaching opStatus.setDidBegin).
* 2. syncOpInProgress: If a sync() call is in flight to the server.
*/
private configureSyncLock(options: SyncOptions) {
const syncInProgress = this.opStatus.syncInProgress
const databaseLoaded = this.databaseLoaded
const canExecuteSync = !this.syncLock
const syncLimitReached = this.syncFrequencyGuard.isSyncCallsThresholdReachedThisMinute()
const shouldExecuteSync = canExecuteSync && databaseLoaded && !syncInProgress && !syncLimitReached
if (shouldExecuteSync) {
this.syncLock = true
} else {
this.logger.debug(
!canExecuteSync
? 'Another function call has begun preparing for sync.'
: syncInProgress
? 'Attempting to sync while existing sync in progress.'
: 'Attempting to sync before local database has loaded.',
options,
)
}
const releaseLock = () => {
this.syncLock = false
}
return { shouldExecuteSync, releaseLock }
}
private deferSyncRequest(options: SyncOptions) {
const useStrategy = !isNullOrUndefined(options.queueStrategy)
? options.queueStrategy
: SyncQueueStrategy.ResolveOnNext
if (useStrategy === SyncQueueStrategy.ResolveOnNext) {
return this.queueStrategyResolveOnNext()
} else if (useStrategy === SyncQueueStrategy.ForceSpawnNew) {
return this.queueStrategyForceSpawnNew(options)
} else {
throw Error('Unhandled timing strategy')
}
}
private async prepareForSyncExecution(
items: (DecryptedItemInterface | DeletedItemInterface)[],
inTimeResolveQueue: SyncPromise[],
beginDate: Date,
frozenDirtyIndex: number,
) {
this.opStatus.setDidBegin()
await this.notifyEvent(SyncEvent.SyncDidBeginProcessing)
/**
* Subtract from array as soon as we're sure they'll be called.
* resolves are triggered at the end of this function call
*/
subtractFromArray(this.resolveQueue, inTimeResolveQueue)
/**
* lastSyncBegan must be set *after* any point we may have returned above.
* Setting this value means the item was 100% sent to the server.
*/
if (items.length > 0) {
return this.setLastSyncBeganForItems(items, beginDate, frozenDirtyIndex)
} else {
return items
}
}
private async setLastSyncBeganForItems(
itemsToLookupUuidsFor: (DecryptedItemInterface | DeletedItemInterface)[],
date: Date,
globalDirtyIndex: number,
): Promise<(DecryptedItemInterface | DeletedItemInterface)[]> {
const uuids = Uuids(itemsToLookupUuidsFor)
const items = this.itemManager.getCollection().findAll(uuids).filter(isDecryptedOrDeletedItem)
const payloads: (DecryptedPayloadInterface | DeletedPayloadInterface)[] = []
for (const item of items) {
const mutator = new ItemMutator<DecryptedPayloadInterface | DeletedPayloadInterface>(
item,
MutationType.NonDirtying,
)
mutator.setBeginSync(date, globalDirtyIndex)
const payload = mutator.getResult()
payloads.push(payload)
}
await this.payloadManager.emitPayloads(payloads, PayloadEmitSource.PreSyncSave)
return this.itemManager.findAnyItems(uuids) as (DecryptedItemInterface | DeletedItemInterface)[]
}
/**
* The InTime resolve queue refers to any sync requests that were made while we still
* have not sent out the current request. So, anything in the InTime resolve queue
* will have made it "in time" to piggyback on the current request. Anything that comes
* after InTime will schedule a new sync request.
*/
private getPendingRequestsMadeInTimeToPiggyBackOnCurrentRequest() {
return this.resolveQueue.slice()
}
private getOfflineSyncParameters(
payloads: (DecryptedPayloadInterface | DeletedPayloadInterface)[],
mode: SyncMode = SyncMode.Default,
): {
uploadPayloads: (DecryptedPayloadInterface | DeletedPayloadInterface)[]
} {
const uploadPayloads: (DecryptedPayloadInterface | DeletedPayloadInterface)[] =
mode === SyncMode.Default ? payloads : []
return { uploadPayloads }
}
private createOfflineSyncOperation(
payloads: (DeletedPayloadInterface | DecryptedPayloadInterface)[],
options: SyncOptions,
) {
this.logger.debug(
'Syncing offline user',
'source:',
SyncSource[options.source],
'sourceDesc',
options.sourceDescription,
'mode:',
options.mode && SyncMode[options.mode],
'payloads:',
payloads,
)
const operation = new OfflineSyncOperation(payloads, async (type, response) => {
if (this.dealloced) {
return
}
if (type === SyncSignal.Response && response) {
await this.handleOfflineResponse(response)
}
})
return operation
}
private async getOnlineSyncParameters(
payloads: (DecryptedPayloadInterface | DeletedPayloadInterface)[],
mode: SyncMode = SyncMode.Default,
): Promise<{
uploadPayloads: ServerSyncPushContextualPayload[]
syncMode: SyncMode
}> {
const useMode = !this.completedOnlineDownloadFirstSync ? SyncMode.DownloadFirst : mode
if (useMode === SyncMode.Default && !this.completedOnlineDownloadFirstSync) {
throw Error('Attempting to default mode sync without having completed initial.')
}
const uploadPayloads: ServerSyncPushContextualPayload[] =
useMode === SyncMode.Default ? await this.payloadsByPreparingForServer(payloads) : []
return { uploadPayloads, syncMode: useMode }
}
private async createServerSyncOperation(
payloads: ServerSyncPushContextualPayload[],
options: SyncOptions,
mode: SyncMode = SyncMode.Default,
) {
const syncToken =
options.sharedVaultUuids && options.sharedVaultUuids.length > 0 && options.syncSharedVaultsFromScratch
? undefined
: await this.getLastSyncToken()
const paginationToken =
options.sharedVaultUuids && options.syncSharedVaultsFromScratch ? undefined : await this.getPaginationToken()
const operation = new AccountSyncOperation(
payloads,
async (type: SyncSignal, response?: ServerSyncResponse, stats?: SyncStats) => {
switch (type) {
case SyncSignal.Response:
if (this.dealloced) {
return
}
if (response?.hasError) {
this.handleErrorServerResponse(response)
} else if (response) {
await this.handleSuccessServerResponse(operation, response)
}
break
case SyncSignal.StatusChanged:
if (stats) {
this.opStatus.setUploadStatus(stats.completedUploadCount, stats.totalUploadCount)
}
break
}
},
this.apiService,
{
syncToken,
paginationToken,
sharedVaultUuids: options.sharedVaultUuids,
},
)
this.logger.debug(
'Syncing online user',
'source',
SyncSource[options.source],
'operation id',
operation.id,
'integrity check',
options.checkIntegrity,
'mode',
SyncMode[mode],
'syncToken',
syncToken,
'cursorToken',
paginationToken,
'payloads',
payloads,
)
return operation
}
private async createSyncOperation(
payloads: (DecryptedPayloadInterface | DeletedPayloadInterface)[],
online: boolean,
options: SyncOptions,
): Promise<{ operation: AccountSyncOperation | OfflineSyncOperation; mode: SyncMode }> {
if (online) {
const { uploadPayloads, syncMode } = await this.getOnlineSyncParameters(payloads, options.mode)
return {
operation: await this.createServerSyncOperation(uploadPayloads, options, syncMode),
mode: syncMode,
}
} else {
const { uploadPayloads } = this.getOfflineSyncParameters(payloads, options.mode)
return {
operation: this.createOfflineSyncOperation(uploadPayloads, options),
mode: options.mode || SyncMode.Default,
}
}
}
private async performSync(options: SyncOptions): Promise<unknown> {
const { shouldExecuteSync, releaseLock } = this.configureSyncLock(options)
const { items, beginDate, frozenDirtyIndex, neverSyncedDeleted } = await this.prepareForSync(options)
if (options.mode === SyncMode.LocalOnly) {
this.logger.debug('Syncing local only, skipping remote sync request')
releaseLock()
return
}
const inTimeResolveQueue = this.getPendingRequestsMadeInTimeToPiggyBackOnCurrentRequest()
if (!shouldExecuteSync) {
return this.deferSyncRequest(options)
}
if (this.dealloced) {
return
}
const latestItems = await this.prepareForSyncExecution(items, inTimeResolveQueue, beginDate, frozenDirtyIndex)
const online = this.sessionManager.online()
const { operation, mode: syncMode } = await this.createSyncOperation(
latestItems.map((i) => i.payloadRepresentation()),
online,
options,
)
const operationPromise = operation.run()
this.currentSyncRequestPromise = operationPromise
await operationPromise
if (this.dealloced) {
return
}
releaseLock()
const { hasError } = await this.handleSyncOperationFinish(operation, options, neverSyncedDeleted, syncMode)
if (hasError) {
return
}
const didSyncAgain = await this.potentiallySyncAgainAfterSyncCompletion(
syncMode,
options,
inTimeResolveQueue,
online,
)
if (didSyncAgain) {
return
}
if (options.checkIntegrity && online) {
await this.notifyEventSync(SyncEvent.SyncRequestsIntegrityCheck, {
source: options.source as SyncSource,
})
}
await this.notifyEventSync(SyncEvent.SyncCompletedWithAllItemsUploadedAndDownloaded, {
source: options.source,
options,
})
this.resolvePendingSyncRequestsThatMadeItInTimeOfCurrentRequest(inTimeResolveQueue)
return undefined
}
async getRawSyncRequestForExternalUse(
items: (DecryptedItemInterface | DeletedItemInterface)[],
): Promise<HttpRequest | undefined> {
if (this.dealloced) {
return
}
const online = this.sessionManager.online()
if (!online) {
return
}
const payloads = await this.payloadsByPreparingForServer(items.map((i) => i.payloadRepresentation()))
const syncToken = await this.getLastSyncToken()
const paginationToken = await this.getPaginationToken()
return this.apiService.getSyncHttpRequest(payloads, syncToken, paginationToken, 150)
}
private async handleOfflineResponse(response: OfflineSyncResponse) {
this.logger.debug('Offline Sync Response', response)
const masterCollection = this.payloadManager.getMasterCollection()
const delta = new DeltaOfflineSaved(masterCollection, response.savedPayloads)
const emit = delta.result()
const payloadsToPersist = await this.payloadManager.emitDeltaEmit(emit)
await this.persistPayloads(payloadsToPersist)
this.opStatus.clearError()
await this.notifyEvent(SyncEvent.PaginatedSyncRequestCompleted, response)
}
private handleErrorServerResponse(response: ServerSyncResponse) {
this.logger.debug('Sync Error', response)
if (response.status === INVALID_SESSION_RESPONSE_STATUS) {
void this.notifyEvent(SyncEvent.InvalidSession)
}
if (response.status === TOO_MANY_REQUESTS_RESPONSE_STATUS) {
void this.notifyEvent(SyncEvent.TooManyRequests)
}
this.opStatus?.setError(response.error)
void this.notifyEvent(SyncEvent.SyncError, response)
}
private async handleSuccessServerResponse(operation: AccountSyncOperation, response: ServerSyncResponse) {
if (this._simulate_latency) {
await sleep(this._simulate_latency.latency)
}
this.opStatus.clearError()
this.opStatus.setDownloadStatus(response.retrievedPayloads.length)
const masterCollection = this.payloadManager.getMasterCollection()
const historyMap = this.historyService.getHistoryMapCopy()
if (response.userEvents && response.userEvents.length > 0) {
await this.notifyEventSync(
SyncEvent.ReceivedNotifications,
response.userEvents as SyncEventReceivedNotificationsData,
)
}
if (response.asymmetricMessages && response.asymmetricMessages.length > 0) {
await this.notifyEventSync(
SyncEvent.ReceivedAsymmetricMessages,
response.asymmetricMessages as SyncEventReceivedAsymmetricMessagesData,
)
}
if (response.vaults && response.vaults.length > 0) {
await this.notifyEventSync(
SyncEvent.ReceivedRemoteSharedVaults,
response.vaults as SyncEventReceivedRemoteSharedVaultsData,
)
}
if (response.vaultInvites && response.vaultInvites.length > 0) {
await this.notifyEventSync(
SyncEvent.ReceivedSharedVaultInvites,
response.vaultInvites as SyncEventReceivedSharedVaultInvitesData,
)
}
const resolver = new ServerSyncResponseResolver(
{
retrievedPayloads: await this.processServerPayloads(response.retrievedPayloads, PayloadSource.RemoteRetrieved),
savedPayloads: response.savedPayloads,
conflicts: await this.decryptServerConflicts(response.conflicts),
},
masterCollection,
operation.payloadsSavedOrSaving,
historyMap,
)
this.logger.debug(
'Online Sync Response',
'Operator ID',
operation.id,
response.rawResponse.data,
'Decrypted payloads',
resolver['payloadSet'],
)
const emits = resolver.result()
for (const emit of emits) {
const payloadsToPersist = await this.payloadManager.emitDeltaEmit(emit)
await this.persistPayloads(payloadsToPersist)
}
if (!operation.options.sharedVaultUuids) {
await Promise.all([
this.setLastSyncToken(response.lastSyncToken as string),
this.setPaginationToken(response.paginationToken as string),
])
}
await this.notifyEvent(SyncEvent.PaginatedSyncRequestCompleted, {
...response,
uploadedPayloads: operation.payloads,
options: operation.options,
})
}
private async decryptServerConflicts(conflictMap: TrustedServerConflictMap): Promise<DecryptedServerConflictMap> {
const decrypted: DecryptedServerConflictMap = {}
for (const conflictType of Object.keys(conflictMap)) {
const conflictsForType = conflictMap[conflictType as ConflictType]
if (!conflictsForType) {
continue
}
if (!decrypted[conflictType as ConflictType]) {
decrypted[conflictType as ConflictType] = []
}
const decryptedConflictsForType = decrypted[conflictType as ConflictType]
if (!decryptedConflictsForType) {
throw Error('Decrypted conflicts for type should exist')
}
for (const conflict of conflictsForType) {
const decryptedUnsavedItem = conflict.unsaved_item
? await this.processServerPayload(conflict.unsaved_item, PayloadSource.RemoteRetrieved)
: undefined
const decryptedServerItem = conflict.server_item
? await this.processServerPayload(conflict.server_item, PayloadSource.RemoteRetrieved)
: undefined
const decryptedEntry: ConflictParams<FullyFormedPayloadInterface> = <
ConflictParams<FullyFormedPayloadInterface>
>{
type: conflict.type,
unsaved_item: decryptedUnsavedItem,
server_item: decryptedServerItem,
}
decryptedConflictsForType.push(decryptedEntry)
}
}
return decrypted
}
private async processServerPayload(
item: FilteredServerItem,
source: PayloadSource,
): Promise<FullyFormedPayloadInterface> {
const result = await this.processServerPayloads([item], source)
return result[0]
}
private async processServerPayloads(
items: FilteredServerItem[],
source: PayloadSource,
): Promise<FullyFormedPayloadInterface[]> {
const payloads = items
.map((i) => {
const result = CreatePayloadFromRawServerItem(i, source)
return result.isFailed() ? undefined : result.getValue()
})
.filter(isNotUndefined)
const { encrypted, deleted } = CreateNonDecryptedPayloadSplit(payloads)
const results: FullyFormedPayloadInterface[] = [...deleted]
const { rootKeyEncryption, itemsKeyEncryption, keySystemRootKeyEncryption } =
SplitPayloadsByEncryptionType(encrypted)
const { results: rootKeyDecryptionResults, map: processedItemsKeys } = await this.decryptServerItemsKeys(
rootKeyEncryption || [],
)
extendArray(results, rootKeyDecryptionResults)
const { results: keySystemRootKeyDecryptionResults, map: processedKeySystemItemsKeys } =
await this.decryptServerKeySystemItemsKeys(keySystemRootKeyEncryption || [])
extendArray(results, keySystemRootKeyDecryptionResults)
if (itemsKeyEncryption) {
const decryptionResults = await this.decryptProcessedServerPayloads(itemsKeyEncryption, {
...processedItemsKeys,
...processedKeySystemItemsKeys,
})
extendArray(results, decryptionResults)
}
return results
}
private async decryptServerItemsKeys(payloads: EncryptedPayloadInterface[]) {
const map: Record<UuidString, DecryptedPayloadInterface<ItemsKeyContent>> = {}
if (payloads.length === 0) {
return {
results: [],
map,
}
}
const rootKeySplit: KeyedDecryptionSplit = {
usesRootKeyWithKeyLookup: {
items: payloads,
},
}
const results = await this.encryptionService.decryptSplit<ItemsKeyContent>(rootKeySplit)
results.forEach((result) => {
if (isDecryptedPayload<ItemsKeyContent>(result) && result.content_type === ContentType.TYPES.ItemsKey) {
map[result.uuid] = result
}
})
return {
results,
map,
}
}
private async decryptServerKeySystemItemsKeys(payloads: EncryptedPayloadInterface[]) {
const map: Record<UuidString, DecryptedPayloadInterface<KeySystemItemsKeyContent>> = {}
if (payloads.length === 0) {
return {
results: [],
map,
}
}
const keySystemRootKeySplit: KeyedDecryptionSplit = {
usesKeySystemRootKeyWithKeyLookup: {
items: payloads,
},
}
const results = await this.encryptionService.decryptSplit<KeySystemItemsKeyContent>(keySystemRootKeySplit)
results.forEach((result) => {
if (
isDecryptedPayload<KeySystemItemsKeyContent>(result) &&
result.content_type === ContentType.TYPES.KeySystemItemsKey
) {
map[result.uuid] = result
}
})
return {
results,
map,
}
}
private async decryptProcessedServerPayloads(
payloads: EncryptedPayloadInterface[],
map: Record<UuidString, DecryptedPayloadInterface<ItemsKeyContent | KeySystemItemsKeyContent>>,
): Promise<(EncryptedPayloadInterface | DecryptedPayloadInterface)[]> {
return Promise.all(
payloads.map(async (encrypted) => {
const previouslyProcessedItemsKey:
| DecryptedPayloadInterface<ItemsKeyContent | KeySystemItemsKeyContent>
| undefined = map[encrypted.items_key_id as string]
const itemsKey = previouslyProcessedItemsKey
? (CreateDecryptedItemFromPayload(previouslyProcessedItemsKey) as
| ItemsKeyInterface
| KeySystemItemsKeyInterface)
: undefined
const keyedSplit: KeyedDecryptionSplit = {}
if (itemsKey) {
keyedSplit.usesItemsKey = {
items: [encrypted],
key: itemsKey,
}
} else {
keyedSplit.usesItemsKeyWithKeyLookup = {
items: [encrypted],
}
}
return this.encryptionService.decryptSplitSingle(keyedSplit)
}),
)
}
private async handleSyncOperationFinish(
operation: AccountSyncOperation | OfflineSyncOperation,
options: SyncOptions,
neverSyncedDeleted: DeletedItemInterface[],
syncMode: SyncMode,
) {
this.opStatus.setDidEnd()
if (this.opStatus.hasError()) {
return { hasError: true }
}
this.opStatus.reset()
this.lastSyncDate = new Date()
this.syncFrequencyGuard.incrementCallsPerMinute()
if (operation instanceof AccountSyncOperation && operation.numberOfItemsInvolved >= this.majorChangeThreshold) {
void this.notifyEvent(SyncEvent.MajorDataChange)
}
if (neverSyncedDeleted.length > 0) {
await this.handleNeverSyncedDeleted(neverSyncedDeleted)
}
if (syncMode !== SyncMode.DownloadFirst) {
await this.notifyEvent(SyncEvent.SyncCompletedWithAllItemsUploaded, {
source: options.source,
})
}
return { hasError: false }
}
private async handleDownloadFirstCompletionAndSyncAgain(online: boolean, options: SyncOptions) {
if (online) {
this.completedOnlineDownloadFirstSync = true
}
await this.notifyEvent(SyncEvent.DownloadFirstSyncCompleted)
await this.sync({
source: SyncSource.AfterDownloadFirst,
checkIntegrity: true,
awaitAll: options.awaitAll,
})
}
private async syncAgainByHandlingRequestsWaitingInResolveQueue(options: SyncOptions) {
this.logger.debug('Syncing again from resolve queue')
const promise = this.sync({
source: SyncSource.ResolveQueue,
checkIntegrity: options.checkIntegrity,
})
if (options.awaitAll) {
await promise
}
}
/**
* As part of the just concluded sync operation, more items may have
* been dirtied (like conflicts), and the caller may want to await the
* full resolution of these items.
*/
private async syncAgainByHandlingNewDirtyItems(options: SyncOptions) {
await this.sync({
source: SyncSource.MoreDirtyItems,
checkIntegrity: options.checkIntegrity,
awaitAll: options.awaitAll,
})
}
/**
* For timing strategy SyncQueueStrategy.ResolveOnNext.
* Execute any callbacks pulled before this sync request began.
* Calling resolve on the callbacks should be the last thing we do in this function,
* to simulate calling .sync as if it went through straight to the end without having
* to be queued.
*/
private resolvePendingSyncRequestsThatMadeItInTimeOfCurrentRequest(inTimeResolveQueue: SyncPromise[]) {
for (const callback of inTimeResolveQueue) {
callback.resolve()
}
}
private async potentiallySyncAgainAfterSyncCompletion(
syncMode: SyncMode,
options: SyncOptions,
inTimeResolveQueue: SyncPromise[],
online: boolean,
) {
if (syncMode === SyncMode.DownloadFirst) {
await this.handleDownloadFirstCompletionAndSyncAgain(online, options)
this.resolvePendingSyncRequestsThatMadeItInTimeOfCurrentRequest(inTimeResolveQueue)
return true
}
const didSpawnNewRequest = this.popSpawnQueue()
const resolveQueueHasRequestsThatDidntMakeItInTime = this.resolveQueue.length > 0
if (!didSpawnNewRequest && resolveQueueHasRequestsThatDidntMakeItInTime) {
await this.syncAgainByHandlingRequestsWaitingInResolveQueue(options)
this.resolvePendingSyncRequestsThatMadeItInTimeOfCurrentRequest(inTimeResolveQueue)
return true
}
const newItemsNeedingSync = this.itemsNeedingSync()
if (newItemsNeedingSync.length > 0) {
await this.syncAgainByHandlingNewDirtyItems(options)
this.resolvePendingSyncRequestsThatMadeItInTimeOfCurrentRequest(inTimeResolveQueue)
return true
}
return false
}
/**
* Items that have never been synced and marked as deleted should be cleared
* as dirty, mapped, then removed from storage.
*/
private async handleNeverSyncedDeleted(items: DeletedItemInterface[]) {
const payloads = items.map((item) => {
return item.payloadRepresentation({
dirty: false,
})
})
await this.payloadManager.emitPayloads(payloads, PayloadEmitSource.LocalChanged)
await this.persistPayloads(payloads)
}
public async persistPayloads(
payloads: FullyFormedPayloadInterface[],
options: { throwError: boolean } = { throwError: true },
) {
if (payloads.length === 0 || this.dealloced) {
return
}
return this.storageService.savePayloads(payloads).catch((error) => {
if (options.throwError) {
void this.notifyEvent(SyncEvent.DatabaseWriteError, error)
SNLog.error(error)
}
})
}
setInSync(isInSync: boolean): void {
if (isInSync === !this.outOfSync) {
return
}
if (isInSync) {
this.outOfSync = false
void this.notifyEvent(SyncEvent.ExitOutOfSync)
} else {
this.outOfSync = true
void this.notifyEvent(SyncEvent.EnterOutOfSync)
}
}
async handleEvent(event: InternalEventInterface): Promise<void> {
switch (event.type) {
case IntegrityEvent.IntegrityCheckCompleted:
await this.handleIntegrityCheckEventResponse(event.payload as IntegrityEventPayload)
break
case WebSocketsServiceEvent.ItemsChangedOnServer:
this.wasNotifiedOfItemsChangeOnServer = true
break
default:
break
}
}
private async handleIntegrityCheckEventResponse(eventPayload: IntegrityEventPayload) {
const rawPayloads = eventPayload.rawPayloads
if (rawPayloads.length === 0) {
this.setInSync(true)
return
}
const rawPayloadsFilteringResult = FilterDisallowedRemotePayloadsAndMap(rawPayloads)
const receivedPayloads = rawPayloadsFilteringResult.filtered
.map((rawPayload) => {
const result = CreatePayloadFromRawServerItem(rawPayload, PayloadSource.RemoteRetrieved)
if (result.isFailed()) {
return undefined
}
return result.getValue()
})
.filter(isNotUndefined)
const payloadSplit = CreateNonDecryptedPayloadSplit(receivedPayloads)
const encryptionSplit = SplitPayloadsByEncryptionType(payloadSplit.encrypted)
const keyedSplit = CreateDecryptionSplitWithKeyLookup(encryptionSplit)
const decryptionResults = await this.encryptionService.decryptSplit(keyedSplit)
this.setInSync(false)
await this.emitOutOfSyncRemotePayloads([...decryptionResults, ...payloadSplit.deleted])
const shouldCheckIntegrityAgainAfterSync = eventPayload.source !== SyncSource.ResolveOutOfSync
await this.sync({
checkIntegrity: shouldCheckIntegrityAgainAfterSync,
source: SyncSource.ResolveOutOfSync,
})
}
private async emitOutOfSyncRemotePayloads(payloads: FullyFormedPayloadInterface[]) {
const delta = new DeltaOutOfSync(
this.payloadManager.getMasterCollection(),
ImmutablePayloadCollection.WithPayloads(payloads),
this.historyService.getHistoryMapCopy(),
)
const emit = delta.result()
await this.payloadManager.emitDeltaEmit(emit)
await this.persistPayloads(emit.emits)
}
async syncSharedVaultsFromScratch(sharedVaultUuids: string[]): Promise<void> {
await this.sync({
sharedVaultUuids: sharedVaultUuids,
syncSharedVaultsFromScratch: true,
queueStrategy: SyncQueueStrategy.ForceSpawnNew,
awaitAll: true,
})
}
/** @e2e_testing */
// eslint-disable-next-line camelcase
ut_setDatabaseLoaded(loaded: boolean): void {
this.databaseLoaded = loaded
}
/** @e2e_testing */
// eslint-disable-next-line camelcase
ut_clearLastSyncDate(): void {
this.lastSyncDate = undefined
}
/** @e2e_testing */
// eslint-disable-next-line camelcase
ut_beginLatencySimulator(latency: number): void {
this._simulate_latency = {
latency: latency || 1000,
enabled: true,
}
}
/** @e2e_testing */
// eslint-disable-next-line camelcase
ut_endLatencySimulator(): void {
this._simulate_latency = undefined
}
}
``` | /content/code_sandbox/packages/snjs/lib/Services/Sync/SyncService.ts | xml | 2016-12-05T23:31:33 | 2024-08-16T06:51:19 | app | standardnotes/app | 5,180 | 11,007 |
```xml
<?xml version="1.0" encoding="utf-8"?><HelpTOCNode Title="LoadMethod Method " Url="html/6c12c148-e999-2f2e-e85b-1e46a939019d.htm"><HelpTOCNode Title="LoadMethod Method (String)" Url="html/e35b2c14-feb8-2a05-b4ac-5421fd0d57f0.htm" /><HelpTOCNode Title="LoadMethod(T) Method (String)" Url="html/f4567bee-c0ab-2e65-9e85-bcf87289a445.htm" /></HelpTOCNode>
``` | /content/code_sandbox/docs/help/toc/6c12c148-e999-2f2e-e85b-1e46a939019d.xml | xml | 2016-01-16T05:50:23 | 2024-08-14T17:35:38 | cs-script | oleg-shilo/cs-script | 1,583 | 144 |
```xml
import { getPackageJSON } from '../../src/index';
import fs from 'fs';
import path from 'path';
test('getPackageJSON caches read operations', () => {
const expected = JSON.parse(
fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf-8')
);
expect(expected.name).toBe('@vercel-internals/get-package-json');
const readFileSyncSpy = jest.spyOn(fs, 'readFileSync');
const actual = getPackageJSON();
expect(actual).toStrictEqual(expected);
expect(readFileSyncSpy).toBeCalledTimes(1);
const cacheHit = getPackageJSON();
expect(cacheHit).toStrictEqual(expected);
expect(readFileSyncSpy).toBeCalledTimes(1);
});
``` | /content/code_sandbox/internals/get-package-json/tests/unit/cache.test.ts | xml | 2016-09-09T01:12:08 | 2024-08-16T17:39:45 | vercel | vercel/vercel | 12,545 | 151 |
```xml
// See LICENSE in the project root for license information.
import * as RawScriptLoader from './RawScriptLoader';
export = RawScriptLoader;
``` | /content/code_sandbox/webpack/loader-raw-script/src/index.ts | xml | 2016-09-30T00:28:20 | 2024-08-16T18:54:35 | rushstack | microsoft/rushstack | 5,790 | 30 |
```xml
/*
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
import resolve = require( './index' );
// TESTS //
// The function returns a number or null...
{
resolve( 0 ); // $ExpectType number | null
resolve( 'float64' ); // $ExpectType number | null
}
``` | /content/code_sandbox/lib/node_modules/@stdlib/ndarray/base/output-policy-resolve-enum/docs/types/test.ts | xml | 2016-03-24T04:19:52 | 2024-08-16T09:03:19 | stdlib | stdlib-js/stdlib | 4,266 | 102 |
```xml
import { IModel } from 'vs/editor/common/editorCommon';
import JSONContributionRegistry = require('vs/platform/jsonschemas/common/jsonContributionRegistry');
``` | /content/code_sandbox/tests/format/typescript/import-require/import_require.ts | xml | 2016-11-29T17:13:37 | 2024-08-16T17:29:57 | prettier | prettier/prettier | 48,913 | 32 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
path_to_url
Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-->
<LWM2M xmlns:xsi="path_to_url"
xsi:noNamespaceSchemaLocation="path_to_url">
<Object ObjectType="MODefinition">
<Name>LwM2M Monitoring</Name>
<Description1>
<![CDATA[]]></Description1>
<ObjectID>3</ObjectID>
<ObjectURN>urn:oma:lwm2m:oma:3</ObjectURN>
<LWM2MVersion>1.1</LWM2MVersion>
<ObjectVersion>1.0</ObjectVersion>
<MultipleInstances>Single</MultipleInstances>
<Mandatory>Mandatory</Mandatory>
<Resources>
<Item ID="0">
<Name>Test data</Name>
<Operations>R</Operations>
<MultipleInstances>Single</MultipleInstances>
<Mandatory>Optional</Mandatory>
<Type>String</Type>
<RangeEnumeration></RangeEnumeration>
<Units></Units>
<Description><![CDATA[Test data]]></Description>
</Item>
</Resources>
<Description2></Description2>
</Object>
</LWM2M>
``` | /content/code_sandbox/monitoring/src/main/resources/lwm2m/models/test-model.xml | xml | 2016-12-01T09:33:30 | 2024-08-16T19:58:25 | thingsboard | thingsboard/thingsboard | 16,820 | 294 |
```xml
<project xmlns="path_to_url" xmlns:xsi="path_to_url"
xsi:schemaLocation="path_to_url path_to_url">
<modelVersion>4.0.0</modelVersion>
<name>Flowable 5 - Spring</name>
<artifactId>flowable5-spring</artifactId>
<parent>
<groupId>org.flowable</groupId>
<artifactId>flowable-root</artifactId>
<relativePath>../..</relativePath>
<version>7.1.0-SNAPSHOT</version>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<flowable.artifact>
org.activiti.spring
</flowable.artifact>
<flowable.osgi.import.additional>
org.springframework.test.context*;resolution:=optional,
</flowable.osgi.import.additional>
</properties>
<build>
<plugins>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<configuration>
<archive>
<manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
</archive>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
<executions>
<execution>
<phase>generate-sources</phase>
<goals>
<goal>cleanVersions</goal>
</goals>
</execution>
<execution>
<id>bundle-manifest</id>
<phase>process-classes</phase>
<goals>
<goal>manifest</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
<pluginManagement>
<plugins>
<!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
<plugin>
<groupId>org.eclipse.m2e</groupId>
<artifactId>lifecycle-mapping</artifactId>
<version>1.0.0</version>
<configuration>
<lifecycleMappingMetadata>
<pluginExecutions>
<pluginExecution>
<pluginExecutionFilter>
<groupId>org.apache.felix</groupId>
<artifactId>
maven-bundle-plugin
</artifactId>
<versionRange>
[2.1.0,)
</versionRange>
<goals>
<goal>cleanVersions</goal>
<goal>manifest</goal>
</goals>
</pluginExecutionFilter>
<action>
<ignore></ignore>
</action>
</pluginExecution>
</pluginExecutions>
</lifecycleMappingMetadata>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
<dependencies>
<dependency>
<groupId>org.flowable</groupId>
<artifactId>flowable5-engine</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>jakarta.persistence</groupId>
<artifactId>jakarta.persistence-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.groovy</groupId>
<artifactId>groovy-jsr223</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
</dependency>
</dependencies>
</project>
``` | /content/code_sandbox/modules/flowable5-spring/pom.xml | xml | 2016-10-13T07:21:43 | 2024-08-16T15:23:14 | flowable-engine | flowable/flowable-engine | 7,715 | 963 |
```xml
let x = [0];
let y = x.length;
y = [""].length;
``` | /content/code_sandbox/tests/decompile-test/cases/array_length.ts | xml | 2016-01-24T19:35:52 | 2024-08-16T16:39:39 | pxt | microsoft/pxt | 2,069 | 20 |
```xml
<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="path_to_url"
xmlns:x="path_to_url"
x:Class="Xamarin.Forms.Controls.GalleryPages.CollectionViewGalleries.SelectionGalleries.PreselectedItemGallery">
<ContentPage.Content>
<Grid x:Name="Grid">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"></RowDefinition>
<RowDefinition Height="Auto"></RowDefinition>
<RowDefinition Height="Auto"></RowDefinition>
<RowDefinition Height="*"></RowDefinition>
</Grid.RowDefinitions>
<Label x:Name="SelectedItemsEvent" Grid.Row="1"/>
<Label x:Name="SelectedItemsCommand" Grid.Row="2"/>
<CollectionView x:Name="CollectionView" Grid.Row="3" Header="This is the header" />
</Grid>
</ContentPage.Content>
</ContentPage>
``` | /content/code_sandbox/Xamarin.Forms.Controls/GalleryPages/CollectionViewGalleries/SelectionGalleries/PreselectedItemGallery.xaml | xml | 2016-03-18T15:52:03 | 2024-08-16T16:25:43 | Xamarin.Forms | xamarin/Xamarin.Forms | 5,637 | 205 |
```xml
<vector xmlns:android="path_to_url" android:width="16dp"
android:height="16dp" android:viewportWidth="1024" android:viewportHeight="1024">
<path
android:pathData="M532.53,904.82L139.51,511.8 532.53,118.78c12.26,-12.26 12.43,-32.89 -0.19,-45.51 -12.71,-12.71 -33,-12.7 -45.51,-0.19L75.17,484.74c-7.12,7.12 -10.16,17.07 -8.99,26.62 -1.5,9.76 1.51,20.01 8.99,27.49l411.66,411.66c12.26,12.26 32.89,12.43 45.51,-0.19 12.71,-12.71 12.7,-33 0.19,-45.51z"
android:fillColor="#1A1A1E" />
</vector>
``` | /content/code_sandbox/Prj-Android/app/src/main/res/drawable/img_back.xml | xml | 2016-08-26T06:35:48 | 2024-08-15T03:26:11 | anyRTC-RTMP-OpenSource | anyrtcIO-Community/anyRTC-RTMP-OpenSource | 4,672 | 250 |
```xml
import Ionicons from '@expo/vector-icons/Ionicons';
import { StyleSheet, TouchableOpacity, TouchableOpacityProps } from 'react-native';
type Props = TouchableOpacityProps & {
color?: string;
name: string;
size?: number;
};
const HeaderIconButton = ({ color = 'blue', disabled, name, onPress, size = 24 }: Props) => (
<TouchableOpacity disabled={disabled} style={styles.iconButton} onPress={onPress}>
<Ionicons size={size} color={color} name={name as any} />
</TouchableOpacity>
);
const styles = StyleSheet.create({
iconButton: {
paddingHorizontal: 12,
},
});
export default HeaderIconButton;
``` | /content/code_sandbox/apps/native-component-list/src/components/HeaderIconButton.tsx | xml | 2016-08-15T17:14:25 | 2024-08-16T19:54:44 | expo | expo/expo | 32,004 | 142 |
```xml
/*
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
export * from "./_"
export * from "./segment"
export * from "./transform"
``` | /content/code_sandbox/src/templates/assets/javascripts/integrations/search/query/index.ts | xml | 2016-01-28T22:09:23 | 2024-08-16T17:55:06 | mkdocs-material | squidfunk/mkdocs-material | 19,629 | 243 |
```xml
import {DMMF} from "@prisma/generator-helper";
import {SourceFile} from "ts-morph";
export interface TransformContext {
dmmf: DMMF.Document;
modelsMap: Map<string, DMMF.Model>;
}
``` | /content/code_sandbox/packages/orm/prisma/src/generator/domain/TransformContext.ts | xml | 2016-02-21T18:38:47 | 2024-08-14T21:19:48 | tsed | tsedio/tsed | 2,817 | 54 |
```xml
import * as fs from "fs";
import * as path from "path";
import { app, ipcMain } from "electron";
import { firstValueFrom } from "rxjs";
import { Main } from "../main";
import { DesktopSettingsService } from "../platform/services/desktop-settings.service";
import { MenuUpdateRequest } from "./menu/menu.updater";
const SyncInterval = 5 * 60 * 1000; // 5 minutes
export class MessagingMain {
private syncTimeout: NodeJS.Timeout;
constructor(
private main: Main,
private desktopSettingsService: DesktopSettingsService,
) {}
async init() {
this.scheduleNextSync();
if (process.platform === "linux") {
await this.desktopSettingsService.setOpenAtLogin(fs.existsSync(this.linuxStartupFile()));
} else {
const loginSettings = app.getLoginItemSettings();
await this.desktopSettingsService.setOpenAtLogin(loginSettings.openAtLogin);
}
ipcMain.on(
"messagingService",
async (event: any, message: any) => await this.onMessage(message),
);
}
async onMessage(message: any) {
switch (message.command) {
case "scheduleNextSync":
this.scheduleNextSync();
break;
case "updateAppMenu":
// FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
// eslint-disable-next-line @typescript-eslint/no-floating-promises
this.main.menuMain.updateApplicationMenuState(message.updateRequest);
this.updateTrayMenu(message.updateRequest);
break;
case "minimizeOnCopy":
{
const shouldMinimizeOnCopy = await firstValueFrom(
this.desktopSettingsService.minimizeOnCopy$,
);
if (shouldMinimizeOnCopy && this.main.windowMain.win !== null) {
this.main.windowMain.win.minimize();
}
}
break;
case "showTray":
this.main.trayMain.showTray();
break;
case "removeTray":
this.main.trayMain.removeTray();
break;
case "hideToTray":
// FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling.
// eslint-disable-next-line @typescript-eslint/no-floating-promises
this.main.trayMain.hideToTray();
break;
case "addOpenAtLogin":
this.addOpenAtLogin();
break;
case "removeOpenAtLogin":
this.removeOpenAtLogin();
break;
case "setFocus":
this.setFocus();
break;
case "getWindowIsFocused":
this.windowIsFocused();
break;
default:
break;
}
}
private scheduleNextSync() {
if (this.syncTimeout) {
global.clearTimeout(this.syncTimeout);
}
this.syncTimeout = global.setTimeout(() => {
if (this.main.windowMain.win == null) {
return;
}
this.main.windowMain.win.webContents.send("messagingService", {
command: "checkSyncVault",
});
}, SyncInterval);
}
private updateTrayMenu(updateRequest: MenuUpdateRequest) {
if (
this.main.trayMain == null ||
this.main.trayMain.contextMenu == null ||
updateRequest?.activeUserId == null
) {
return;
}
const lockVaultTrayMenuItem = this.main.trayMain.contextMenu.getMenuItemById("lockVault");
const activeAccount = updateRequest.accounts[updateRequest.activeUserId];
if (lockVaultTrayMenuItem != null && activeAccount != null) {
lockVaultTrayMenuItem.enabled = activeAccount.isAuthenticated && !activeAccount.isLocked;
}
this.main.trayMain.updateContextMenu();
}
private addOpenAtLogin() {
if (process.platform === "linux") {
const data = `[Desktop Entry]
Type=Application
Version=${app.getVersion()}
Name=Bitwarden
Comment=Bitwarden startup script
Exec=${app.getPath("exe")}
StartupNotify=false
Terminal=false`;
const dir = path.dirname(this.linuxStartupFile());
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir);
}
fs.writeFileSync(this.linuxStartupFile(), data);
} else {
app.setLoginItemSettings({ openAtLogin: true });
}
}
private removeOpenAtLogin() {
if (process.platform === "linux") {
if (fs.existsSync(this.linuxStartupFile())) {
fs.unlinkSync(this.linuxStartupFile());
}
} else {
app.setLoginItemSettings({ openAtLogin: false });
}
}
private linuxStartupFile(): string {
return path.join(app.getPath("home"), ".config", "autostart", "bitwarden.desktop");
}
private setFocus() {
this.main.trayMain.restoreFromTray();
this.main.windowMain.win.focusOnWebView();
}
private windowIsFocused() {
const windowIsFocused = this.main.windowMain.win.isFocused();
this.main.windowMain.win.webContents.send("messagingService", {
command: "windowIsFocused",
windowIsFocused: windowIsFocused,
});
}
}
``` | /content/code_sandbox/apps/desktop/src/main/messaging.main.ts | xml | 2016-03-09T23:14:01 | 2024-08-16T15:07:51 | clients | bitwarden/clients | 8,877 | 1,116 |
```xml
//
//
// path_to_url
//
// Unless required by applicable law or agreed to in writing, software
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#import "RunModelViewController.h"
#include <fstream>
#include <pthread.h>
#include <unistd.h>
#include <queue>
#include <sstream>
#include <string>
#include "tensorflow/core/framework/op_kernel.h"
#include "tensorflow/core/public/session.h"
#include "ios_image_load.h"
NSString* RunInferenceOnImage();
namespace {
class IfstreamInputStream : public ::google::protobuf::io::CopyingInputStream {
public:
explicit IfstreamInputStream(const std::string& file_name)
: ifs_(file_name.c_str(), std::ios::in | std::ios::binary) {}
~IfstreamInputStream() { ifs_.close(); }
int Read(void* buffer, int size) {
if (!ifs_) {
return -1;
}
ifs_.read(static_cast<char*>(buffer), size);
return (int)ifs_.gcount();
}
private:
std::ifstream ifs_;
};
} // namespace
@interface RunModelViewController ()
@end
@implementation RunModelViewController {
}
- (IBAction)getUrl:(id)sender {
NSString* inference_result = RunInferenceOnImage();
self.urlContentTextView.text = inference_result;
}
@end
// Returns the top N confidence values over threshold in the provided vector,
// sorted by confidence in descending order.
static void GetTopN(
const Eigen::TensorMap<Eigen::Tensor<float, 1, Eigen::RowMajor>,
Eigen::Aligned>& prediction,
const int num_results, const float threshold,
std::vector<std::pair<float, int> >* top_results) {
// Will contain top N results in ascending order.
std::priority_queue<std::pair<float, int>,
std::vector<std::pair<float, int> >,
std::greater<std::pair<float, int> > > top_result_pq;
const long count = prediction.size();
for (int i = 0; i < count; ++i) {
const float value = prediction(i);
// Only add it if it beats the threshold and has a chance at being in
// the top N.
if (value < threshold) {
continue;
}
top_result_pq.push(std::pair<float, int>(value, i));
// If at capacity, kick the smallest value out.
if (top_result_pq.size() > num_results) {
top_result_pq.pop();
}
}
// Copy to output vector and reverse into descending order.
while (!top_result_pq.empty()) {
top_results->push_back(top_result_pq.top());
top_result_pq.pop();
}
std::reverse(top_results->begin(), top_results->end());
}
bool PortableReadFileToProto(const std::string& file_name,
::google::protobuf::MessageLite* proto) {
::google::protobuf::io::CopyingInputStreamAdaptor stream(
new IfstreamInputStream(file_name));
stream.SetOwnsCopyingStream(true);
// TODO(jiayq): the following coded stream is for debugging purposes to allow
// one to parse arbitrarily large messages for MessageLite. One most likely
// doesn't want to put protobufs larger than 64MB on Android, so we should
// eventually remove this and quit loud when a large protobuf is passed in.
::google::protobuf::io::CodedInputStream coded_stream(&stream);
// Total bytes hard limit / warning limit are set to 1GB and 512MB
// respectively.
coded_stream.SetTotalBytesLimit(1024LL << 20, 512LL << 20);
return proto->ParseFromCodedStream(&coded_stream);
}
NSString* FilePathForResourceName(NSString* name, NSString* extension) {
NSString* file_path = [[NSBundle mainBundle] pathForResource:name ofType:extension];
if (file_path == NULL) {
LOG(FATAL) << "Couldn't find '" << [name UTF8String] << "."
<< [extension UTF8String] << "' in bundle.";
}
return file_path;
}
NSString* RunInferenceOnImage() {
tensorflow::SessionOptions options;
tensorflow::Session* session_pointer = nullptr;
tensorflow::Status session_status = tensorflow::NewSession(options, &session_pointer);
if (!session_status.ok()) {
std::string status_string = session_status.ToString();
return [NSString stringWithFormat: @"Session create failed - %s",
status_string.c_str()];
}
std::unique_ptr<tensorflow::Session> session(session_pointer);
LOG(INFO) << "Session created.";
tensorflow::GraphDef tensorflow_graph;
LOG(INFO) << "Graph created.";
// 1. Load the model
//NSString* network_path = FilePathForResourceName(@"tensorflow_inception_graph", @"pb");
NSString* network_path = FilePathForResourceName(@"tensorflow_template_application_model", @"pb");
PortableReadFileToProto([network_path UTF8String], &tensorflow_graph);
LOG(INFO) << "Creating session.";
tensorflow::Status s = session->Create(tensorflow_graph);
if (!s.ok()) {
LOG(ERROR) << "Could not create TensorFlow Graph: " << s;
return @"";
}
NSString* result = [network_path stringByAppendingString: @" - loaded!"];
LOG(INFO) << result;
// 2. Construct input tensor
tensorflow::Tensor keys_tensor(tensorflow::DT_INT32,tensorflow::TensorShape({1, 1}));
auto keys_data = keys_tensor.tensor<int, 2>();
keys_data(0, 0) = 1;
tensorflow::Tensor features_tensor(tensorflow::DT_FLOAT,tensorflow::TensorShape({1, 9}));
auto features_data = features_tensor.tensor<float, 2>();
for (int i = 0; i < 9; ++i) {
features_data(0, i) = 1.0;
}
// 3. Session run with input
std::string keys_input = "keys";
std::string features_input = "features";
std::string output_keys = "output_keys";
std::string output_prediction = "output_prediction";
std::string output_softmax = "output_softmax";
std::vector<tensorflow::Tensor> output_tensors;
// TODO: Support multiple inputs
std::vector<tensorflow::Tensor> input_tensor;
std::vector<std::pair<std::string, tensorflow::Tensor>> string_tensor_list;
// string_tensor_list.push({keys_input, keys_tensor});
// string_tensor_list.push({features_input, features_data});
tensorflow::Status run_status = session->Run({{keys_input, keys_tensor}}, {output_keys}, {}, &output_tensors);
// tensorflow::Status run_status = session->Run({{features_input, features_tensor}}, {output_softmax}, {}, &output_tensors);
if (!run_status.ok()) {
LOG(ERROR) << "Running model failed: " << run_status;
tensorflow::LogAllRegisteredKernels();
result = @"Error running model";
return result;
}
// 4. Parse outputs
tensorflow::string status_string = run_status.ToString();
result = [NSString stringWithFormat: @"%@ - %s", result, status_string.c_str()];
tensorflow::Tensor* output2 = &output_tensors[0];
auto prediction2 = output2->flat<int>();
const long count = prediction2.size();
const int value2 = prediction2(0);
LOG(INFO) << value2;
result = [NSString stringWithFormat: @"%@: %i", @"Inference result", value2];
return result;
/*
// Read the label list
NSString* labels_path = FilePathForResourceName(@"imagenet_comp_graph_label_strings", @"txt");
std::vector<std::string> label_strings;
std::ifstream t;
t.open([labels_path UTF8String]);
std::string line;
while(t){
std::getline(t, line);
label_strings.push_back(line);
}
t.close();
// Read the Grace Hopper image.
NSString* image_path = FilePathForResourceName(@"grace_hopper", @"jpg");
int image_width;
int image_height;
int image_channels;
std::vector<tensorflow::uint8> image_data = LoadImageFromFile(
[image_path UTF8String], &image_width, &image_height, &image_channels);
const int wanted_width = 224;
const int wanted_height = 224;
const int wanted_channels = 3;
const float input_mean = 117.0f;
const float input_std = 1.0f;
assert(image_channels >= wanted_channels);
tensorflow::Tensor image_tensor(
tensorflow::DT_FLOAT,
tensorflow::TensorShape({
1, wanted_height, wanted_width, wanted_channels}));
auto image_tensor_mapped = image_tensor.tensor<float, 4>();
tensorflow::uint8* in = image_data.data();
// tensorflow::uint8* in_end = (in + (image_height * image_width * image_channels));
float* out = image_tensor_mapped.data();
for (int y = 0; y < wanted_height; ++y) {
const int in_y = (y * image_height) / wanted_height;
tensorflow::uint8* in_row = in + (in_y * image_width * image_channels);
float* out_row = out + (y * wanted_width * wanted_channels);
for (int x = 0; x < wanted_width; ++x) {
const int in_x = (x * image_width) / wanted_width;
tensorflow::uint8* in_pixel = in_row + (in_x * image_channels);
float* out_pixel = out_row + (x * wanted_channels);
for (int c = 0; c < wanted_channels; ++c) {
out_pixel[c] = (in_pixel[c] - input_mean) / input_std;
}
}
}
NSString* result = [network_path stringByAppendingString: @" - loaded!"];
result = [NSString stringWithFormat: @"%@ - %lu, %s - %dx%d", result,
label_strings.size(), label_strings[0].c_str(), image_width, image_height];
std::string input_layer = "input";
std::string output_layer = "output";
std::vector<tensorflow::Tensor> outputs;
tensorflow::Status run_status = session->Run({{input_layer, image_tensor}},
{output_layer}, {}, &outputs);
if (!run_status.ok()) {
LOG(ERROR) << "Running model failed: " << run_status;
tensorflow::LogAllRegisteredKernels();
result = @"Error running model";
return result;
}
tensorflow::string status_string = run_status.ToString();
result = [NSString stringWithFormat: @"%@ - %s", result,
status_string.c_str()];
tensorflow::Tensor* output = &outputs[0];
const int kNumResults = 5;
const float kThreshold = 0.1f;
std::vector<std::pair<float, int> > top_results;
GetTopN(output->flat<float>(), kNumResults, kThreshold, &top_results);
std::stringstream ss;
ss.precision(3);
for (const auto& result : top_results) {
const float confidence = result.first;
const int index = result.second;
ss << index << " " << confidence << " ";
// Write out the result as a string
if (index < label_strings.size()) {
// just for safety: theoretically, the output is under 1000 unless there
// is some numerical issues leading to a wrong prediction.
ss << label_strings[index];
} else {
ss << "Prediction: " << index;
}
ss << "\n";
}
LOG(INFO) << "Predictions: " << ss.str();
tensorflow::string predictions = ss.str();
result = [NSString stringWithFormat: @"%@ - %s", result,
predictions.c_str()];
return result;
*/
}
``` | /content/code_sandbox/ios_client/RunModelViewController.mm | xml | 2016-07-18T10:54:20 | 2024-08-05T07:01:20 | tensorflow_template_application | tobegit3hub/tensorflow_template_application | 1,869 | 2,593 |
```xml
#!/usr/bin/env node
import { Command } from './cli';
export declare const configureCodeSigning: Command;
``` | /content/code_sandbox/packages/expo-updates/cli/build/configureCodeSigning.d.ts | xml | 2016-08-15T17:14:25 | 2024-08-16T19:54:44 | expo | expo/expo | 32,004 | 24 |
```xml
import http from 'http';
import Stream from 'stream';
import { Socket } from 'net';
import { stub } from 'sinon';
import { test } from 'tap';
import {
serve,
run,
send,
sendError,
buffer,
json,
HttpError,
} from 'micro/src/lib/index';
import fetch from 'node-fetch';
import type { AddressInfo } from 'net';
import type { RequestHandler, BufferInfo } from 'micro/src/lib/index';
function startServer(handler: RequestHandler): Promise<[string, () => void]> {
return new Promise((resolve, reject) => {
const server = http.createServer(serve(handler));
server.on('error', reject);
server.listen(() => {
const { port } = server.address() as AddressInfo;
resolve([
`path_to_url{port}`,
() => {
server.close();
},
]);
});
});
}
function sleep(ms: number) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
}
void test('send(200, <String>)', async (t) => {
const fn: RequestHandler = (req, res) => {
send(res, 200, 'woot');
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url);
const body = await res.text();
t.same(body, 'woot');
shutdown();
});
void test('send(200, <Object>)', async (t) => {
const fn: RequestHandler = (req, res) => {
send(res, 200, {
a: 'b',
});
};
const [url, shutdown] = await startServer(fn);
const res: unknown = await fetch(url).then((r) => r.json());
t.same(res, {
a: 'b',
});
shutdown();
});
void test('send(200, <Number>)', async (t) => {
const fn: RequestHandler = (req, res) => {
// Chosen by fair dice roll. guaranteed to be random.
send(res, 200, 4);
};
const [url, shutdown] = await startServer(fn);
const res: unknown = await fetch(url).then((r) => r.json());
t.same(res, 4);
shutdown();
});
void test('send(200, <Buffer>)', async (t) => {
const fn: RequestHandler = (req, res) => {
send(res, 200, Buffer.from('muscle'));
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url).then((r) => r.text());
t.same(res, 'muscle');
shutdown();
});
void test('send(200, <Stream>)', async (t) => {
const fn: RequestHandler = (req, res) => {
send(res, 200, 'waterfall');
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url).then((r) => r.text());
t.same(res, 'waterfall');
shutdown();
});
void test('send(<Number>)', async (t) => {
const fn: RequestHandler = (req, res) => {
send(res, 404);
};
const [url, shutdown] = await startServer(fn);
const { status } = await fetch(url);
t.same(status, 404);
shutdown();
});
void test('return <String>', async (t) => {
const fn: RequestHandler = () => 'woot';
const [url, shutdown] = await startServer(fn);
const res = await fetch(url).then((r) => r.text());
t.same(res, 'woot');
shutdown();
});
void test('return <Promise>', async (t) => {
const fn: RequestHandler = async () => {
await sleep(100);
return 'I Promise';
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url).then((r) => r.text());
t.same(res, 'I Promise');
shutdown();
});
void test('sync return <String>', async (t) => {
const fn: RequestHandler = () => 'argon';
const [url, shutdown] = await startServer(fn);
const res = await fetch(url).then((r) => r.text());
t.same(res, 'argon');
shutdown();
});
void test('return empty string', async (t) => {
const fn: RequestHandler = () => '';
const [url, shutdown] = await startServer(fn);
const res = await fetch(url).then((r) => r.text());
t.same(res, '');
shutdown();
});
void test('return <Object>', async (t) => {
const fn: RequestHandler = () => ({
a: 'b',
});
const [url, shutdown] = await startServer(fn);
const res: unknown = await fetch(url).then((r) => r.json());
t.same(res, {
a: 'b',
});
shutdown();
});
void test('return <Number>', async (t) => {
const fn: RequestHandler = () =>
// Chosen by fair dice roll. guaranteed to be random.
4;
const [url, shutdown] = await startServer(fn);
const res: unknown = await fetch(url).then((r) => r.json());
t.same(res, 4);
shutdown();
});
void test('return <Buffer>', async (t) => {
const fn: RequestHandler = () => Buffer.from('Hammer');
const [url, shutdown] = await startServer(fn);
const res = await fetch(url).then((r) => r.text());
t.same(res, 'Hammer');
shutdown();
});
void test('return <Stream>', async (t) => {
const fn: RequestHandler = () => {
const stream = new Stream.Transform();
stream.push('River');
stream.end();
return stream;
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url).then((r) => r.text());
t.same(res, 'River');
shutdown();
});
void test('return <null>', async (t) => {
const fn: RequestHandler = () => null;
const [url, shutdown] = await startServer(fn);
const res = await fetch(url);
const body = await res.text();
t.equal(res.status, 204);
t.equal(body, '');
shutdown();
});
void test('return <null> calls res.end once', async (t) => {
const fn: RequestHandler = () => null;
const req = new http.IncomingMessage(new Socket());
const res = new http.ServerResponse(req);
const fake = stub(res, 'end');
await run(req, res, fn);
t.equal(fake.calledOnce, true);
});
void test('throw with code', async (t) => {
const fn: RequestHandler = async () => {
await sleep(100);
const err = new HttpError('Error from test (expected)');
err.statusCode = 402;
throw err;
};
const [url, shutdown] = await startServer(fn);
const { status } = await fetch(url);
t.same(status, 402);
shutdown();
});
void test('throw (500)', async (t) => {
const fn: RequestHandler = () => {
throw new Error('500 from test (expected)');
};
const [url, shutdown] = await startServer(fn);
const { status } = await fetch(url);
t.same(status, 500);
shutdown();
});
void test('throw (500) sync', async (t) => {
const fn: RequestHandler = () => {
throw new Error('500 from test (expected)');
};
const [url, shutdown] = await startServer(fn);
const { status } = await fetch(url);
t.same(status, 500);
shutdown();
});
void test('send(200, <Stream>) with error on same tick', async (t) => {
const fn: RequestHandler = (req, res) => {
const stream = new Stream.Transform();
stream.push('error-stream');
stream.emit('error', new Error('500 from test (expected)'));
stream.end();
send(res, 200, stream);
};
const [url, shutdown] = await startServer(fn);
const { status } = await fetch(url);
t.same(status, 500);
shutdown();
});
void test('custom error', async (t) => {
const fn: RequestHandler = async () => {
await sleep(50);
throw new Error('500 from test (expected)');
};
const handleErrors =
(ofn: RequestHandler) =>
async (req: http.IncomingMessage, res: http.ServerResponse) => {
try {
return await ofn(req, res);
} catch (err) {
send(res, 200, 'My custom error!');
}
};
const [url, shutdown] = await startServer(handleErrors(fn));
const res = await fetch(url).then((r) => r.text());
t.same(res, 'My custom error!');
shutdown();
});
void test('custom async error', async (t) => {
const fn: RequestHandler = async () => {
await sleep(50);
throw new Error('500 from test (expected)');
};
const handleErrors =
(ofn: RequestHandler) =>
async (req: http.IncomingMessage, res: http.ServerResponse) => {
try {
return await ofn(req, res);
} catch (err) {
send(res, 200, 'My custom error!');
}
};
const [url, shutdown] = await startServer(handleErrors(fn));
const res = await fetch(url).then((r) => r.text());
t.same(res, 'My custom error!');
shutdown();
});
void test('json parse error', async (t) => {
const fn: RequestHandler = async (req, res) => {
const body = await json(req);
send(res, 200, (body as { woot: string }).woot);
};
const [url, shutdown] = await startServer(fn);
const { status } = await fetch(url, {
method: 'POST',
body: '{ "bad json" }',
headers: {
'Content-Type': 'application/json',
},
});
t.same(status, 400);
shutdown();
});
void test('json', async (t) => {
interface Payload {
some: { cool: string };
}
const fn: RequestHandler = async (req, res) => {
const body = await json(req);
send(res, 200, {
response: (body as Payload).some.cool,
});
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url, {
method: 'POST',
body: JSON.stringify({
some: {
cool: 'json',
},
}),
});
const body: unknown = await res.json();
t.same((body as { response: unknown }).response, 'json');
shutdown();
});
void test('json limit (below)', async (t) => {
interface Payload {
some: { cool: string };
}
const fn: RequestHandler = async (req, res) => {
const body = await json(req, {
limit: 100,
});
send(res, 200, {
response: (body as Payload).some.cool,
});
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url, {
method: 'POST',
body: JSON.stringify({
some: {
cool: 'json',
},
}),
});
const body: unknown = await res.json();
t.same((body as { response: unknown }).response, 'json');
shutdown();
});
void test('json limit (over)', async (t) => {
const fn: RequestHandler = async (req, res) => {
try {
await json(req, {
limit: 3,
});
} catch (err) {
t.same((err as HttpError).statusCode, 413);
}
send(res, 200, 'ok');
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url, {
method: 'POST',
body: JSON.stringify({
some: {
cool: 'json',
},
}),
});
t.same(res.status, 200);
shutdown();
});
void test('json circular', async (t) => {
interface Payload {
circular: boolean;
obj?: Payload;
}
const fn: RequestHandler = (req, res) => {
const obj: Payload = {
circular: true,
};
obj.obj = obj;
send(res, 200, obj);
};
const [url, shutdown] = await startServer(fn);
const { status } = await fetch(url);
t.same(status, 500);
shutdown();
});
void test('no async', async (t) => {
const fn: RequestHandler = (req, res) => {
send(res, 200, {
a: 'b',
});
};
const [url, shutdown] = await startServer(fn);
const obj: unknown = await fetch(url).then((r) => r.json());
t.same((obj as { a: string }).a, 'b');
shutdown();
});
void test('limit included in error', async (t) => {
interface Payload {
some: { cool: string };
}
const fn: RequestHandler = async (req, res) => {
let body;
try {
body = await json(req, {
limit: 3,
});
} catch (err) {
t.ok((err as Error).message.includes('exceeded 3 limit'));
}
send(res, 200, {
response: (body as Payload).some.cool,
});
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url, {
method: 'POST',
body: JSON.stringify({
some: {
cool: 'json',
},
}),
});
t.same(res.status, 500);
shutdown();
});
void test('support for status fallback in errors', async (t) => {
const fn: RequestHandler = (req, res) => {
const err = new HttpError('Custom');
err.statusCode = 403;
sendError(req, res, err);
};
const [url, shutdown] = await startServer(fn);
const { status } = await fetch(url);
t.same(status, 403);
shutdown();
});
void test('json from rawBodyMap works', async (t) => {
interface Payload {
some: { cool: string };
}
const fn: RequestHandler = async (req, res) => {
const bodyOne = await json(req);
const bodyTwo = await json(req);
t.same(bodyOne, bodyTwo);
send(res, 200, {
response: (bodyOne as Payload).some.cool,
});
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url, {
method: 'POST',
body: JSON.stringify({
some: {
cool: 'json',
},
}),
});
const body: unknown = await res.json();
t.same((body as { response: unknown }).response, 'json');
shutdown();
});
void test('statusCode defaults to 200', async (t) => {
const fn: RequestHandler = () => {
return 'woot';
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url);
const body = await res.text();
t.equal(body, 'woot');
t.equal(res.status, 200);
shutdown();
});
void test('statusCode on response works', async (t) => {
const fn: RequestHandler = (req, res) => {
res.statusCode = 400;
return 'woot';
};
const [url, shutdown] = await startServer(fn);
const { status } = await fetch(url);
t.same(status, 400);
shutdown();
});
void test('Content-Type header is preserved on string', async (t) => {
const fn: RequestHandler = (req, res) => {
res.setHeader('Content-Type', 'text/html');
return '<blink>woot</blink>';
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url);
t.equal(res.headers.get('content-type'), 'text/html');
shutdown();
});
void test('Content-Type header is preserved on stream', async (t) => {
const fn: RequestHandler = (req, res) => {
res.setHeader('Content-Type', 'text/html');
const stream = new Stream.Transform();
stream.push('River');
stream.end();
return stream;
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url);
t.equal(res.headers.get('content-type'), 'text/html');
shutdown();
});
void test('Content-Type header is preserved on buffer', async (t) => {
const fn: RequestHandler = (req, res) => {
res.setHeader('Content-Type', 'text/html');
return Buffer.from('hello');
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url);
t.equal(res.headers.get('content-type'), 'text/html');
shutdown();
});
void test('Content-Type header is preserved on object', async (t) => {
const fn: RequestHandler = (req, res) => {
res.setHeader('Content-Type', 'text/html');
return {};
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url);
t.equal(res.headers.get('content-type'), 'text/html');
shutdown();
});
void test('res.end is working', async (t) => {
const fn: RequestHandler = (req, res) => {
setTimeout(() => res.end('woot'), 100);
};
const [url, shutdown] = await startServer(fn);
const res = await fetch(url).then((r) => r.text());
t.same(res, 'woot');
shutdown();
});
void test('json should throw 400 on empty body with no headers', async (t) => {
const fn: RequestHandler = (req) => json(req);
const [url, shutdown] = await startServer(fn);
const res = await fetch(url);
const body = await res.text();
t.equal(body, 'Invalid JSON');
t.equal(res.status, 400);
shutdown();
});
void test('buffer should throw 400 on invalid encoding', async (t) => {
const bufferInfo = { encoding: 'lol' };
const fn: RequestHandler = async (req) =>
buffer(req, bufferInfo as BufferInfo);
const [url, shutdown] = await startServer(fn);
const res = await fetch(url, {
method: 'POST',
body: '',
});
const body = await res.text();
t.equal(body, 'Invalid body');
t.equal(res.status, 400);
shutdown();
});
void test('buffer works', async (t) => {
const fn: RequestHandler = (req) => buffer(req);
const [url, shutdown] = await startServer(fn);
const res = await fetch(url, { method: 'POST', body: '' });
const body = await res.text();
t.equal(body, '');
shutdown();
});
void test('Content-Type header for JSON is set', async (t) => {
const [url, shutdown] = await startServer(() => ({}));
const res = await fetch(url);
t.equal(res.headers.get('content-type'), 'application/json; charset=utf-8');
shutdown();
});
``` | /content/code_sandbox/test/suite/index.ts | xml | 2016-01-23T05:17:00 | 2024-08-15T13:02:51 | micro | vercel/micro | 10,560 | 4,364 |
```xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<document type="com.apple.InterfaceBuilder3.CocoaTouch.XIB" version="3.0" toolsVersion="9531" systemVersion="15A2301" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES">
<dependencies>
<deployment identifier="iOS"/>
<plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="9529"/>
</dependencies>
<objects>
<placeholder placeholderIdentifier="IBFilesOwner" id="-1" userLabel="File's Owner" customClass="RZSimpleCollectionViewController">
<connections>
<outlet property="collectionView" destination="bwQ-eI-bsg" id="4X7-Ph-IRf"/>
<outlet property="view" destination="1" id="3"/>
</connections>
</placeholder>
<placeholder placeholderIdentifier="IBFirstResponder" id="-2" customClass="UIResponder"/>
<view contentMode="scaleToFill" id="1">
<rect key="frame" x="0.0" y="0.0" width="320" height="568"/>
<autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
<subviews>
<collectionView opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="scaleToFill" fixedFrame="YES" minimumZoomScale="0.0" maximumZoomScale="0.0" dataMode="none" translatesAutoresizingMaskIntoConstraints="NO" id="bwQ-eI-bsg">
<rect key="frame" x="0.0" y="0.0" width="320" height="568"/>
<color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
<inset key="scrollIndicatorInsets" minX="0.0" minY="88" maxX="0.0" maxY="0.0"/>
<collectionViewFlowLayout key="collectionViewLayout" minimumLineSpacing="10" minimumInteritemSpacing="10" id="DZk-nj-5uF">
<size key="itemSize" width="88" height="88"/>
<size key="headerReferenceSize" width="0.0" height="0.0"/>
<size key="footerReferenceSize" width="0.0" height="0.0"/>
<inset key="sectionInset" minX="10" minY="10" maxX="10" maxY="0.0"/>
</collectionViewFlowLayout>
<cells/>
<connections>
<outlet property="dataSource" destination="-1" id="pcP-0e-JNA"/>
<outlet property="delegate" destination="-1" id="jah-gq-Cig"/>
</connections>
</collectionView>
</subviews>
<color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
<simulatedNavigationBarMetrics key="simulatedTopBarMetrics" prompted="NO"/>
</view>
</objects>
</document>
``` | /content/code_sandbox/BigShow1949/Classes/04 - ViewTransition(视图切换)/RZTransitions/ViewControllers/RZSimpleCollectionViewController.xib | xml | 2016-05-05T08:19:43 | 2024-08-07T09:29:21 | BigShow1949 | BigShow1949/BigShow1949 | 1,121 | 679 |
```xml
// See LICENSE in the project root for license information.
import type { Chunk, ChunkGraph } from 'webpack';
export function chunkIsJs(chunk: Chunk, chunkGraph: ChunkGraph): boolean {
return !!chunkGraph.getChunkModulesIterableBySourceType(chunk, 'javascript');
}
``` | /content/code_sandbox/webpack/webpack5-localization-plugin/src/utilities/chunkUtilities.ts | xml | 2016-09-30T00:28:20 | 2024-08-16T18:54:35 | rushstack | microsoft/rushstack | 5,790 | 58 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.3//EN"
"path_to_url" [
<!ENTITY legal SYSTEM "legal.xml">
]>
<!--<?yelp:chunk-depth 4?>
-->
<!--
(Do not remove this comment block.)
Version: 3.0
Last modified: Sep 8, 2010
Maintainers:
Michael Vogt <mvo@ubuntu.com>
Translators:
(translators put your name and email here)
-->
<!-- =============Document Header ============================= -->
<book id="index" lang="de">
<!-- ============= Document Body ============================= -->
<!-- ============= Introduction ============================== -->
<bookinfo>
<!-- please do not change the id; for translations, change lang to -->
<!-- appropriate code -->
<title>Software-Center</title>
<!-- translators: uncomment this:
<copyright>
<year>2000</year>
<holder>ME-THE-TRANSLATOR (Latin translation)</holder>
</copyright>
-->
<!-- An address can be added to the publisher information. If a role is
not specified, the publisher/author is the same for all versions of the
document. -->
<!-- This file contains link to license for the documentation (GNU FDL), and
other legal stuff such as "NO WARRANTY" statement. Please do not change
any of this. -->
<publisher> <publishername>Ubuntu Documentation Project</publishername>
</publisher> &legal;
<authorgroup>
<author>
<firstname>Michael</firstname>
<surname>Vogt</surname>
<email>mvo@ubuntu.com</email>
</author>
<author>
<firstname>Matthew</firstname>
<firstname>Paul</firstname>
<surname>Thomas</surname>
<email>mpt@ubuntu.com</email>
</author>
<author>
<firstname>Andrew</firstname>
<surname>Higginson</surname>
<email>rugby471@gmail.com</email>
</author>
</authorgroup>
<abstract>
<para>Wie man Software unter Ubuntu installiert und deinstalliert.</para>
</abstract>
</bookinfo>
<chapter id="introduction">
<title>Was ist das Ubuntu Software-Center?</title>
<para>
Das Software-Center ist ein virtueller Katalog tausender freier Anwendungen
und anderer Software, um Ihren Ubuntu-Rechner ntzlicher zu gestalten.
</para>
<para>
Sie knnen Software ber Kategorien oder ber die Suche finden und mit nur
einem Mausklick installieren.
</para>
<para>
Auerdem knnen Sie feststellen, welche Anwendungen bereits auf dem Rechner
installiert sind und alle nicht mehr bentigten entfernen.
</para>
</chapter>
<chapter id="installing">
<title>Anwendungen installieren</title>
<para>
Um etwas mit dem Software-Center zu installieren, bentigen Sie
Systemverwaltungsrechte und eine funktionierende Internetverbindung. (Wenn
Sie Ubuntu selbst auf dem Rechner installiert haben, besitzen Sie bereits
Systemverwaltungsrechte.)
</para>
<orderedlist>
<listitem>
<para>
Suchen Sie im Bereich <guilabel>Anwendungen installieren</guilabel> nach der
Anwendung, die Sie installieren mchten. Wenn Sie bereits deren Namen
kennen, knnen Sie ihn in das Suchfeld eingeben. Oder Sie suchen nach dem
gewnschten Anwendungstyp (wie zum Beispiel
“Tabellenkalkulation”). Sie knnen jedoch auch die einzelnen
Kategorien durchstbern.
</para>
</listitem>
<listitem>
<para>
Whlen Sie die Anwendung aus der Liste und klicken Sie auf <guilabel>Weitere
Informationen</guilabel>.
</para>
</listitem>
<listitem>
<para>
Klicken Sie auf <guilabel>Installieren</guilabel>. Sie mssen Ihr
Ubuntu-Passwort eingeben, bevor die Installation beginnen kann.
</para>
</listitem>
</orderedlist>
<para>
Wie viel Zeit die Installation bentigt, hngt von der Gre der Anwendung,
der Geschwindigkeit Ihres Rechners und Ihrer Internetverbindung ab.
</para>
<para>
Wenn auf dem Bildschirm “Installiert” zu lesen ist, ist die
Anwendung bereit zur Verwendung.
</para>
<itemizedlist>
<listitem><para><xref linkend="launching" endterm="launching-title"/></para></listitem>
<listitem><para><xref linkend="missing" endterm="missing-title"/></para></listitem>
</itemizedlist>
</chapter>
<chapter id="launching">
<title id="launching-title"
>Ein installiertes Programm benutzen</title>
<para>
Die meisten Anwendungen knnen nach der Installation ber das Men
<guimenu>Anwendungen</guimenu> gestartet werden. (Hilfsprogramme zum ndern
von Einstellungen tauchen stattdessen unter
<menuchoice><guimenu>System</guimenu>
<guisubmenu>Einstellungen</guisubmenu></menuchoice> oder
<menuchoice><guimenu>System</guimenu>
<guisubmenu>Systemverwaltung</guisubmenu></menuchoice> auf).
</para>
<para>
Um herauszufinden, wo Sie eine neue Anwendung starten knnen, rufen Sie im
Software-Center die Detailansicht fr dieses Programm auf, falls diese nicht
immer noch angezeigt wird. Dort sollte unter der farbigen Leiste der Fundort
im Men aufgefhrt sein.
</para>
<para>
Falls Sie die Ubuntu Netbook Edition verwenden, erscheint eine Anwendung in
der entsprechenden Kategorie auf dem Startbildschirm.
</para>
<para>
Manche Dinge, wie Media-Codecs oder Webbrowser-Erweiterungen erscheinen
nicht in den Mens. Sie werden automatisch benutzt wenn Ubuntu sie
bentigt. Bei einer Webbrowser-Erweiterung mssen Sie den Browser erst
schlieen und wieder ffnen, bevor diese verwendet werden kann.
</para>
</chapter>
<chapter id="removing">
<title id="removing-title">Anwendungen entfernen</title>
<para>
Um Anwendungen zu entfernen, bentigen Sie Systemverwaltungsrechte. (Wenn
Sie selbst Ubuntu auf dem Rechner installiert haben, verfgen Sie bereits
ber Systemverwaltungsrechte.)
</para>
<orderedlist>
<listitem>
<para>
Suchen Sie im Bereich <guilabel>Installierte Anwendungen</guilabel> die
Anwendung, die Sie entfernen mchten.
</para>
</listitem>
<listitem>
<para>
Whlen Sie die Anwendung aus der Liste und klicken Sie auf
<guilabel>Entfernen</guilabel>. Sie mssen anschlieend Ihr Ubuntu-Passwort
eingeben.
</para>
</listitem>
</orderedlist>
<para>
Wenn Sie ein Programm geffnet haben, whrend Sie es entfernen, wird es
normalerweise geffnet bleiben, nachdem es entfernt wurde. Sobald Sie es
schlieen, wird es nicht weiter verfgbar sein.
</para>
<itemizedlist>
<listitem><para><xref linkend="metapackages" endterm="metapackages-title"/></para></listitem>
</itemizedlist>
</chapter>
<chapter id="metapackages">
<title id="metapackages-title"
>Warum werde ich gefragt, viele verschiedene Programme zusammen zu entfernen?</title>
<para>
Manchmal werden Sie beim Entfernen eines Objekts vom Ubuntu Software-Center
gewarnt, dass auch andere Objekte entfernt werden. Dafr gibt es
hauptschlich zwei Grnde.
</para>
<itemizedlist>
<listitem>
<para>
Beim Entfernen einer Anwendung werden normalerweise auch die Erweiterungen
fr diese Anwendung entfernt.
</para>
</listitem>
<listitem>
<para>
Mehrere Anwendungen werden manchmal in einem Paket zusammengefasst. Wenn
eine davon installiert ist, sind alle installiert und wenn eine davon
entfernt wird, werden alle entfernt. Das Software-Center kann Sie nicht
einzeln entfernen, da es nicht ber die Mglichkeit verfgt, sie zu trennen.
</para>
</listitem>
</itemizedlist>
<para>
Sie knnen die Einstellungsmglichkeiten im <guilabel>Hauptmen</guilabel>
nutzen, um nicht bentigte Anwendungen zu verbergen, ohne sie vom Rechner zu
entfernen. Unter Ubuntu finden Sie das <guilabel>Hauptmen</guilabel> unter
<menuchoice><guimenu>System</guimenu>
<guisubmenu>Einstellungen</guisubmenu></menuchoice>. In der Ubuntu Netbook
Edition befindet es sich unter <menuchoice><guimenu>Einstellungen</guimenu>
<guisubmenu>Einstellungen</guisubmenu></menuchoice>.
</para>
<itemizedlist>
<listitem>
<para><ulink url="ghelp:user-guide?menu-editor" >Die Menleiste anpassen</ulink></para>
</listitem>
</itemizedlist>
</chapter>
<chapter id="canonical-maintained">
<title>Was bedeutet “Von Canonical betreut”?</title>
<para>
Ein Teil der fr Ubuntu verfgbaren Anwendungen wird von Canonical
betreut. Entwickler von Canonical stellen sicher, dass
Sicherheitsaktualisierungen oder andere wichtige Aktualisierungen fr diese
Anwendungen bereitgestellt werden.
</para>
<para>
Andere Software wird von der Ubuntu-Entwicklergemeinschaft betreut. Alle
Aktualisierungen werden so gut es geht bereitgestellt.
</para>
</chapter>
<chapter id="canonical-partners">
<title>Was bedeutet “Canonical-Partner”?</title>
<para>
<guilabel>Canonical-Partner</guilabel> enthlt Software von Unternehmen, die
mit Canonical zusammenarbeiten, um ihre Anwendungen fr Ubuntu verfgbar zu
machen.
</para>
<para>
Sie knnen diese Software genauso installieren, wie jede andere Software im
Software-Center.
</para>
</chapter>
<chapter id="commercial">
<title id="commercial-title">Muss ich irgendetwas bezahlen?</title>
<para>
Der berwiegende Teil der Software im Ubuntu Software-Center ist kostenlos.
</para>
<para>
Falls etwas Geld kostet, wird ein <guilabel>Kaufen</guilabel>-Knopf statt
<guilabel>Installieren</guilabel> angezeigt und der Preis fr das Objekt ist
angegeben.
</para>
<para>
Um fr kommerzielle Software zu bezahlen, bentigen Sie eine
Internetverbindung und ein Ubuntu Single Sign On- oder
Launchpad-Konto. Falls Sie keines besitzen, hilft Ihnen das Ubuntu
Software-Center bei der Registrierung.
</para>
</chapter>
<chapter id="commercial-reinstalling">
<title id="commercial-reinstalling-title">
Was kann ich tun, wenn ich fr Anwendungen bezahlt und diese verloren habe?
</title>
<para>
Falls Sie bezahlte Anwendungen versehentlich entfernt haben und Sie erneut
installieren mchten, whlen Sie <menuchoice><guimenu>Datei</guimenu>
<guimenuitem>Vorherige Einkufe neu installieren
</guimenuitem></menuchoice>.
</para>
<para>
Sobald Sie sich bei dem Konto angemeldet haben, das Sie auch zum Bezahlen
verwendet haben, werden Ihnen Ihre Einkufe zum erneuten Installieren
angezeigt.
</para>
<para>
Dies funktioniert auch, wenn Sie Ubuntu neu installiert haben.
</para>
</chapter>
<chapter id="missing">
<title id="missing-title"
>Was tun, wenn ein Programm nicht verfgbar ist?</title>
<para>
Stellen Sie zunchst sicher, dass <menuchoice><guimenu>Ansicht</guimenu>
<guimenuitem>Alle Anwendungen</guimenuitem></menuchoice> ausgewhlt ist.
</para>
<para>
Wenn die Anwendung immer noch nicht verfgbar ist, Sie jedoch mit Sicherheit
wissen, dass Sie unter Ubuntu luft, versuchen Sie ursprnglichen Entwickler
des jeweiligen Programms zu kontaktieren, um sie zu fragen, ob sie dabei
helfen knnen, die Anwendung verfgbar zu machen.
</para>
<para>
Wenn das Programm fr andere Betriebssysteme, aber nicht Ubuntu verfgbar
ist, teilen Sie den Entwicklern mit, dass Sie daran interessiert wren, es
unter Ubuntu laufen zu haben.
</para>
</chapter>
<chapter id="bugs">
<title id="bugs-title"
>Was, wenn ein Programm nicht funktioniert?</title>
<para>
Bei mehreren zehntausend Anwendungen im Software-Center besteht immer die
kleine Chance, dass einige davon nicht richtig auf Ihrem Rechner laufen.
</para>
<para>
Wenn Sie wissen, wie man Fehlerberichte ber Software erstellt, knnen Sie
helfen indem Sie das Problem den Ubuntu-Entwicklern melden. Die meisten
Anwendungen haben den Eintrag <guimenuitem>Einen Fehler melden</guimenuitem>
in ihrem <guimenu>Hilfe</guimenu> Men.
</para>
<para>
Suchen Sie andernfalls im Ubuntu Software-Center nach einer anderen
Anwendung, welche die gewnschte Aufgabe erfllt.
</para>
<itemizedlist>
<listitem><para><xref linkend="removing" endterm="removing-title"/></para></listitem>
</itemizedlist>
</chapter>
</book>
``` | /content/code_sandbox/help/de/software-center.xml | xml | 2016-08-08T17:54:58 | 2024-08-06T13:58:47 | x-mario-center | fossasia/x-mario-center | 1,487 | 3,368 |
```xml
<UserControl x:Class="ScreenToGif.UserControls.KGySoftGifOptionsPanel"
xmlns="path_to_url"
xmlns:x="path_to_url"
xmlns:mc="path_to_url"
xmlns:d="path_to_url"
xmlns:vm="clr-namespace:ScreenToGif.ViewModel"
xmlns:c="clr-namespace:ScreenToGif.Controls"
mc:Ignorable="d"
Name="This" d:DataContext="{d:DesignInstance vm:KGySoftGifOptionsViewModel, IsDesignTimeCreatable=False}"
Unloaded="KGySoftGifOptionsPanel_OnUnloaded" DataContextChanged="KGySoftGifOptionsPanel_OnDataContextChanged">
<StackPanel Margin="0,0,3,0">
<!--Quantizer-->
<GroupBox Header="{DynamicResource S.SaveAs.KGySoft.Quantizer}">
<StackPanel>
<!--Selectable quantizers-->
<ComboBox x:Name="QuantizersComboBox" Height="38" Margin="3" ItemsSource="{Binding Quantizers}" SelectedValue="{Binding QuantizerId}"
SelectedValuePath="Id" ItemTemplate="{StaticResource Template.ComboBox.SimpleNoIcon}"/>
<!--Quantizers Options-->
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<!--Back Color-->
<TextBlock Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" Margin="3,0,5,0" Foreground="{DynamicResource Element.Foreground.Medium}"
Text="{DynamicResource S.SaveAs.KGySoft.Quantizer.BackColor}" ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.BackColor.Info}"/>
<c:ColorBox Grid.Row="0" Grid.Column="1" Margin="3" AllowTransparency="False" SelectedColor="{Binding BackColor, Mode=TwoWay}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.BackColor.Info}"/>
<!--Alpha Threshold-->
<TextBlock Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" Margin="3,0,5,0" Foreground="{DynamicResource Element.Foreground.Medium}"
Text="{DynamicResource S.SaveAs.KGySoft.Quantizer.AlphaThreshold}" ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.AlphaThreshold.Info}"
Visibility="{Binding ElementName=QuantizersComboBox, Path=SelectedItem.(vm:QuantizerDescriptor.HasAlphaThreshold), Converter={StaticResource Bool2Visibility}}"/>
<Slider Grid.Row="1" Grid.Column="1" Margin="0,3" TickPlacement="BottomRight" AutoToolTipPlacement="TopLeft" Minimum="0" Maximum="255" TickFrequency="32"
Value="{Binding AlphaThreshold}" SmallChange="1" LargeChange="32" ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.AlphaThreshold.Info}"
Visibility="{Binding ElementName=QuantizersComboBox, Path=SelectedItem.(vm:QuantizerDescriptor.HasAlphaThreshold), Converter={StaticResource Bool2Visibility}}"/>
<!--White Threshold-->
<TextBlock Grid.Row="2" Grid.Column="0" VerticalAlignment="Center" Margin="3,0,5,0" Foreground="{DynamicResource Element.Foreground.Medium}"
Text="{DynamicResource S.SaveAs.KGySoft.Quantizer.WhiteThreshold}" ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.WhiteThreshold.Info}"
Visibility="{Binding ElementName=QuantizersComboBox, Path=SelectedItem.(vm:QuantizerDescriptor.HasWhiteThreshold), Converter={StaticResource Bool2Visibility}}"/>
<Slider Grid.Row="2" Grid.Column="1" Margin="0,3" TickPlacement="BottomRight" AutoToolTipPlacement="TopLeft" Minimum="0" Maximum="255" TickFrequency="32"
Value="{Binding WhiteThreshold}" SmallChange="1" LargeChange="32" ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.WhiteThreshold.Info}"
Visibility="{Binding ElementName=QuantizersComboBox, Path=SelectedItem.(vm:QuantizerDescriptor.HasWhiteThreshold), Converter={StaticResource Bool2Visibility}}"/>
<!--Direct Mapping-->
<c:ExtendedCheckBox Grid.Row="3" Grid.Column="0" Grid.ColumnSpan="2" Margin="3" Text="{DynamicResource S.SaveAs.KGySoft.Quantizer.DirectMapping}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.DirectMapping.Info}" IsChecked="{Binding DirectMapping}"
Visibility="{Binding ElementName=QuantizersComboBox, Path=SelectedItem.(vm:QuantizerDescriptor.HasDirectMapping), Converter={StaticResource Bool2Visibility}}"/>
<!--Palette Size-->
<TextBlock Grid.Row="4" Grid.Column="0" VerticalAlignment="Center" Margin="3,0,5,0" Foreground="{DynamicResource Element.Foreground.Medium}"
Text="{DynamicResource S.SaveAs.KGySoft.Quantizer.PaletteSize}" ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.PaletteSize.Info}"
Visibility="{Binding ElementName=QuantizersComboBox, Path=SelectedItem.(vm:QuantizerDescriptor.HasMaxColors), Converter={StaticResource Bool2Visibility}}"/>
<c:IntegerUpDown Grid.Row="4" Grid.Column="1" Margin="3" TextAlignment="Right" Minimum="2" Maximum="256" StepValue="1" Value="{Binding PaletteSize, Mode=TwoWay}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.PaletteSize.Info}"
Visibility="{Binding ElementName=QuantizersComboBox, Path=SelectedItem.(vm:QuantizerDescriptor.HasMaxColors), Converter={StaticResource Bool2Visibility}}"/>
<!--Bit Level-->
<c:ExtendedCheckBox Grid.Row="5" Grid.Column="0" Margin="3,8,5,8" Text="{DynamicResource S.SaveAs.KGySoft.Quantizer.CustomBitLevel}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.CustomBitLevel.Info}" IsChecked="{Binding IsCustomBitLevel}"
Visibility="{Binding ElementName=QuantizersComboBox, Path=SelectedItem.(vm:QuantizerDescriptor.HasBitLevel), Converter={StaticResource Bool2Visibility}, FallbackValue={x:Static Visibility.Collapsed}}"/>
<Slider Grid.Row="5" Grid.Column="1" Margin="0,3" TickPlacement="BottomRight" AutoToolTipPlacement="TopLeft"
Minimum="1" Maximum="8" TickFrequency="1" Value="{Binding BitLevel, FallbackValue=0}" SmallChange="1" LargeChange="32"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.BitLevel.Info}">
<Slider.Visibility>
<MultiBinding Converter="{StaticResource BoolAndToVisibility}">
<Binding ElementName="QuantizersComboBox" Path="SelectedItem.(vm:QuantizerDescriptor.HasBitLevel)"/>
<Binding Path="IsCustomBitLevel"/>
</MultiBinding>
</Slider.Visibility>
</Slider>
<!--Linear Color Space-->
<c:ExtendedCheckBox Grid.Row="6" Grid.Column="0" Grid.ColumnSpan="2" Margin="3"
Text="{DynamicResource S.SaveAs.KGySoft.Quantizer.LinearColorSpace}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Quantizer.LinearColorSpace.Info}"
IsChecked="{Binding LinearColorSpace}"/>
</Grid>
</StackPanel>
</GroupBox>
<!--Ditherer-->
<GroupBox>
<GroupBox.Header>
<c:ExtendedCheckBox Text="{DynamicResource S.SaveAs.KGySoft.Ditherer}" IsChecked="{Binding UseDitherer}" Margin="0,0,-10,0"/>
</GroupBox.Header>
<StackPanel IsEnabled="{Binding UseDitherer}">
<!--Selectable ditherers-->
<ComboBox Name="DithererComboBox" Height="38" Margin="3" ItemsSource="{Binding Ditherers}"
SelectedValue="{Binding DithererId}" SelectedValuePath="Id" ItemTemplate="{StaticResource Template.ComboBox.SimpleNoIcon}"/>
<!--Ditherer Options-->
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="45"/>
</Grid.ColumnDefinitions>
<!--Strength-->
<TextBlock Grid.Row="0" Grid.Column="0" VerticalAlignment="Center" Margin="3,0,5,0" Foreground="{DynamicResource Element.Foreground.Medium}"
Text="{DynamicResource S.SaveAs.KGySoft.Ditherer.Strength}" ToolTip="{DynamicResource S.SaveAs.KGySoft.Ditherer.Strength.Info}"
Visibility="{Binding ElementName=DithererComboBox, Path=SelectedItem.(vm:DithererDescriptor.HasStrength), Converter={StaticResource Bool2Visibility}}"/>
<Slider Grid.Row="0" Grid.Column="1" Margin="0,3" TickPlacement="BottomRight" Minimum="0" Maximum="1" TickFrequency="0.1"
Value="{Binding Strength}" SmallChange="0.01" LargeChange="0.25" ToolTip="{DynamicResource S.SaveAs.KGySoft.Ditherer.Strength.Info}"
Visibility="{Binding ElementName=DithererComboBox, Path=SelectedItem.(vm:DithererDescriptor.HasStrength), Converter={StaticResource Bool2Visibility}}"/>
<!--Issue: StringFormat cannot be a DynamicResource-->
<TextBlock Grid.Row="0" Grid.Column="2" Margin="0,0,3,0" VerticalAlignment="Center" Foreground="{DynamicResource Element.Foreground.Medium}" Text="{Binding Strength, StringFormat=#0.##%;;Auto}"
Visibility="{Binding ElementName=DithererComboBox, Path=SelectedItem.(vm:DithererDescriptor.HasStrength), Converter={StaticResource Bool2Visibility}}"/>
<!--Seed-->
<TextBlock Grid.Row="1" Grid.Column="0" VerticalAlignment="Center" Margin="3,0,5,0" Foreground="{DynamicResource Element.Foreground.Medium}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Ditherer.Seed.Info}" Text="{DynamicResource S.SaveAs.KGySoft.Ditherer.Seed}"
Visibility="{Binding ElementName=DithererComboBox, Path=SelectedItem.(vm:DithererDescriptor.HasSeed), Converter={StaticResource Bool2Visibility}}"/>
<c:NullableIntegerBox Grid.Row="1" Grid.Column="1" Margin="5,3" Value="{Binding Seed, Mode=TwoWay}" ToolTip="{DynamicResource S.SaveAs.KGySoft.Ditherer.Seed.Info}"
Visibility="{Binding ElementName=DithererComboBox, Path=SelectedItem.(vm:DithererDescriptor.HasSeed), Converter={StaticResource Bool2Visibility}}"/>
<!--Serpentine Processing-->
<c:ExtendedCheckBox Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="2" Margin="5,3,3,3" Text="{DynamicResource S.SaveAs.KGySoft.Ditherer.IsSerpentineProcessing}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Ditherer.IsSerpentineProcessing.Info}" IsChecked="{Binding IsSerpentineProcessing}"
Visibility="{Binding ElementName=DithererComboBox, Path=SelectedItem.(vm:DithererDescriptor.HasSerpentineProcessing), Converter={StaticResource Bool2Visibility}}"/>
</Grid>
</StackPanel>
</GroupBox>
<!--Preview-->
<GroupBox Header="{DynamicResource S.SaveAs.KGySoft.Preview}">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto" MinHeight="16"/>
</Grid.RowDefinitions>
<c:ExtendedCheckBox Grid.Row="0" Margin="3" Text="{DynamicResource S.SaveAs.KGySoft.Preview.ShowCurrentFrame}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Preview.ShowCurrentFrame.Info}" IsChecked="{Binding ShowCurrentFrame}"/>
<!--Tried to use ZoomBox and FrameViewer, none of them worked well. Some zoomable solution would be preferable-->
<Image Grid.Row="1" Source="{Binding PreviewImage, Mode=OneWay}" RenderOptions.BitmapScalingMode="HighQuality"/>
<DockPanel Grid.Row="1" LastChildFill="False">
<ProgressBar DockPanel.Dock="Bottom" Height="4" Margin="10,0" IsIndeterminate="True"
Visibility="{Binding IsGenerating, Converter={StaticResource Bool2Visibility}}"/>
</DockPanel>
<Label Grid.Row="1" Template="{StaticResource WarningLabel}" Content="{DynamicResource S.SaveAs.KGySoft.Preview.Refresh}"
Visibility="{Binding ShowRefreshPreview, Converter={StaticResource Bool2Visibility}}" PreviewMouseLeftButtonUp="RefreshPreview_Click"/>
<Label Grid.Row="1" Template="{StaticResource ErrorLabel}" Content="{Binding PreviewError}"
Visibility="{Binding PreviewError, Converter={StaticResource ContentToVisibility}}" PreviewMouseLeftButtonUp="RefreshPreview_Click"/>
</Grid>
</GroupBox>
<!--Animation Settings-->
<GroupBox Header="{DynamicResource S.SaveAs.KGySoft.Animation}">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<!--Repeat Count-->
<c:ExtendedCheckBox Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2" Margin="3" Text="{DynamicResource S.SaveAs.KGySoft.Animation.EndlessLoop}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Animation.EndlessLoop.Info}" IsChecked="{Binding EndlessLoop}"/>
<c:ExtendedCheckBox Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" VerticalContentAlignment="Center" Margin="15,7,5,7"
Text="{DynamicResource S.SaveAs.KGySoft.Animation.PingPong}" ToolTip="{DynamicResource S.SaveAs.KGySoft.Animation.PingPong.Info}"
IsChecked="{Binding PingPong}" Visibility="{Binding EndlessLoop, Converter={StaticResource Bool2Visibility}}"/>
<TextBlock Grid.Row="1" Grid.Column="0" Margin="15,6,3,7" VerticalAlignment="Center" Foreground="{DynamicResource Element.Foreground.Medium}"
Text="{DynamicResource S.SaveAs.KGySoft.Animation.LoopCount}" ToolTip="{DynamicResource S.SaveAs.KGySoft.Animation.LoopCount.Info}"
Visibility="{Binding EndlessLoop, Converter={StaticResource InvertedBoolToVisibility}}"/>
<c:IntegerUpDown Grid.Row="1" Grid.Column="1" Margin="5,3" TextAlignment="Right" Minimum="1" Maximum="65535" StepValue="1"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Animation.LoopCount.Info}" Visibility="{Binding EndlessLoop, Converter={StaticResource InvertedBoolToVisibility}}"/>
<!--Allow Delta Frames-->
<c:ExtendedCheckBox Grid.Row="2" Grid.Column="0" Grid.ColumnSpan="2" Margin="3" Text="{DynamicResource S.SaveAs.KGySoft.Animation.AllowDeltaFrames}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Animation.AllowDeltaFrames.Info}" IsChecked="{Binding AllowDeltaFrames}"/>
<TextBlock Grid.Row="3" Grid.Column="0" Margin="15,5,3,5" VerticalAlignment="Center" Foreground="{DynamicResource Element.Foreground.Medium}"
Text="{DynamicResource S.SaveAs.KGySoft.Animation.DeltaTolerance}" ToolTip="{DynamicResource S.SaveAs.KGySoft.Animation.DeltaTolerance.Info}"
Visibility="{Binding AllowDeltaFrames, Converter={StaticResource Bool2Visibility}}"/>
<Slider Grid.Row="3" Grid.Column="1" Margin="5,3" TickPlacement="BottomRight" AutoToolTipPlacement="TopLeft"
Minimum="0" Maximum="255" TickFrequency="32" Value="{Binding DeltaTolerance}" SmallChange="1" LargeChange="32"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Animation.DeltaTolerance.Info}" Visibility="{Binding AllowDeltaFrames, Converter={StaticResource Bool2Visibility}}"/>
<Label Grid.Row="4" Grid.Column="0" Grid.ColumnSpan="2" Margin="20,3,10,3" Template="{StaticResource WarningLabel}"
Content="{DynamicResource S.SaveAs.KGySoft.Animation.HighDeltaTolerance}"
PreviewMouseLeftButtonUp="HighDeltaToleranceLabel_Click"
Visibility="{Binding IsHighTolerance, Converter={StaticResource Bool2Visibility}}"/>
<!--Allow Clipped Frames-->
<c:ExtendedCheckBox Grid.Row="5" Grid.Column="0" Grid.ColumnSpan="2" Margin="3" Text="{DynamicResource S.SaveAs.KGySoft.Animation.AllowClippedFrames}"
ToolTip="{DynamicResource S.SaveAs.KGySoft.Animation.AllowClippedFrames.Info}" IsChecked="{Binding AllowClippedFrames}"/>
<Label Grid.Row="6" Grid.Column="0" Grid.ColumnSpan="2" Margin="3" Template="{StaticResource InfoLabel}"
Content="{DynamicResource S.SaveAs.KGySoft.Animation.AllowDeltaIgnored}" Visibility="{Binding IsAllowDeltaIgnored, Converter={StaticResource Bool2Visibility}}"
PreviewMouseLeftButtonUp="AllowDeltaIgnoredLabel_Click"/>
<Label Grid.Row="6" Grid.Column="0" Grid.ColumnSpan="2" Margin="3" Template="{StaticResource InfoLabel}"
Content="{DynamicResource S.SaveAs.KGySoft.Animation.AllowClippedIgnored}"
Visibility="{Binding IsAllowClippedIgnored, Converter={StaticResource Bool2Visibility}}"
PreviewMouseLeftButtonUp="AllowClippedIgnoredLabel_Click"/>
</Grid>
</GroupBox>
</StackPanel>
</UserControl>
``` | /content/code_sandbox/ScreenToGif/UserControls/KGySoftGifOptionsPanel.xaml | xml | 2016-08-02T01:28:59 | 2024-08-16T05:33:15 | ScreenToGif | NickeManarin/ScreenToGif | 23,310 | 3,962 |
```xml
import { InjectionToken } from 'graphql-modules';
import { type AccountsPasswordOptions } from '../accounts-password';
export const AccountsPasswordConfigToken = new InjectionToken<AccountsPasswordOptions>(
'AccountsPasswordConfig'
);
``` | /content/code_sandbox/packages/password/src/types/AccountsPasswordConfig.symbol.ts | xml | 2016-10-07T01:43:23 | 2024-07-14T11:57:08 | accounts | accounts-js/accounts | 1,492 | 45 |
```xml
import {JsonEntityStore} from "@tsed/schema";
import {ColumnOpts} from "../domain/ColumnOpts.js";
/**
* @ignore
*/
export interface ColumnCtx extends ColumnOpts {
entity: JsonEntityStore;
schema: any;
}
/**
* @ignore
*/
export function getColumnCtx(entity: JsonEntityStore): ColumnCtx {
const schema = entity.schema.toJSON();
const {columnType = schema.type, options = {}} = entity.store.get<Partial<ColumnOpts>>("objection", {});
return {entity, columnType, options, schema};
}
``` | /content/code_sandbox/packages/orm/objection/src/utils/getColumnCtx.ts | xml | 2016-02-21T18:38:47 | 2024-08-14T21:19:48 | tsed | tsedio/tsed | 2,817 | 121 |
```xml
import { ExtensionContext, window, OutputChannel, Uri, extensions, env, ProgressLocation } from 'vscode';
import * as zip from 'yauzl';
import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';
import { Writable } from 'stream';
import * as async from './novsc/async';
import { isRosetta } from './novsc/adapter';
const MaxRedirects = 10;
let activeInstallation: Promise<boolean> = null;
export async function ensurePlatformPackage(context: ExtensionContext, output: OutputChannel, modal: boolean): Promise<boolean> {
if (await async.fs.exists(path.join(context.extensionPath, 'platform.ok')))
return true;
// Just wait if installation is already in progress.
if (activeInstallation != null)
return activeInstallation;
activeInstallation = doEnsurePlatformPackage(context, output, modal);
let result = await activeInstallation;
activeInstallation = null;
return result;
}
async function doEnsurePlatformPackage(context: ExtensionContext, output: OutputChannel, modal: boolean): Promise<boolean> {
let packageUrl = await getPlatformPackageUrl();
output.appendLine(`Installing platform package from ${packageUrl}`);
try {
await window.withProgress(
{
location: ProgressLocation.Notification,
cancellable: false,
title: 'Acquiring CodeLLDB platform package'
},
async (progress) => {
let lastPercentage = 0;
let reportProgress = (downloaded: number, contentLength: number) => {
let percentage = Math.round(downloaded / contentLength * 100);
progress.report({
message: `${percentage}%`,
increment: percentage - lastPercentage
});
lastPercentage = percentage;
};
let downloadTarget = path.join(os.tmpdir(), `codelldb-${process.pid}-${getRandomInt()}.vsix`);
if (packageUrl.scheme != 'file') {
await download(packageUrl, downloadTarget, reportProgress);
} else {
// Simulate download
await async.fs.copyFile(packageUrl.fsPath, downloadTarget);
for (var i = 0; i <= 100; ++i) {
await async.sleep(10);
reportProgress(i, 100);
}
}
progress.report({
message: 'installing',
increment: 100 - lastPercentage,
});
await installVsix(context, downloadTarget);
await async.fs.unlink(downloadTarget);
}
);
} catch (err) {
output.append(`Error: ${err}`);
output.show();
// Show error message, but don't block on it.
window.showErrorMessage(
`Platform package installation failed: ${err}.\n\n` +
'You can try downloading the package manually.\n' +
'Once done, use "Install from VSIX..." command to install.',
{ modal: modal },
`Open download URL in a browser`
).then(choice => {
if (choice != undefined)
env.openExternal(packageUrl);
});
return false;
}
output.appendLine('Done')
return true;
}
async function getPlatformPackageUrl(): Promise<Uri> {
let pkg = extensions.getExtension('vadimcn.vscode-lldb').packageJSON;
let pp = pkg.config.platformPackages;
let platform = os.platform();
let arch = os.arch();
if (await isRosetta()) {
arch = 'arm64';
}
let id = `${arch}-${platform}`;
let platformPackage = pp.platforms[id];
if (platformPackage == undefined) {
throw new Error(`This platform (${id}) is not suported.`);
}
return Uri.parse(pp.url.replace('${version}', pkg.version).replace('${platformPackage}', platformPackage));
}
async function download(srcUrl: Uri, destPath: string,
progress?: (downloaded: number, contentLength?: number) => void) {
let url = srcUrl.toString(true);
for (let i = 0; i < MaxRedirects; ++i) {
let response = await async.https.get(url);
if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
url = response.headers.location;
} else {
return new Promise(async (resolve, reject) => {
if (response.statusCode < 200 || response.statusCode >= 300) {
reject(new Error(`HTTP status ${response.statusCode} : ${response.statusMessage}`));
}
if (response.headers['content-type'] != 'application/octet-stream') {
reject(new Error('HTTP response does not contain an octet stream'));
} else {
let stm = fs.createWriteStream(destPath, { mode: 0o600 });
let pipeStm = response.pipe(stm);
if (progress) {
let contentLength = response.headers['content-length'] ? Number.parseInt(response.headers['content-length']) : null;
let downloaded = 0;
response.on('data', (chunk) => {
downloaded += chunk.length;
progress(downloaded, contentLength);
})
}
pipeStm.on('finish', resolve);
pipeStm.on('error', reject);
response.on('error', reject);
}
});
}
}
}
async function installVsix(context: ExtensionContext, vsixPath: string) {
let destDir = context.extensionPath;
await extractZip(vsixPath, async (entry) => {
if (!entry.fileName.startsWith('extension/'))
return null; // Skip metadata files.
if (entry.fileName.endsWith('/platform.ok'))
return null; // Skip success indicator, we'll create it at the end.
let destPath = path.join(destDir, entry.fileName.substr(10));
await ensureDirectory(path.dirname(destPath));
let stream = fs.createWriteStream(destPath);
stream.on('finish', () => {
let attrs = (entry.externalFileAttributes >> 16) & 0o7777;
fs.chmod(destPath, attrs, (err) => { });
});
return stream;
});
await async.fs.writeFile(path.join(destDir, 'platform.ok'), '');
}
function extractZip(zipPath: string, callback: (entry: zip.Entry) => Promise<Writable> | null): Promise<void> {
return new Promise((resolve, reject) =>
zip.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
if (err) {
reject(err);
} else {
zipfile.readEntry();
zipfile.on('entry', (entry: zip.Entry) => {
callback(entry).then(outstream => {
if (outstream != null) {
zipfile.openReadStream(entry, (err, zipstream) => {
if (err) {
reject(err);
} else {
outstream.on('error', reject);
zipstream.on('error', reject);
zipstream.on('end', () => zipfile.readEntry());
zipstream.pipe(outstream);
}
});
} else {
zipfile.readEntry();
}
});
});
zipfile.on('end', () => {
zipfile.close();
resolve();
});
zipfile.on('error', reject);
}
})
);
}
async function ensureDirectory(dir: string) {
let exists = await new Promise(resolve => fs.exists(dir, exists => resolve(exists)));
if (!exists) {
await ensureDirectory(path.dirname(dir));
await new Promise<void>((resolve, reject) => fs.mkdir(dir, err => {
if (err) reject(err);
else resolve();
}));
}
}
function getRandomInt(): number {
return Math.floor(Math.random() * 1e10)
}
``` | /content/code_sandbox/extension/install.ts | xml | 2016-01-11T06:37:39 | 2024-08-16T11:30:30 | codelldb | vadimcn/codelldb | 2,468 | 1,636 |
```xml
import * as compose from "lodash.flowright";
import { Alert, confirm } from "modules/common/utils";
import {
IUserGroup,
UsersGroupsQueryResponse,
} from "@erxes/ui-settings/src/permissions/types";
import {
PermissionActionsQueryResponse,
PermissionModulesQueryResponse,
PermissionRemoveMutationResponse,
PermissionTotalCountQueryResponse,
PermissionsFixMutationResponse,
PermissionsQueryResponse,
} from "../types";
import { mutations, queries } from "../graphql";
import PermissionList from "../components/PermissionList";
import React from "react";
import { generatePaginationParams } from "modules/common/utils/router";
import { gql } from "@apollo/client";
import { graphql } from "@apollo/client/react/hoc";
import { NavigateFunction } from 'react-router-dom';
type Props = {
navigate: NavigateFunction;
queryParams: Record<string, string>;
permissionsQuery: PermissionsQueryResponse;
modulesQuery: PermissionModulesQueryResponse;
actionsQuery: PermissionActionsQueryResponse;
usersGroupsQuery: UsersGroupsQueryResponse;
totalCountQuery: PermissionTotalCountQueryResponse;
removeMutation: (params: { variables: { ids: string[] } }) => Promise<any>;
fixPermissionsMutation: PermissionsFixMutationResponse;
};
type FinalProps = {
can: (action: string) => boolean;
} & Props;
const List = (props: FinalProps) => {
const {
fixPermissionsMutation,
queryParams,
permissionsQuery,
modulesQuery,
actionsQuery,
usersGroupsQuery,
totalCountQuery,
removeMutation,
} = props;
// remove action
const remove = (id: string) => {
confirm("This will permanently delete are you absolutely sure?", {
hasDeleteConfirm: true,
}).then(() => {
removeMutation({
variables: { ids: [id] },
})
.then(() => {
Alert.success("You successfully deleted a permission.");
})
.catch((error) => {
Alert.error(error.message);
});
});
};
const isLoading =
permissionsQuery.loading ||
modulesQuery.loading ||
actionsQuery.loading ||
usersGroupsQuery.loading ||
totalCountQuery.loading;
const groups = usersGroupsQuery.usersGroups || [];
const currentGroup =
groups.find((group) => queryParams.groupId === group._id) ||
({} as IUserGroup);
const updatedProps = {
...props,
queryParams,
remove,
totalCount: totalCountQuery.permissionsTotalCount || 0,
modules: modulesQuery.permissionModules || [],
actions: actionsQuery.permissionActions || [],
permissions: permissionsQuery.permissions || [],
groups,
isLoading,
currentGroupName: currentGroup.name,
refetchQueries: commonOptions(queryParams),
fixPermissions: fixPermissionsMutation,
};
return <PermissionList {...updatedProps} />;
};
const commonOptions = (queryParams) => {
const variables = {
module: queryParams.module,
action: queryParams.action,
userId: queryParams.userId,
groupId: queryParams.groupId,
allowed: queryParams.allowed === "notAllowed" ? false : true,
...generatePaginationParams(queryParams),
};
return [
{ query: gql(queries.permissions), variables },
{ query: gql(queries.totalCount), variables },
];
};
export default compose(
graphql<Props, PermissionTotalCountQueryResponse>(gql(queries.totalCount), {
name: "totalCountQuery",
options: ({ queryParams }) => ({
notifyOnNetworkStatusChange: true,
variables: {
module: queryParams.module,
action: queryParams.action,
userId: queryParams.userId,
groupId: queryParams.groupId,
allowed: queryParams.allowed === "notAllowed" ? false : true,
},
}),
}),
graphql<Props, PermissionsQueryResponse>(gql(queries.permissions), {
name: "permissionsQuery",
options: ({ queryParams }) => ({
notifyOnNetworkStatusChange: true,
variables: {
module: queryParams.module,
action: queryParams.action,
userId: queryParams.userId,
groupId: queryParams.groupId,
allowed: queryParams.allowed === "notAllowed" ? false : true,
...generatePaginationParams(queryParams),
},
}),
}),
graphql<Props, PermissionModulesQueryResponse>(gql(queries.modules), {
name: "modulesQuery",
}),
graphql<Props, PermissionActionsQueryResponse>(gql(queries.actions), {
name: "actionsQuery",
}),
graphql<{}, UsersGroupsQueryResponse>(gql(queries.usersGroups), {
name: "usersGroupsQuery",
}),
// mutations
graphql<Props, PermissionRemoveMutationResponse>(
gql(mutations.permissionRemove),
{
name: "removeMutation",
options: ({ queryParams }) => ({
refetchQueries: commonOptions(queryParams),
}),
}
),
graphql<Props>(gql(mutations.permissionsFix), {
name: "fixPermissionsMutation",
options: ({ queryParams }) => ({
refetchQueries: commonOptions(queryParams),
}),
})
)(List);
``` | /content/code_sandbox/packages/core-ui/src/modules/settings/permissions/containers/PermissionList.tsx | xml | 2016-11-11T06:54:50 | 2024-08-16T10:26:06 | erxes | erxes/erxes | 3,479 | 1,054 |
```xml
///
///
///
/// path_to_url
///
/// Unless required by applicable law or agreed to in writing, software
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
///
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { PageLink } from '@shared/models/page/page-link';
import { defaultHttpOptionsFromConfig, defaultHttpUploadOptions, RequestConfig } from '@core/http/http-utils';
import { Observable, of, ReplaySubject } from 'rxjs';
import { PageData } from '@shared/models/page/page-data';
import {
NO_IMAGE_DATA_URI,
ImageResourceInfo,
imageResourceType,
ImageResourceType,
IMAGES_URL_PREFIX, isImageResourceUrl, ImageExportData, removeTbImagePrefix, ResourceSubType
} from '@shared/models/resource.models';
import { catchError, map, switchMap } from 'rxjs/operators';
import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
import { blobToBase64, blobToText } from '@core/utils';
import { ResourcesService } from '@core/services/resources.service';
@Injectable({
providedIn: 'root'
})
export class ImageService {
private imagesLoading: { [url: string]: ReplaySubject<Blob> } = {};
constructor(
private http: HttpClient,
private sanitizer: DomSanitizer,
private resourcesService: ResourcesService
) {
}
public uploadImage(file: File, title: string, imageSubType: ResourceSubType, config?: RequestConfig): Observable<ImageResourceInfo> {
if (!config) {
config = {};
}
const formData = new FormData();
formData.append('file', file);
formData.append('title', title);
formData.append('imageSubType', imageSubType);
return this.http.post<ImageResourceInfo>('/api/image', formData,
defaultHttpUploadOptions(config.ignoreLoading, config.ignoreErrors, config.resendRequest));
}
public updateImage(type: ImageResourceType, key: string, file: File, config?: RequestConfig): Observable<ImageResourceInfo> {
if (!config) {
config = {};
}
const formData = new FormData();
formData.append('file', file);
return this.http.put<ImageResourceInfo>(`${IMAGES_URL_PREFIX}/${type}/${encodeURIComponent(key)}`, formData,
defaultHttpUploadOptions(config.ignoreLoading, config.ignoreErrors, config.resendRequest));
}
public updateImageInfo(imageInfo: ImageResourceInfo, config?: RequestConfig): Observable<ImageResourceInfo> {
const type = imageResourceType(imageInfo);
const key = encodeURIComponent(imageInfo.resourceKey);
return this.http.put<ImageResourceInfo>(`${IMAGES_URL_PREFIX}/${type}/${key}/info`,
imageInfo, defaultHttpOptionsFromConfig(config));
}
public updateImagePublicStatus(imageInfo: ImageResourceInfo, isPublic: boolean, config?: RequestConfig): Observable<ImageResourceInfo> {
const type = imageResourceType(imageInfo);
const key = encodeURIComponent(imageInfo.resourceKey);
return this.http.put<ImageResourceInfo>(`${IMAGES_URL_PREFIX}/${type}/${key}/public/${isPublic}`,
imageInfo, defaultHttpOptionsFromConfig(config));
}
public getImages(pageLink: PageLink, imageSubType: ResourceSubType,
includeSystemImages = false, config?: RequestConfig): Observable<PageData<ImageResourceInfo>> {
return this.http.get<PageData<ImageResourceInfo>>(
`${IMAGES_URL_PREFIX}${pageLink.toQuery()}&imageSubType=${imageSubType}&includeSystemImages=${includeSystemImages}`,
defaultHttpOptionsFromConfig(config));
}
public getImageInfo(type: ImageResourceType, key: string, config?: RequestConfig): Observable<ImageResourceInfo> {
return this.http.get<ImageResourceInfo>(`${IMAGES_URL_PREFIX}/${type}/${encodeURIComponent(key)}/info`,
defaultHttpOptionsFromConfig(config));
}
public getImageDataUrl(imageUrl: string, preview = false, asString = false, emptyUrl = NO_IMAGE_DATA_URI): Observable<SafeUrl | string> {
const parts = imageUrl.split('/');
const key = parts[parts.length - 1];
parts[parts.length - 1] = encodeURIComponent(key);
const encodedUrl = parts.join('/');
const imageLink = preview ? (encodedUrl + '/preview') : encodedUrl;
return this.loadImageDataUrl(imageLink, asString, emptyUrl);
}
private loadImageDataUrl(imageLink: string, asString = false, emptyUrl = NO_IMAGE_DATA_URI): Observable<SafeUrl | string> {
let request: ReplaySubject<Blob>;
if (this.imagesLoading[imageLink]) {
request = this.imagesLoading[imageLink];
} else {
request = new ReplaySubject<Blob>(1);
this.imagesLoading[imageLink] = request;
const options = defaultHttpOptionsFromConfig({ignoreLoading: true, ignoreErrors: true});
this.http.get(imageLink, {...options, ...{ responseType: 'blob' } }).subscribe({
next: (value) => {
request.next(value);
request.complete();
},
error: err => {
request.error(err);
},
complete: () => {
delete this.imagesLoading[imageLink];
}
});
}
return request.pipe(
switchMap(val => blobToBase64(val).pipe(
map((dataUrl) => asString ? dataUrl : this.sanitizer.bypassSecurityTrustUrl(dataUrl))
)),
catchError(() => of(asString ? emptyUrl : this.sanitizer.bypassSecurityTrustUrl(emptyUrl)))
);
}
public getImageString(imageUrl: string): Observable<string> {
imageUrl = removeTbImagePrefix(imageUrl);
let request: ReplaySubject<Blob>;
if (this.imagesLoading[imageUrl]) {
request = this.imagesLoading[imageUrl];
} else {
request = new ReplaySubject<Blob>(1);
this.imagesLoading[imageUrl] = request;
const options = defaultHttpOptionsFromConfig({ignoreLoading: true, ignoreErrors: true});
this.http.get(imageUrl, {...options, ...{ responseType: 'blob' } }).subscribe({
next: (value) => {
request.next(value);
request.complete();
},
error: err => {
request.error(err);
},
complete: () => {
delete this.imagesLoading[imageUrl];
}
});
}
return request.pipe(
switchMap(val => blobToText(val))
);
}
public resolveImageUrl(imageUrl: string, preview = false, asString = false, emptyUrl = NO_IMAGE_DATA_URI): Observable<SafeUrl | string> {
imageUrl = removeTbImagePrefix(imageUrl);
if (isImageResourceUrl(imageUrl)) {
return this.getImageDataUrl(imageUrl, preview, asString, emptyUrl);
} else {
return of(asString ? imageUrl : this.sanitizer.bypassSecurityTrustUrl(imageUrl));
}
}
public downloadImage(type: ImageResourceType, key: string): Observable<any> {
return this.resourcesService.downloadResource(`${IMAGES_URL_PREFIX}/${type}/${encodeURIComponent(key)}`);
}
public deleteImage(type: ImageResourceType, key: string, force = false, config?: RequestConfig) {
return this.http.delete(`${IMAGES_URL_PREFIX}/${type}/${encodeURIComponent(key)}?force=${force}`, defaultHttpOptionsFromConfig(config));
}
public exportImage(type: ImageResourceType, key: string, config?: RequestConfig): Observable<ImageExportData> {
return this.http.get<ImageExportData>(`${IMAGES_URL_PREFIX}/${type}/${encodeURIComponent(key)}/export`,
defaultHttpOptionsFromConfig(config));
}
public importImage(imageData: ImageExportData, config?: RequestConfig): Observable<ImageResourceInfo> {
return this.http.put<ImageResourceInfo>('/api/image/import',
imageData, defaultHttpOptionsFromConfig(config));
}
}
``` | /content/code_sandbox/ui-ngx/src/app/core/http/image.service.ts | xml | 2016-12-01T09:33:30 | 2024-08-16T19:58:25 | thingsboard | thingsboard/thingsboard | 16,820 | 1,668 |
```xml
import React from 'react';
import Alert from '@erxes/ui/src/utils/Alert';
import { __ } from '@erxes/ui/src/utils/core';
import Button from '@erxes/ui/src/components/Button';
import FormControl from '@erxes/ui/src/components/form/Control';
import Icon from '@erxes/ui/src/components/Icon';
import SortableList from '@erxes/ui/src/components/SortableList';
import { FlexContent, FlexItem } from '@erxes/ui/src/layout/styles';
import { IPollOption } from '../../types';
import { List, Actions } from '../../styles';
type Props = {
options?: IPollOption[];
addButtonLabel?: string;
showAddButton?: boolean;
emptyMessage?: string;
onChangeOption?: (options?: IPollOption[]) => void;
};
type State = {
options: IPollOption[];
optionsObj: IPollOption[];
adding?: boolean;
editing: boolean;
editedIdx: string;
editedOrder: number;
};
const convertOptions = (options: IPollOption[]) => {
const optionObj = (options || []).map(option => {
return {
_id:
option._id ||
Math.random()
.toString(36)
.slice(2),
order: option.order,
title: option.title
};
});
return optionObj;
};
class PollOptions extends React.Component<Props, State> {
constructor(props: Props) {
super(props);
const optionsObj = convertOptions(props.options);
let adding = true;
if (props.showAddButton) {
adding = false;
}
this.state = {
adding: false,
options: props.options || [],
optionsObj: optionsObj || [],
editing: false,
editedIdx: '',
editedOrder: 0
};
}
componentWillReceiveProps(nextProps: Props) {
const { options } = nextProps;
if (options !== this.state.options) {
const optionsObj = convertOptions(options);
this.setState({ options, optionsObj });
}
}
handleChangeOption = () => {
if (this.props.onChangeOption) {
this.props.onChangeOption(this.state.optionsObj);
}
};
handleAddOption = () => {
this.setState({ adding: true });
};
handleCancelAddingOption = () => {
this.setState({ adding: false });
};
handleSaveOption = () => {
const { optionsObj } = this.state;
const optionValue = (document.getElementById(
'optionValue'
) as HTMLInputElement).value;
const optionOrder = (document.getElementById(
'optionOrder'
) as HTMLInputElement).value;
if (!optionValue) {
return Alert.warning('Nothing inserted');
}
if (optionOrder === '') {
return Alert.warning('Insert order number');
}
this.setState(
{
optionsObj: [
...optionsObj,
{
_id: '',
order: parseInt(optionOrder, 10),
title: optionValue
}
]
},
() => {
this.handleChangeOption();
(document.getElementById('optionValue') as HTMLInputElement).value = '';
(document.getElementById(
'optionOrder'
) as HTMLInputElement).value = `${parseInt(optionOrder, 10) + 1}`;
}
);
};
showEditForm = (option: { text: string; _id: string; order: string }) => {
this.setState({
editing: true,
editedIdx: option._id,
editedOrder: parseInt(option.order, 10)
});
};
handleEditOption = (e, type: string) => {
const { optionsObj, editedIdx } = this.state;
const updatedOptionsObj = optionsObj.map(option =>
option._id === editedIdx
? {
title: type === 'title' ? e.target.value : option.title,
_id: option._id,
order:
type === 'order' ? parseInt(e.target.value, 10) : option.order
}
: option
);
this.setState({ optionsObj: updatedOptionsObj });
};
handleRemoveOption = i => {
const { optionsObj } = this.state;
this.setState(
{
optionsObj: optionsObj.filter(option => option._id !== i._id)
},
() => {
this.handleChangeOption();
}
);
};
onKeyPress = e => {
if (e.key === 'Enter') {
e.preventDefault();
this.handleSaveOption();
}
};
saveEditedOption = (value: string) => {
if (value.trim().length === 0) {
return Alert.warning('Option title required!');
}
this.setState({ editing: false, editedIdx: '' }, () => {
this.handleChangeOption();
});
};
renderButtonOrElement = () => {
if (this.state.adding) {
return (
<>
<FlexContent>
<FlexItem count={4}>
<FormControl
id="optionValue"
autoFocus={true}
placeholder="title"
onKeyPress={this.onKeyPress}
/>
</FlexItem>
<FlexItem hasSpace={true} count={4}>
<FormControl
id="optionOrder"
type="number"
defaultValue={0}
onKeyPress={this.onKeyPress}
/>
</FlexItem>
</FlexContent>
<Actions>
<Button
icon="cancel-1"
btnStyle="simple"
size="small"
onClick={this.handleCancelAddingOption}
>
Cancel
</Button>
<Button
btnStyle="success"
size="small"
icon="checked-1"
onClick={this.handleSaveOption}
>
Save
</Button>
</Actions>
</>
);
}
return (
<Button onClick={this.handleAddOption} size="small" icon="plus-circle">
{__(this.props.addButtonLabel || 'Add an option')}
</Button>
);
};
renderTitle = (option: IPollOption, type: string) => {
const value = type === 'title' ? option.title : option.order;
if (this.state.editing && this.state.editedIdx === option._id) {
return (
<input
className="editInput"
onChange={e => this.handleEditOption(e, type)}
value={value}
onBlur={e => {
e.preventDefault();
this.saveEditedOption(e.currentTarget.value);
}}
onKeyPress={e => {
if (e.key === 'Enter') {
e.preventDefault();
this.saveEditedOption(e.currentTarget.value);
}
}}
/>
);
}
return value;
};
renderOption = (option: IPollOption) => {
return (
<li key={option._id} onDoubleClick={this.showEditForm.bind(this, option)}>
<FlexContent>
<FlexItem count={4}>{this.renderTitle(option, 'title')}</FlexItem>
<FlexItem hasSpace={true} count={4}>
{this.renderTitle(option, 'order')}
</FlexItem>
</FlexContent>
<Icon
icon="cancel-1"
onClick={this.handleRemoveOption.bind(this, option)}
/>
</li>
);
};
onChangeOptions = optionsObj => {
this.setState({ optionsObj }, () => {
this.handleChangeOption();
});
};
render() {
const child = option => this.renderOption(option);
const renderListOption = (
<SortableList
fields={this.state.optionsObj}
child={child}
onChangeFields={this.onChangeOptions}
isModal={true}
showDragHandler={false}
droppableId="post option fields"
emptyMessage={this.props.emptyMessage}
/>
);
return (
<List>
{renderListOption}
{this.renderButtonOrElement()}
</List>
);
}
}
export default PollOptions;
``` | /content/code_sandbox/packages/plugin-forum-ui/src/components/posts/PollOptions.tsx | xml | 2016-11-11T06:54:50 | 2024-08-16T10:26:06 | erxes | erxes/erxes | 3,479 | 1,705 |
```xml
// package: pulumirpc
// file: pulumi/analyzer.proto
/* tslint:disable */
/* eslint-disable */
import * as jspb from "google-protobuf";
import * as pulumi_plugin_pb from "./plugin_pb";
import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb";
export class AnalyzeRequest extends jspb.Message {
getType(): string;
setType(value: string): AnalyzeRequest;
hasProperties(): boolean;
clearProperties(): void;
getProperties(): google_protobuf_struct_pb.Struct | undefined;
setProperties(value?: google_protobuf_struct_pb.Struct): AnalyzeRequest;
getUrn(): string;
setUrn(value: string): AnalyzeRequest;
getName(): string;
setName(value: string): AnalyzeRequest;
hasOptions(): boolean;
clearOptions(): void;
getOptions(): AnalyzerResourceOptions | undefined;
setOptions(value?: AnalyzerResourceOptions): AnalyzeRequest;
hasProvider(): boolean;
clearProvider(): void;
getProvider(): AnalyzerProviderResource | undefined;
setProvider(value?: AnalyzerProviderResource): AnalyzeRequest;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AnalyzeRequest.AsObject;
static toObject(includeInstance: boolean, msg: AnalyzeRequest): AnalyzeRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: AnalyzeRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AnalyzeRequest;
static deserializeBinaryFromReader(message: AnalyzeRequest, reader: jspb.BinaryReader): AnalyzeRequest;
}
export namespace AnalyzeRequest {
export type AsObject = {
type: string,
properties?: google_protobuf_struct_pb.Struct.AsObject,
urn: string,
name: string,
options?: AnalyzerResourceOptions.AsObject,
provider?: AnalyzerProviderResource.AsObject,
}
}
export class AnalyzerResource extends jspb.Message {
getType(): string;
setType(value: string): AnalyzerResource;
hasProperties(): boolean;
clearProperties(): void;
getProperties(): google_protobuf_struct_pb.Struct | undefined;
setProperties(value?: google_protobuf_struct_pb.Struct): AnalyzerResource;
getUrn(): string;
setUrn(value: string): AnalyzerResource;
getName(): string;
setName(value: string): AnalyzerResource;
hasOptions(): boolean;
clearOptions(): void;
getOptions(): AnalyzerResourceOptions | undefined;
setOptions(value?: AnalyzerResourceOptions): AnalyzerResource;
hasProvider(): boolean;
clearProvider(): void;
getProvider(): AnalyzerProviderResource | undefined;
setProvider(value?: AnalyzerProviderResource): AnalyzerResource;
getParent(): string;
setParent(value: string): AnalyzerResource;
clearDependenciesList(): void;
getDependenciesList(): Array<string>;
setDependenciesList(value: Array<string>): AnalyzerResource;
addDependencies(value: string, index?: number): string;
getPropertydependenciesMap(): jspb.Map<string, AnalyzerPropertyDependencies>;
clearPropertydependenciesMap(): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AnalyzerResource.AsObject;
static toObject(includeInstance: boolean, msg: AnalyzerResource): AnalyzerResource.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: AnalyzerResource, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AnalyzerResource;
static deserializeBinaryFromReader(message: AnalyzerResource, reader: jspb.BinaryReader): AnalyzerResource;
}
export namespace AnalyzerResource {
export type AsObject = {
type: string,
properties?: google_protobuf_struct_pb.Struct.AsObject,
urn: string,
name: string,
options?: AnalyzerResourceOptions.AsObject,
provider?: AnalyzerProviderResource.AsObject,
parent: string,
dependenciesList: Array<string>,
propertydependenciesMap: Array<[string, AnalyzerPropertyDependencies.AsObject]>,
}
}
export class AnalyzerResourceOptions extends jspb.Message {
getProtect(): boolean;
setProtect(value: boolean): AnalyzerResourceOptions;
clearIgnorechangesList(): void;
getIgnorechangesList(): Array<string>;
setIgnorechangesList(value: Array<string>): AnalyzerResourceOptions;
addIgnorechanges(value: string, index?: number): string;
getDeletebeforereplace(): boolean;
setDeletebeforereplace(value: boolean): AnalyzerResourceOptions;
getDeletebeforereplacedefined(): boolean;
setDeletebeforereplacedefined(value: boolean): AnalyzerResourceOptions;
clearAdditionalsecretoutputsList(): void;
getAdditionalsecretoutputsList(): Array<string>;
setAdditionalsecretoutputsList(value: Array<string>): AnalyzerResourceOptions;
addAdditionalsecretoutputs(value: string, index?: number): string;
clearAliasesList(): void;
getAliasesList(): Array<string>;
setAliasesList(value: Array<string>): AnalyzerResourceOptions;
addAliases(value: string, index?: number): string;
hasCustomtimeouts(): boolean;
clearCustomtimeouts(): void;
getCustomtimeouts(): AnalyzerResourceOptions.CustomTimeouts | undefined;
setCustomtimeouts(value?: AnalyzerResourceOptions.CustomTimeouts): AnalyzerResourceOptions;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AnalyzerResourceOptions.AsObject;
static toObject(includeInstance: boolean, msg: AnalyzerResourceOptions): AnalyzerResourceOptions.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: AnalyzerResourceOptions, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AnalyzerResourceOptions;
static deserializeBinaryFromReader(message: AnalyzerResourceOptions, reader: jspb.BinaryReader): AnalyzerResourceOptions;
}
export namespace AnalyzerResourceOptions {
export type AsObject = {
protect: boolean,
ignorechangesList: Array<string>,
deletebeforereplace: boolean,
deletebeforereplacedefined: boolean,
additionalsecretoutputsList: Array<string>,
aliasesList: Array<string>,
customtimeouts?: AnalyzerResourceOptions.CustomTimeouts.AsObject,
}
export class CustomTimeouts extends jspb.Message {
getCreate(): number;
setCreate(value: number): CustomTimeouts;
getUpdate(): number;
setUpdate(value: number): CustomTimeouts;
getDelete(): number;
setDelete(value: number): CustomTimeouts;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CustomTimeouts.AsObject;
static toObject(includeInstance: boolean, msg: CustomTimeouts): CustomTimeouts.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CustomTimeouts, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CustomTimeouts;
static deserializeBinaryFromReader(message: CustomTimeouts, reader: jspb.BinaryReader): CustomTimeouts;
}
export namespace CustomTimeouts {
export type AsObject = {
create: number,
update: number,
pb_delete: number,
}
}
}
export class AnalyzerProviderResource extends jspb.Message {
getType(): string;
setType(value: string): AnalyzerProviderResource;
hasProperties(): boolean;
clearProperties(): void;
getProperties(): google_protobuf_struct_pb.Struct | undefined;
setProperties(value?: google_protobuf_struct_pb.Struct): AnalyzerProviderResource;
getUrn(): string;
setUrn(value: string): AnalyzerProviderResource;
getName(): string;
setName(value: string): AnalyzerProviderResource;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AnalyzerProviderResource.AsObject;
static toObject(includeInstance: boolean, msg: AnalyzerProviderResource): AnalyzerProviderResource.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: AnalyzerProviderResource, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AnalyzerProviderResource;
static deserializeBinaryFromReader(message: AnalyzerProviderResource, reader: jspb.BinaryReader): AnalyzerProviderResource;
}
export namespace AnalyzerProviderResource {
export type AsObject = {
type: string,
properties?: google_protobuf_struct_pb.Struct.AsObject,
urn: string,
name: string,
}
}
export class AnalyzerPropertyDependencies extends jspb.Message {
clearUrnsList(): void;
getUrnsList(): Array<string>;
setUrnsList(value: Array<string>): AnalyzerPropertyDependencies;
addUrns(value: string, index?: number): string;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AnalyzerPropertyDependencies.AsObject;
static toObject(includeInstance: boolean, msg: AnalyzerPropertyDependencies): AnalyzerPropertyDependencies.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: AnalyzerPropertyDependencies, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AnalyzerPropertyDependencies;
static deserializeBinaryFromReader(message: AnalyzerPropertyDependencies, reader: jspb.BinaryReader): AnalyzerPropertyDependencies;
}
export namespace AnalyzerPropertyDependencies {
export type AsObject = {
urnsList: Array<string>,
}
}
export class AnalyzeStackRequest extends jspb.Message {
clearResourcesList(): void;
getResourcesList(): Array<AnalyzerResource>;
setResourcesList(value: Array<AnalyzerResource>): AnalyzeStackRequest;
addResources(value?: AnalyzerResource, index?: number): AnalyzerResource;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AnalyzeStackRequest.AsObject;
static toObject(includeInstance: boolean, msg: AnalyzeStackRequest): AnalyzeStackRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: AnalyzeStackRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AnalyzeStackRequest;
static deserializeBinaryFromReader(message: AnalyzeStackRequest, reader: jspb.BinaryReader): AnalyzeStackRequest;
}
export namespace AnalyzeStackRequest {
export type AsObject = {
resourcesList: Array<AnalyzerResource.AsObject>,
}
}
export class AnalyzeResponse extends jspb.Message {
clearDiagnosticsList(): void;
getDiagnosticsList(): Array<AnalyzeDiagnostic>;
setDiagnosticsList(value: Array<AnalyzeDiagnostic>): AnalyzeResponse;
addDiagnostics(value?: AnalyzeDiagnostic, index?: number): AnalyzeDiagnostic;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AnalyzeResponse.AsObject;
static toObject(includeInstance: boolean, msg: AnalyzeResponse): AnalyzeResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: AnalyzeResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AnalyzeResponse;
static deserializeBinaryFromReader(message: AnalyzeResponse, reader: jspb.BinaryReader): AnalyzeResponse;
}
export namespace AnalyzeResponse {
export type AsObject = {
diagnosticsList: Array<AnalyzeDiagnostic.AsObject>,
}
}
export class AnalyzeDiagnostic extends jspb.Message {
getPolicyname(): string;
setPolicyname(value: string): AnalyzeDiagnostic;
getPolicypackname(): string;
setPolicypackname(value: string): AnalyzeDiagnostic;
getPolicypackversion(): string;
setPolicypackversion(value: string): AnalyzeDiagnostic;
getDescription(): string;
setDescription(value: string): AnalyzeDiagnostic;
getMessage(): string;
setMessage(value: string): AnalyzeDiagnostic;
clearTagsList(): void;
getTagsList(): Array<string>;
setTagsList(value: Array<string>): AnalyzeDiagnostic;
addTags(value: string, index?: number): string;
getEnforcementlevel(): EnforcementLevel;
setEnforcementlevel(value: EnforcementLevel): AnalyzeDiagnostic;
getUrn(): string;
setUrn(value: string): AnalyzeDiagnostic;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AnalyzeDiagnostic.AsObject;
static toObject(includeInstance: boolean, msg: AnalyzeDiagnostic): AnalyzeDiagnostic.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: AnalyzeDiagnostic, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AnalyzeDiagnostic;
static deserializeBinaryFromReader(message: AnalyzeDiagnostic, reader: jspb.BinaryReader): AnalyzeDiagnostic;
}
export namespace AnalyzeDiagnostic {
export type AsObject = {
policyname: string,
policypackname: string,
policypackversion: string,
description: string,
message: string,
tagsList: Array<string>,
enforcementlevel: EnforcementLevel,
urn: string,
}
}
export class Remediation extends jspb.Message {
getPolicyname(): string;
setPolicyname(value: string): Remediation;
getPolicypackname(): string;
setPolicypackname(value: string): Remediation;
getPolicypackversion(): string;
setPolicypackversion(value: string): Remediation;
getDescription(): string;
setDescription(value: string): Remediation;
hasProperties(): boolean;
clearProperties(): void;
getProperties(): google_protobuf_struct_pb.Struct | undefined;
setProperties(value?: google_protobuf_struct_pb.Struct): Remediation;
getDiagnostic(): string;
setDiagnostic(value: string): Remediation;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Remediation.AsObject;
static toObject(includeInstance: boolean, msg: Remediation): Remediation.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Remediation, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Remediation;
static deserializeBinaryFromReader(message: Remediation, reader: jspb.BinaryReader): Remediation;
}
export namespace Remediation {
export type AsObject = {
policyname: string,
policypackname: string,
policypackversion: string,
description: string,
properties?: google_protobuf_struct_pb.Struct.AsObject,
diagnostic: string,
}
}
export class RemediateResponse extends jspb.Message {
clearRemediationsList(): void;
getRemediationsList(): Array<Remediation>;
setRemediationsList(value: Array<Remediation>): RemediateResponse;
addRemediations(value?: Remediation, index?: number): Remediation;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): RemediateResponse.AsObject;
static toObject(includeInstance: boolean, msg: RemediateResponse): RemediateResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: RemediateResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): RemediateResponse;
static deserializeBinaryFromReader(message: RemediateResponse, reader: jspb.BinaryReader): RemediateResponse;
}
export namespace RemediateResponse {
export type AsObject = {
remediationsList: Array<Remediation.AsObject>,
}
}
export class AnalyzerInfo extends jspb.Message {
getName(): string;
setName(value: string): AnalyzerInfo;
getDisplayname(): string;
setDisplayname(value: string): AnalyzerInfo;
clearPoliciesList(): void;
getPoliciesList(): Array<PolicyInfo>;
setPoliciesList(value: Array<PolicyInfo>): AnalyzerInfo;
addPolicies(value?: PolicyInfo, index?: number): PolicyInfo;
getVersion(): string;
setVersion(value: string): AnalyzerInfo;
getSupportsconfig(): boolean;
setSupportsconfig(value: boolean): AnalyzerInfo;
getInitialconfigMap(): jspb.Map<string, PolicyConfig>;
clearInitialconfigMap(): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): AnalyzerInfo.AsObject;
static toObject(includeInstance: boolean, msg: AnalyzerInfo): AnalyzerInfo.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: AnalyzerInfo, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): AnalyzerInfo;
static deserializeBinaryFromReader(message: AnalyzerInfo, reader: jspb.BinaryReader): AnalyzerInfo;
}
export namespace AnalyzerInfo {
export type AsObject = {
name: string,
displayname: string,
policiesList: Array<PolicyInfo.AsObject>,
version: string,
supportsconfig: boolean,
initialconfigMap: Array<[string, PolicyConfig.AsObject]>,
}
}
export class PolicyInfo extends jspb.Message {
getName(): string;
setName(value: string): PolicyInfo;
getDisplayname(): string;
setDisplayname(value: string): PolicyInfo;
getDescription(): string;
setDescription(value: string): PolicyInfo;
getMessage(): string;
setMessage(value: string): PolicyInfo;
getEnforcementlevel(): EnforcementLevel;
setEnforcementlevel(value: EnforcementLevel): PolicyInfo;
hasConfigschema(): boolean;
clearConfigschema(): void;
getConfigschema(): PolicyConfigSchema | undefined;
setConfigschema(value?: PolicyConfigSchema): PolicyInfo;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): PolicyInfo.AsObject;
static toObject(includeInstance: boolean, msg: PolicyInfo): PolicyInfo.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: PolicyInfo, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): PolicyInfo;
static deserializeBinaryFromReader(message: PolicyInfo, reader: jspb.BinaryReader): PolicyInfo;
}
export namespace PolicyInfo {
export type AsObject = {
name: string,
displayname: string,
description: string,
message: string,
enforcementlevel: EnforcementLevel,
configschema?: PolicyConfigSchema.AsObject,
}
}
export class PolicyConfigSchema extends jspb.Message {
hasProperties(): boolean;
clearProperties(): void;
getProperties(): google_protobuf_struct_pb.Struct | undefined;
setProperties(value?: google_protobuf_struct_pb.Struct): PolicyConfigSchema;
clearRequiredList(): void;
getRequiredList(): Array<string>;
setRequiredList(value: Array<string>): PolicyConfigSchema;
addRequired(value: string, index?: number): string;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): PolicyConfigSchema.AsObject;
static toObject(includeInstance: boolean, msg: PolicyConfigSchema): PolicyConfigSchema.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: PolicyConfigSchema, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): PolicyConfigSchema;
static deserializeBinaryFromReader(message: PolicyConfigSchema, reader: jspb.BinaryReader): PolicyConfigSchema;
}
export namespace PolicyConfigSchema {
export type AsObject = {
properties?: google_protobuf_struct_pb.Struct.AsObject,
requiredList: Array<string>,
}
}
export class PolicyConfig extends jspb.Message {
getEnforcementlevel(): EnforcementLevel;
setEnforcementlevel(value: EnforcementLevel): PolicyConfig;
hasProperties(): boolean;
clearProperties(): void;
getProperties(): google_protobuf_struct_pb.Struct | undefined;
setProperties(value?: google_protobuf_struct_pb.Struct): PolicyConfig;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): PolicyConfig.AsObject;
static toObject(includeInstance: boolean, msg: PolicyConfig): PolicyConfig.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: PolicyConfig, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): PolicyConfig;
static deserializeBinaryFromReader(message: PolicyConfig, reader: jspb.BinaryReader): PolicyConfig;
}
export namespace PolicyConfig {
export type AsObject = {
enforcementlevel: EnforcementLevel,
properties?: google_protobuf_struct_pb.Struct.AsObject,
}
}
export class ConfigureAnalyzerRequest extends jspb.Message {
getPolicyconfigMap(): jspb.Map<string, PolicyConfig>;
clearPolicyconfigMap(): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ConfigureAnalyzerRequest.AsObject;
static toObject(includeInstance: boolean, msg: ConfigureAnalyzerRequest): ConfigureAnalyzerRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ConfigureAnalyzerRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ConfigureAnalyzerRequest;
static deserializeBinaryFromReader(message: ConfigureAnalyzerRequest, reader: jspb.BinaryReader): ConfigureAnalyzerRequest;
}
export namespace ConfigureAnalyzerRequest {
export type AsObject = {
policyconfigMap: Array<[string, PolicyConfig.AsObject]>,
}
}
export enum EnforcementLevel {
ADVISORY = 0,
MANDATORY = 1,
DISABLED = 2,
REMEDIATE = 3,
}
``` | /content/code_sandbox/sdk/nodejs/proto/analyzer_pb.d.ts | xml | 2016-10-31T21:02:47 | 2024-08-16T19:47:04 | pulumi | pulumi/pulumi | 20,743 | 4,948 |
```xml
import * as React from 'react';
import { View, Text, Image, ScrollView, StyleSheet } from 'react-native';
const Profile = () => {
return (
<ScrollView style={styles.container} contentContainerStyle={styles.content}>
<View style={styles.author}>
<Image
style={styles.avatar}
source={require('../../assets/avatar-1.png')}
/>
<View style={styles.meta}>
<Text style={styles.name}>Knowledge Bot</Text>
<Text style={styles.timestamp}>1st Jan 2025</Text>
</View>
</View>
<Text style={styles.title}>Lorem Ipsum</Text>
<Text style={styles.paragraph}>
Contrary to popular belief, Lorem Ipsum is not simply random text. It
has roots in a piece of classical Latin literature from 45 BC, making it
over 2000 years old.
</Text>
<Image style={styles.image} source={require('../../assets/book.jpg')} />
<Text style={styles.paragraph}>
Richard McClintock, a Latin professor at Hampden-Sydney College in
Virginia, looked up one of the more obscure Latin words, consectetur,
from a Lorem Ipsum passage, and going through the cites of the word in
classical literature, discovered the undoubtable source.
</Text>
<Text style={styles.paragraph}>
Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of "de Finibus
Bonorum et Malorum" (The Extremes of Good and Evil) by Cicero,
written in 45 BC. This book is a treatise on the theory of ethics, very
popular during the Renaissance. The first line of Lorem Ipsum,
"Lorem ipsum dolor sit amet..", comes from a line in section
1.10.32.
</Text>
</ScrollView>
);
};
export default Profile;
const styles = StyleSheet.create({
container: {
backgroundColor: 'white',
},
content: {
paddingVertical: 16,
},
author: {
flexDirection: 'row',
marginVertical: 8,
marginHorizontal: 16,
},
meta: {
marginHorizontal: 8,
justifyContent: 'center',
},
name: {
color: '#000',
fontWeight: 'bold',
fontSize: 16,
lineHeight: 24,
},
timestamp: {
color: '#999',
fontSize: 14,
lineHeight: 21,
},
avatar: {
height: 48,
width: 48,
borderRadius: 24,
},
title: {
color: '#000',
fontWeight: 'bold',
fontSize: 36,
marginVertical: 8,
marginHorizontal: 16,
},
paragraph: {
color: '#000',
fontSize: 16,
lineHeight: 24,
marginVertical: 8,
marginHorizontal: 16,
},
image: {
width: '100%',
height: 200,
resizeMode: 'cover',
marginVertical: 8,
},
});
``` | /content/code_sandbox/example/src/Shared/Profile.tsx | xml | 2016-06-15T21:38:19 | 2024-08-14T13:07:59 | react-native-tab-view | satya164/react-native-tab-view | 5,135 | 684 |
```xml
import { HasLocation } from './locations'
import * as VAST from '../ast'
export interface BaseNode extends HasLocation {
type: string
parent: VAST.ASTNode | null
}
export interface HasParentNode extends BaseNode {
parent: VAST.ASTNode
}
``` | /content/code_sandbox/typings/eslint-plugin-vue/util-types/node/node.ts | xml | 2016-08-29T15:26:53 | 2024-08-14T15:17:25 | eslint-plugin-vue | vuejs/eslint-plugin-vue | 4,428 | 63 |
```xml
//
//
// Microsoft Bot Framework: path_to_url
//
// Bot Framework Emulator Github:
// path_to_url
//
// All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
import * as HttpStatus from 'http-status-codes';
import { sendTyping } from './sendTyping';
const mockSendErrorResponse = jest.fn();
jest.mock('../../../utils/sendErrorResponse', () => ({
sendErrorResponse: (...args) => mockSendErrorResponse(...args),
}));
describe('sendTyping handler', () => {
beforeEach(() => {
mockSendErrorResponse.mockClear();
});
it('should send a 200 after sending a ping activity', async () => {
const req: any = {
conversation: {
sendTyping: jest.fn().mockResolvedValueOnce(undefined),
},
};
const res: any = {
end: jest.fn(),
send: jest.fn(),
};
const next = jest.fn();
await sendTyping(req, res);
expect(res.send).toHaveBeenCalledWith(HttpStatus.OK);
expect(res.end).toHaveBeenCalled();
});
it('should send an error response if something goes wrong', async () => {
const req: any = {
conversation: {
sendTyping: jest.fn().mockRejectedValueOnce(new Error('Something went wrong.')),
},
};
const res: any = {};
await sendTyping(req, res);
expect(mockSendErrorResponse).toHaveBeenCalledWith(req, res, null, new Error('Something went wrong.'));
});
});
``` | /content/code_sandbox/packages/app/main/src/server/routes/emulator/handlers/sendTyping.spec.ts | xml | 2016-11-11T23:15:09 | 2024-08-16T12:45:29 | BotFramework-Emulator | microsoft/BotFramework-Emulator | 1,803 | 527 |
```xml
<?xml version="1.0"?>
<!--
-->
<info xmlns:xsi= "path_to_url"
xsi:noNamespaceSchemaLocation="path_to_url">
<id>workflowengine</id>
<name>Nextcloud workflow engine</name>
<summary>Nextcloud workflow engine</summary>
<description>Nextcloud workflow engine</description>
<version>2.13.0</version>
<licence>agpl</licence>
<author>Arthur Schiwon</author>
<author>Julius Hrtl</author>
<author>Morris Jobke</author>
<namespace>WorkflowEngine</namespace>
<types>
<filesystem/>
</types>
<category>files</category>
<website>path_to_url
<bugs>path_to_url
<repository>path_to_url
<dependencies>
<nextcloud min-version="31" max-version="31"/>
</dependencies>
<background-jobs>
<job>OCA\WorkflowEngine\BackgroundJobs\Rotate</job>
</background-jobs>
<repair-steps>
<post-migration>
<step>OCA\WorkflowEngine\Migration\PopulateNewlyIntroducedDatabaseFields</step>
</post-migration>
</repair-steps>
<commands>
<command>OCA\WorkflowEngine\Command\Index</command>
</commands>
<settings>
<admin>OCA\WorkflowEngine\Settings\Admin</admin>
<admin-section>OCA\WorkflowEngine\Settings\Section</admin-section>
<personal>OCA\WorkflowEngine\Settings\Personal</personal>
<personal-section>OCA\WorkflowEngine\Settings\Section</personal-section>
</settings>
</info>
``` | /content/code_sandbox/apps/workflowengine/appinfo/info.xml | xml | 2016-06-02T07:44:14 | 2024-08-16T18:23:54 | server | nextcloud/server | 26,415 | 384 |
```xml
/*
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
import sapxsumpw = require( './index' );
// TESTS //
// The function returns a number...
{
const x = new Float32Array( 10 );
sapxsumpw( x.length, 5.0, x, 1 ); // $ExpectType number
}
// The compiler throws an error if the function is provided a first argument which is not a number...
{
const x = new Float32Array( 10 );
sapxsumpw( '10', 5.0, x, 1 ); // $ExpectError
sapxsumpw( true, 5.0, x, 1 ); // $ExpectError
sapxsumpw( false, 5.0, x, 1 ); // $ExpectError
sapxsumpw( null, 5.0, x, 1 ); // $ExpectError
sapxsumpw( undefined, 5.0, x, 1 ); // $ExpectError
sapxsumpw( [], 5.0, x, 1 ); // $ExpectError
sapxsumpw( {}, 5.0, x, 1 ); // $ExpectError
sapxsumpw( ( x: number ): number => x, 5.0, x, 1 ); // $ExpectError
}
// The compiler throws an error if the function is provided a second argument which is not a number...
{
const x = new Float32Array( 10 );
sapxsumpw( x.length, '10', x, 1 ); // $ExpectError
sapxsumpw( x.length, true, x, 1 ); // $ExpectError
sapxsumpw( x.length, false, x, 1 ); // $ExpectError
sapxsumpw( x.length, null, x, 1 ); // $ExpectError
sapxsumpw( x.length, undefined, x, 1 ); // $ExpectError
sapxsumpw( x.length, [], x, 1 ); // $ExpectError
sapxsumpw( x.length, {}, x, 1 ); // $ExpectError
sapxsumpw( x.length, ( x: number ): number => x, x, 1 ); // $ExpectError
}
// The compiler throws an error if the function is provided a third argument which is not a Float32Array...
{
const x = new Float32Array( 10 );
sapxsumpw( x.length, 5.0, 10, 1 ); // $ExpectError
sapxsumpw( x.length, 5.0, '10', 1 ); // $ExpectError
sapxsumpw( x.length, 5.0, true, 1 ); // $ExpectError
sapxsumpw( x.length, 5.0, false, 1 ); // $ExpectError
sapxsumpw( x.length, 5.0, null, 1 ); // $ExpectError
sapxsumpw( x.length, 5.0, undefined, 1 ); // $ExpectError
sapxsumpw( x.length, 5.0, [], 1 ); // $ExpectError
sapxsumpw( x.length, 5.0, {}, 1 ); // $ExpectError
sapxsumpw( x.length, 5.0, ( x: number ): number => x, 1 ); // $ExpectError
}
// The compiler throws an error if the function is provided a fourth argument which is not a number...
{
const x = new Float32Array( 10 );
sapxsumpw( x.length, 5.0, x, '10' ); // $ExpectError
sapxsumpw( x.length, 5.0, x, true ); // $ExpectError
sapxsumpw( x.length, 5.0, x, false ); // $ExpectError
sapxsumpw( x.length, 5.0, x, null ); // $ExpectError
sapxsumpw( x.length, 5.0, x, undefined ); // $ExpectError
sapxsumpw( x.length, 5.0, x, [] ); // $ExpectError
sapxsumpw( x.length, 5.0, x, {} ); // $ExpectError
sapxsumpw( x.length, 5.0, x, ( x: number ): number => x ); // $ExpectError
}
// The compiler throws an error if the function is provided an unsupported number of arguments...
{
const x = new Float32Array( 10 );
sapxsumpw(); // $ExpectError
sapxsumpw( x.length ); // $ExpectError
sapxsumpw( x.length, 5.0 ); // $ExpectError
sapxsumpw( x.length, 5.0, x ); // $ExpectError
sapxsumpw( x.length, 5.0, x, 1, 10 ); // $ExpectError
}
// Attached to main export is an `ndarray` method which returns a number...
{
const x = new Float32Array( 10 );
sapxsumpw.ndarray( x.length, 5.0, x, 1, 0 ); // $ExpectType number
}
// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
{
const x = new Float32Array( 10 );
sapxsumpw.ndarray( '10', 5.0, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( true, 5.0, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( false, 5.0, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( null, 5.0, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( undefined, 5.0, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( [], 5.0, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( {}, 5.0, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( ( x: number ): number => x, 5.0, x, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number...
{
const x = new Float32Array( 10 );
sapxsumpw.ndarray( x.length, '10', x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, true, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, false, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, null, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, undefined, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, [], x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, {}, x, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, ( x: number ): number => x, x, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a third argument which is not a Float32Array...
{
const x = new Float32Array( 10 );
sapxsumpw.ndarray( x.length, 5.0, 10, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, '10', 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, true, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, false, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, null, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, undefined, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, [], 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, {}, 1, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, ( x: number ): number => x, 1, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
{
const x = new Float32Array( 10 );
sapxsumpw.ndarray( x.length, 5.0, x, '10', 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, true, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, false, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, null, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, undefined, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, [], 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, {}, 0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, ( x: number ): number => x, 0 ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number...
{
const x = new Float32Array( 10 );
sapxsumpw.ndarray( x.length, 5.0, x, 1, '10' ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, 1, true ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, 1, false ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, 1, null ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, 1, undefined ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, 1, [] ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, 1, {} ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, 1, ( x: number ): number => x ); // $ExpectError
}
// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
{
const x = new Float32Array( 10 );
sapxsumpw.ndarray(); // $ExpectError
sapxsumpw.ndarray( x.length ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, 1 ); // $ExpectError
sapxsumpw.ndarray( x.length, 5.0, x, 1, 0, 10 ); // $ExpectError
}
``` | /content/code_sandbox/lib/node_modules/@stdlib/blas/ext/base/sapxsumpw/docs/types/test.ts | xml | 2016-03-24T04:19:52 | 2024-08-16T09:03:19 | stdlib | stdlib-js/stdlib | 4,266 | 2,686 |
```xml
import { HighScore } from "../Types";
interface IProps {
highScores: HighScore[];
highScoreMode: string;
}
const HighScoresList: React.FC<IProps> = ({ highScores, highScoreMode }) => {
const highScoresExist = !!highScores.length;
if (highScoreMode === "None") {
return null;
}
return (
<div className="gameHighScores">
<h2 className="gameHighScoreHeader">{lf("High Scores")}</h2>
{!highScoresExist && (
<p className="gameHighScoreContent">{lf("None yet")}</p>
)}
{highScoresExist && (
<ol className="gameHighScoreContent">
{highScores.slice(0, 5).map((highScore, index) => {
return (
<li key={index}>
<span className="gameHighScoreInitials">
{highScore.initials}
</span>
<span className="gameHighScoreScore">
{highScore.score}
</span>
</li>
);
})}
</ol>
)}
</div>
);
};
export default HighScoresList;
``` | /content/code_sandbox/kiosk/src/Components/HighScoresList.tsx | xml | 2016-01-24T19:35:52 | 2024-08-16T16:39:39 | pxt | microsoft/pxt | 2,069 | 253 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE section PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
"path_to_url">
<!--
file LICENSE_1_0.txt or copy at path_to_url
-->
<section last-revision="$Date: 2007-06-12 14:01:23 -0400 (Tue, 12 Jun 2007) $" id="signals2.examples">
<title>Example programs</title>
<using-namespace name="boost::signals2"/>
<using-namespace name="boost"/>
<section id="signals2.examples.misc">
<title>Miscellaneous Tutorial Examples</title>
<section id="signals2.examples.tutorial.hello_world_slot">
<title>hello_world_slot</title>
<para>
This example is a basic example of connecting a slot to a signal
and then invoking the signal.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/hello_world_slot.cpp">hello_world_slot.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.tutorial.hello_world_multi_slot">
<title>hello_world_multi_slot</title>
<para>
This example extends the hello_world_slot example slightly by connecting more than one
slot to the signal before invoking it.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/hello_world_multi_slot.cpp">hello_world_multi_slot.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.tutorial.ordering_slots">
<title>ordering_slots</title>
<para>
This example extends the hello_world_multi_slot example slightly by
using slot groups to specify
the order slots should be invoked.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/ordering_slots.cpp">ordering_slots.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.tutorial.slot_arguments">
<title>slot_arguments</title>
<para>
The slot_arguments program shows how to pass arguments from a signal invocation to slots.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/slot_arguments.cpp">slot_arguments.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.tutorial.signal_return_value">
<title>signal_return_value</title>
<para>
This example shows how to return a value from slots to the signal invocation.
It uses the default <classname>optional_last_value</classname> combiner.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/signal_return_value.cpp">signal_return_value.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.tutorial.custom_combiners">
<title>custom_combiners</title>
<para>
This example shows more returning of values from slots to the signal invocation.
This time, custom combiners are defined and used.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/custom_combiners.cpp">custom_combiners.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.tutorial.disconnect_and_block">
<title>disconnect_and_block</title>
<para>
This example demonstrates various means of manually disconnecting slots, as well as temporarily
blocking them via <classname>shared_connection_block</classname>.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/disconnect_and_block.cpp">disconnect_and_block.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.tutorial.passing_slots">
<title>passing_slots</title>
<para>
This example demonstrates the passing of slot functions to a private signal
through a non-template interface.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/passing_slots.cpp">passing_slots.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.tutorial.extended_slot">
<title>extended_slot</title>
<para>
This example demonstrates connecting an extended slot to a signal. An extended slot
accepts a reference to its invoking signal-slot connection as an additional argument,
permitting the slot to temporarily block or permanently disconnect itself.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/extended_slot.cpp">extended_slot.cpp</ulink>.
</para>
</section>
</section>
<section id="signals2.examples.document-view">
<title>Document-View</title>
<section id="signals2.examples.document-view.doc_view">
<title>doc_view</title>
<para>
This is the document-view example program which is described in the
<link linkend="signals2.tutorial.document-view">tutorial</link>. It shows
usage of a signal and slots to implement two different views of
a text document.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/doc_view.cpp">doc_view.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.document-view.doc_view_acm">
<title>doc_view_acm</title>
<para>
This program modifies the original doc_view.cpp example to employ
automatic connection management.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/doc_view_acm.cpp">doc_view_acm.cpp</ulink>.
</para>
</section>
<section id="signals2.examples.document-view.doc_view_acm_deconstruct">
<title>doc_view_acm_deconstruct</title>
<para>
This program modifies the doc_view_acm.cpp example to use postconstructors
and the <functionname>deconstruct()</functionname> factory function.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/doc_view_acm_deconstruct.cpp">doc_view_acm_deconstruct.cpp</ulink>.
</para>
</section>
</section>
<section id="signals2.examples.deconstruct">
<title>Postconstructors and Predestructors with <code>deconstruct()</code></title>
<section id="signals2.examples.deconstruct.postconstructor_ex1">
<title>postconstructor_ex1</title>
<para>
This program is a basic example of how to define a class with a postconstructor which
uses <functionname>deconstruct()</functionname> as its factory function.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/postconstructor_ex1.cpp">postconstructor_ex1</ulink>.
</para>
</section>
<section id="signals2.examples.deconstruct.postconstructor_ex2">
<title>postconstructor_ex2</title>
<para>
This program extends the postconstructor_ex1 example slightly, by additionally passing arguments from
the <functionname>deconstruct()</functionname> call through to the class' constructor
and postconstructor.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/postconstructor_ex2.cpp">postconstructor_ex2</ulink>.
</para>
</section>
<section id="signals2.examples.deconstruct.predestructor_example">
<title>predestructor_example</title>
<para>
This program is a basic example of how to define a class with a predestructor which
uses <functionname>deconstruct()</functionname> as its factory function.
</para>
<para>
Download <ulink url="boost:/libs/signals2/example/predestructor_example.cpp">predestructor_example</ulink>.
</para>
</section>
</section>
</section>
``` | /content/code_sandbox/deps/boost_1_66_0/libs/signals2/doc/examples.xml | xml | 2016-09-05T10:18:44 | 2024-08-11T13:21:40 | LiquidCore | LiquidPlayer/LiquidCore | 1,010 | 1,773 |
```xml
import * as React from 'react';
import { IMenuItem } from '../../models/IMenuItem';
import { MenuItem } from './MenuItem';
import { useMenuStyles } from './useMenuStyles';
export interface IMenuProps {
currentItem: IMenuItem;
onItemClick: (item: IMenuItem) => void;
}
const menuItems:IMenuItem[] = [
{
id : 1,
title: "Orders",
description: "Manage orders",
icon: "map:grocery-or-supermarket" ,
},
{
id: 2,
title: "Customers",
description: "Manage customers",
icon: "mingcute:user-2-line" ,
}
];
export const Menu: React.FunctionComponent<IMenuProps> = (props: React.PropsWithChildren<IMenuProps>) => {
const { currentItem, onItemClick } = props;
const styles = useMenuStyles();
return (
<>
<div className={styles.mainContainer}>
{menuItems.map((item, index) => {
const isCurrentItem = item.id === currentItem.id;
return (
<MenuItem key={index} item={item} isCurrentItem={isCurrentItem} onItemClick={() => onItemClick(item)} />
);
})}
</div>
</>
);
};
``` | /content/code_sandbox/samples/react-sales-orders/src/src/components/menu/Menu.tsx | xml | 2016-08-30T17:21:43 | 2024-08-16T18:41:32 | sp-dev-fx-webparts | pnp/sp-dev-fx-webparts | 2,027 | 280 |
```xml
export const MAX_DECIMAL_PRECISION = 20;
export const DEFAULT_DECIMAL_PRECISION = 0;
``` | /content/code_sandbox/source/renderer/app/config/assetsConfig.ts | xml | 2016-10-05T13:48:54 | 2024-08-13T22:03:19 | daedalus | input-output-hk/daedalus | 1,230 | 23 |
```xml
import { interpolateBuPu, interpolatePurples, interpolateRdPu } from 'd3-scale-chromatic';
import React from 'react';
import { BenchmarkType } from '../app/Benchmark';
const targetSize = 10;
type ISierpinskiTriangle = {
components: {
Dot: React.FC<any>;
};
depth: number;
renderCount: number;
s: number;
x: number;
y: number;
};
export default function SierpinskiTriangle({
components,
s,
x,
y,
depth = 0,
renderCount = 0,
}: ISierpinskiTriangle) {
const { Dot } = components;
if (Dot) {
if (s <= targetSize) {
let fn;
switch (depth) {
case 1:
fn = interpolatePurples;
break;
case 2:
fn = interpolateBuPu;
break;
case 3:
default:
fn = interpolateRdPu;
}
// introduce randomness to ensure that repeated runs don't produce the same colors
const color = fn((renderCount * Math.random()) / 20);
return <Dot color={color} size={targetSize} x={x - targetSize / 2} y={y - targetSize / 2} />;
}
s /= 2;
return (
<React.Fragment>
<SierpinskiTriangle
components={components}
depth={1}
renderCount={renderCount}
s={s}
x={x}
y={y - s / 2}
/>
<SierpinskiTriangle
components={components}
depth={2}
renderCount={renderCount}
s={s}
x={x - s}
y={y + s / 2}
/>
<SierpinskiTriangle
components={components}
depth={3}
renderCount={renderCount}
s={s}
x={x + s}
y={y + s / 2}
/>
</React.Fragment>
);
} else {
return <span style={{ color: 'white' }}>No implementation available</span>;
}
}
SierpinskiTriangle.displayName = 'SierpinskiTriangle';
SierpinskiTriangle.benchmarkType = BenchmarkType.UPDATE;
``` | /content/code_sandbox/packages/benchmarks/src/cases/SierpinskiTriangle.tsx | xml | 2016-08-16T06:41:32 | 2024-08-16T12:59:53 | styled-components | styled-components/styled-components | 40,332 | 507 |
```xml
import { Version } from '@microsoft/sp-core-library';
import {
type IPropertyPaneConfiguration,
PropertyPaneToggle,
PropertyPaneHorizontalRule,
PropertyPaneLabel,
} from '@microsoft/sp-property-pane';
import { BaseClientSideWebPart } from '@microsoft/sp-webpart-base';
import type { IReadonlyTheme } from '@microsoft/sp-component-base';
// import styles from './WorkbenchCustomizerWebPart.module.scss';
import * as strings from 'WorkbenchCustomizerWebPartStrings';
// import { delay } from 'lodash';
export interface IWorkbenchCustomizerWebPartProps {
customWorkbenchStyles: boolean;
customWorkbenchStylesFullWidth: boolean;
previewMode: boolean;
}
export default class WorkbenchCustomizerWebPart extends BaseClientSideWebPart<IWorkbenchCustomizerWebPartProps> {
private _isDarkTheme: boolean = false;
// private _environmentMessage: string = '';
public async render(): Promise<void> {
if (!this.renderedOnce) {
if (this.properties.customWorkbenchStyles) {
await import(/* webpackChunkName: 'customWorkbenchStyles' */ './styles/customWorkbenchStyles.module.scss');
}
if (this.properties.customWorkbenchStyles && this.properties.customWorkbenchStylesFullWidth) {
await import(/* webpackChunkName: 'customWorkbenchStylesFullWidth' */ './styles/customWorkbenchStylesFullWidth.module.scss');
}
if (this.properties.previewMode && this.displayMode === 2) {
const previewBtn = document.getElementsByName("Preview")[0];
if (previewBtn) {
previewBtn.click();
}
}
this.domElement.innerHTML = `
<div>
*** ${strings.TitleLabel} | ${strings.ThemeLabel}: ${this._isDarkTheme ? "Dark" : "Light"} ***
</div>`;
}
}
protected onThemeChanged(currentTheme: IReadonlyTheme | undefined): void {
if (!currentTheme) {
return;
}
this._isDarkTheme = !!currentTheme.isInverted;
const {
semanticColors
} = currentTheme;
if (semanticColors) {
this.domElement.style.setProperty('--bodyText', semanticColors.bodyText || null);
this.domElement.style.setProperty('--link', semanticColors.link || null);
this.domElement.style.setProperty('--linkHovered', semanticColors.linkHovered || null);
}
}
protected get disableReactivePropertyChanges(): boolean {
return true;
}
protected get dataVersion(): Version {
return Version.parse('1.0');
}
protected getPropertyPaneConfiguration(): IPropertyPaneConfiguration {
return {
pages: [
{
header: {
description: strings.PropertyPaneDescription,
},
groups: [
{
groupName: strings.BasicGroupName,
groupFields: [
PropertyPaneToggle('customWorkbenchStyles', {
label: strings.CustomWorkbenchStylesFieldLabel,
}),
PropertyPaneToggle('customWorkbenchStylesFullWidth', {
label: strings.customWorkbenchStylesFullWidthFieldLabel,
disabled: !this.properties.customWorkbenchStyles,
}),
PropertyPaneToggle('previewMode', {
label: strings.PreviewModeFieldLabel,
}),
PropertyPaneHorizontalRule(),
PropertyPaneLabel('', {
text: strings.RequestPageRefresh,
}),
]
}
]
}
]
};
}
}
``` | /content/code_sandbox/samples/js-workbench-customizer/src/webparts/workbenchCustomizer/WorkbenchCustomizerWebPart.ts | xml | 2016-08-30T17:21:43 | 2024-08-16T18:41:32 | sp-dev-fx-webparts | pnp/sp-dev-fx-webparts | 2,027 | 722 |
```xml
import { KernelOutput, Texture, TextureArrayOutput } from 'gpu.js';
import {
IJSONLayer,
INeuralNetworkData,
INeuralNetworkDatum,
INeuralNetworkTrainOptions,
} from './neural-network';
import {
INeuralNetworkGPUOptions,
NeuralNetworkGPU,
} from './neural-network-gpu';
import { INeuralNetworkState } from './neural-network-types';
import { UntrainedNeuralNetworkError } from './errors/untrained-neural-network-error';
export interface IAEOptions {
binaryThresh: number;
decodedSize: number;
hiddenLayers: number[];
}
/**
* An autoencoder learns to compress input data down to relevant features and reconstruct input data from its compressed representation.
*/
export class AE<
DecodedData extends INeuralNetworkData,
EncodedData extends INeuralNetworkData
> {
private decoder?: NeuralNetworkGPU<EncodedData, DecodedData>;
private readonly denoiser: NeuralNetworkGPU<DecodedData, DecodedData>;
constructor(options?: Partial<IAEOptions>) {
// Create default options for the autoencoder.
options ??= {};
// Create default options for the autoencoder's denoiser subnet.
const denoiserOptions: Partial<INeuralNetworkGPUOptions> = {};
// Inherit the binary threshold of the parent autoencoder.
denoiserOptions.binaryThresh = options.binaryThresh;
// Inherit the hidden layers of the parent autoencoder.
denoiserOptions.hiddenLayers = options.hiddenLayers;
// Define the denoiser subnet's input and output sizes.
if (options.decodedSize)
denoiserOptions.inputSize = denoiserOptions.outputSize =
options.decodedSize;
// Create the denoiser subnet of the autoencoder.
this.denoiser = new NeuralNetworkGPU<DecodedData, DecodedData>(options);
}
/**
* Denoise input data, removing any anomalies from the data.
* @param {DecodedData} input
* @returns {DecodedData}
*/
denoise(input: DecodedData): DecodedData {
// Run the input through the generic denoiser.
// This isn't the best denoiser implementation, but it's efficient.
// Efficiency is important here because training should focus on
// optimizing for feature extraction as quickly as possible rather than
// denoising and anomaly detection; there are other specialized topologies
// better suited for these tasks anyways, many of which can be implemented
// by using an autoencoder.
return this.denoiser.run(input);
}
/**
* Decode `EncodedData` into an approximation of its original form.
*
* @param {EncodedData} input
* @returns {DecodedData}
*/
decode(input: EncodedData): DecodedData {
// If the decoder has not been trained yet, throw an error.
if (!this.decoder) throw new UntrainedNeuralNetworkError(this);
// Decode the encoded input.
return this.decoder.run(input);
}
/**
* Encode data to extract features, reduce dimensionality, etc.
*
* @param {DecodedData} input
* @returns {EncodedData}
*/
encode(input: DecodedData): EncodedData {
// If the decoder has not been trained yet, throw an error.
if (!this.denoiser) throw new UntrainedNeuralNetworkError(this);
// Process the input.
this.denoiser.run(input);
// Get the auto-encoded input.
let encodedInput: TextureArrayOutput = this
.encodedLayer as TextureArrayOutput;
// If the encoded input is a `Texture`, convert it into an `Array`.
if (encodedInput instanceof Texture) encodedInput = encodedInput.toArray();
else encodedInput = encodedInput.slice(0);
// Return the encoded input.
return encodedInput as EncodedData;
}
/**
* Test whether or not a data sample likely contains anomalies.
* If anomalies are likely present in the sample, returns `true`.
* Otherwise, returns `false`.
*
* @param {DecodedData} input
* @returns {boolean}
*/
likelyIncludesAnomalies(input: DecodedData, anomalyThreshold = 0.2): boolean {
// Create the anomaly vector.
const anomalies: number[] = [];
// Attempt to denoise the input.
const denoised = this.denoise(input);
// Calculate the anomaly vector.
for (let i = 0; i < (input.length ?? 0); i++) {
anomalies[i] = Math.abs(
(input as number[])[i] - (denoised as number[])[i]
);
}
// Calculate the sum of all anomalies within the vector.
const sum = anomalies.reduce(
(previousValue, value) => previousValue + value
);
// Calculate the mean anomaly.
const mean = sum / (input as number[]).length;
// Return whether or not the mean anomaly rate is greater than the anomaly threshold.
return mean > anomalyThreshold;
}
/**
* Train the auto encoder.
*
* @param {DecodedData[]} data
* @param {Partial<INeuralNetworkTrainOptions>} options
* @returns {INeuralNetworkState}
*/
train(
data: DecodedData[],
options?: Partial<INeuralNetworkTrainOptions>
): INeuralNetworkState {
const preprocessedData: Array<INeuralNetworkDatum<
Partial<DecodedData>,
Partial<DecodedData>
>> = [];
for (const datum of data) {
preprocessedData.push({ input: datum, output: datum });
}
const results = this.denoiser.train(preprocessedData, options);
this.decoder = this.createDecoder();
return results;
}
/**
* Create a new decoder from the trained denoiser.
*
* @returns {NeuralNetworkGPU<EncodedData, DecodedData>}
*/
private createDecoder() {
const json = this.denoiser.toJSON();
const layers: IJSONLayer[] = [];
const sizes: number[] = [];
for (let i = this.encodedLayerIndex; i < this.denoiser.sizes.length; i++) {
layers.push(json.layers[i]);
sizes.push(json.sizes[i]);
}
json.layers = layers;
json.sizes = sizes;
json.options.inputSize = json.sizes[0];
const decoder = new NeuralNetworkGPU().fromJSON(json);
return (decoder as unknown) as NeuralNetworkGPU<EncodedData, DecodedData>;
}
/**
* Get the layer containing the encoded representation.
*/
private get encodedLayer(): KernelOutput {
return this.denoiser.outputs[this.encodedLayerIndex];
}
/**
* Get the offset of the encoded layer.
*/
private get encodedLayerIndex(): number {
return Math.round(this.denoiser.outputs.length * 0.5) - 1;
}
}
export default AE;
``` | /content/code_sandbox/src/autoencoder.ts | xml | 2016-02-13T18:09:44 | 2024-08-15T20:41:49 | brain.js | BrainJS/brain.js | 14,300 | 1,541 |
```xml
<Project>
<PropertyGroup>
<PackageId>Microsoft.$(_PlatformName).Ref.$(PackageOSTargetVersion)</PackageId>
<Description>Microsoft $(_PlatformName) reference assemblies. Please do not reference directly.</Description>
<_CreateFrameworkList>true</_CreateFrameworkList>
</PropertyGroup>
<Import Project="common.csproj" />
</Project>
``` | /content/code_sandbox/dotnet/package/microsoft.ref.csproj | xml | 2016-04-20T18:24:26 | 2024-08-16T13:29:19 | xamarin-macios | xamarin/xamarin-macios | 2,436 | 82 |
```xml
/*
tags: basic
<p>This example demonstrates how to use batch mode commands</p>
<p> To use a command in batch mode, we pass in an array of objects. Then
the command is executed once for each object in the array. </p>
*/
// As usual, we start by creating a full screen regl object
import REGL = require('../../regl')
const regl = REGL()
interface Props {
offset: REGL.Vec2;
}
interface Uniforms {
color: REGL.Vec4;
angle: number;
offset: REGL.Vec2;
}
interface Attributes {
position: number[];
}
// Next we create our command
const draw = regl<Uniforms, Attributes, Props>({
frag: `
precision mediump float;
uniform vec4 color;
void main() {
gl_FragColor = color;
}`,
vert: `
precision mediump float;
attribute vec2 position;
uniform float angle;
uniform vec2 offset;
void main() {
gl_Position = vec4(
cos(angle) * position.x + sin(angle) * position.y + offset.x,
-sin(angle) * position.x + cos(angle) * position.y + offset.y, 0, 1);
}`,
attributes: {
position: [
0.5, 0,
0, 0.5,
1, 1]
},
uniforms: {
// the batchId parameter gives the index of the command
color: ({tick}, props, batchId) => [
Math.sin(0.02 * ((0.1 + Math.sin(batchId)) * tick + 3.0 * batchId)),
Math.cos(0.02 * (0.02 * tick + 0.1 * batchId)),
Math.sin(0.02 * ((0.3 + Math.cos(2.0 * batchId)) * tick + 0.8 * batchId)),
1
],
angle: ({tick}) => 0.01 * tick,
offset: regl.prop<Props, 'offset'>('offset')
},
depth: {
enable: false
},
count: 3
})
// Here we register a per-frame callback to draw the whole scene
regl.frame(function () {
regl.clear({
color: [0, 0, 0, 1]
})
// This tells regl to execute the command once for each object
draw([
{ offset: [-1, -1] },
{ offset: [-1, 0] },
{ offset: [-1, 1] },
{ offset: [0, -1] },
{ offset: [0, 0] },
{ offset: [0, 1] },
{ offset: [1, -1] },
{ offset: [1, 0] },
{ offset: [1, 1] }
])
})
``` | /content/code_sandbox/example/typescript/batch.ts | xml | 2016-02-23T00:03:11 | 2024-08-15T22:14:06 | regl | regl-project/regl | 5,194 | 646 |
```xml
/*
* one or more contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright ownership.
*/
import React, {useEffect} from 'react';
import {IncidentsOverlay} from './IncidentsOverlay';
import {incidentsStore} from 'modules/stores/incidents';
import {observer} from 'mobx-react';
import {Transition} from './styled';
import {IncidentsFilter} from './IncidentsFilter';
import {IncidentsTable} from './IncidentsTable';
import {PanelHeader} from 'modules/components/PanelHeader';
type Props = {
setIsInTransition: (isTransitionActive: boolean) => void;
};
const IncidentsWrapper: React.FC<Props> = observer(({setIsInTransition}) => {
useEffect(() => {
incidentsStore.init();
return () => {
incidentsStore.reset();
};
}, []);
if (incidentsStore.incidentsCount === 0) {
return null;
}
return (
<>
<Transition
in={incidentsStore.state.isIncidentBarOpen}
onEnter={() => setIsInTransition(true)}
onEntered={() => setIsInTransition(false)}
onExit={() => setIsInTransition(true)}
onExited={() => setIsInTransition(false)}
mountOnEnter
unmountOnExit
timeout={400}
>
<IncidentsOverlay>
<PanelHeader
title="Incidents View"
count={incidentsStore.filteredIncidents.length}
size="sm"
>
<IncidentsFilter />
</PanelHeader>
<IncidentsTable />
</IncidentsOverlay>
</Transition>
</>
);
});
export {IncidentsWrapper};
``` | /content/code_sandbox/operate/client/src/App/ProcessInstance/IncidentsWrapper/index.tsx | xml | 2016-03-20T03:38:04 | 2024-08-16T19:59:58 | camunda | camunda/camunda | 3,172 | 357 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="path_to_url"
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:id="@+id/tv_day_num"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:textColor="#000000"
android:textSize="15sp" />
<TextView
android:id="@+id/tv_day_new_count"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:layout_alignParentLeft="true"
android:layout_marginBottom="1dp"
android:layout_marginLeft="2dp"
android:textColor="@color/gray_bbbbbb"
android:textSize="10sp"
android:visibility="gone" />
<ImageView
android:id="@+id/image_is_fav"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:layout_alignParentRight="true"
android:layout_marginBottom="1dp"
android:layout_marginRight="1dp"
android:src="@mipmap/ic_like_normal"
android:visibility="gone" />
</RelativeLayout>
``` | /content/code_sandbox/sample/src/main/res/layout/griditem_custom_calendar_item.xml | xml | 2016-08-10T11:04:33 | 2024-07-22T02:46:12 | CalendarListView | Kelin-Hong/CalendarListView | 1,067 | 301 |
```xml
import path from 'path';
import { LocalFileSystemDetector } from '../src';
import { detectFramework } from '../src/detect-framework';
import monorepoManagers from '../src/monorepos/monorepo-managers';
describe('monorepo-managers', () => {
describe.each([
['28-turborepo-with-yarn-workspaces', 'turbo'],
['31-turborepo-in-package-json', 'turbo'],
['22-pnpm', null],
['39-nx-monorepo', 'nx'],
['40-rush-monorepo', 'rush'],
])('with detectFramework', (fixturePath, frameworkSlug) => {
const testName = frameworkSlug
? `should detect a ${frameworkSlug} workspace for ${fixturePath}`
: `should not detect a monorepo manager for ${fixturePath}`;
it(testName, async () => {
const fixture = path.join(__dirname, 'fixtures', fixturePath);
const fs = new LocalFileSystemDetector(fixture);
const result = await detectFramework({
fs,
frameworkList: monorepoManagers,
});
expect(result).toBe(frameworkSlug);
});
});
});
``` | /content/code_sandbox/packages/fs-detectors/test/unit.detect-monorepo-managers.test.ts | xml | 2016-09-09T01:12:08 | 2024-08-16T17:39:45 | vercel | vercel/vercel | 12,545 | 254 |
```xml
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
import classNames from "classnames";
import * as React from "react";
import { AbstractPureComponent, Alignment, Classes } from "../../common";
import { DISPLAYNAME_PREFIX, type HTMLDivProps, type Props } from "../../common/props";
export interface NavbarGroupProps extends Props, HTMLDivProps {
/**
* The side of the navbar on which the group should appear.
* The `Alignment` enum provides constants for these values.
*
* @default Alignment.LEFT
*/
align?: Alignment;
children?: React.ReactNode;
}
// this component is simple enough that tests would be purely tautological.
/* istanbul ignore next */
export class NavbarGroup extends AbstractPureComponent<NavbarGroupProps> {
public static displayName = `${DISPLAYNAME_PREFIX}.NavbarGroup`;
public static defaultProps: NavbarGroupProps = {
align: Alignment.LEFT,
};
public render() {
const { align, children, className, ...htmlProps } = this.props;
const classes = classNames(Classes.NAVBAR_GROUP, Classes.alignmentClass(align), className);
return (
<div className={classes} {...htmlProps}>
{children}
</div>
);
}
}
``` | /content/code_sandbox/packages/core/src/components/navbar/navbarGroup.tsx | xml | 2016-10-25T21:17:50 | 2024-08-16T15:14:48 | blueprint | palantir/blueprint | 20,593 | 288 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="colorPrimary">#3F51B5</color>
<color name="colorPrimaryDark">#303F9F</color>
<color name="colorAccent">#FF4081</color>
<color name="whileblack">#f9f9f9</color>
</resources>
``` | /content/code_sandbox/SqliteDBAndroidExample/app/src/main/res/values/colors.xml | xml | 2016-09-26T16:36:28 | 2024-08-13T08:59:01 | AndroidTutorialForBeginners | hussien89aa/AndroidTutorialForBeginners | 4,360 | 84 |
```xml
import { SPSecurityInfo } from "../../SPSecurityService";
import { ISelectedPermission } from "../ISpSecurityWebPartProps";
export interface ISpSecurityState {
securityInfo: SPSecurityInfo;
// permission: string;
selectedPermissions: ISelectedPermission[];
showUserPanel: boolean;
showListPanel: boolean;
showPermissionsPanel: boolean;
showEmail: boolean; //0 show name, 1 show email
securityInfoLoaded: boolean;
errors: Array<string>;
}
``` | /content/code_sandbox/samples/react-securitygrid/src/webparts/spSecurity/components/ISpSecurityState.ts | xml | 2016-08-30T17:21:43 | 2024-08-16T18:41:32 | sp-dev-fx-webparts | pnp/sp-dev-fx-webparts | 2,027 | 110 |
```xml
import type { Result } from '../Result/Result'
export interface SyncUseCaseInterface<T> {
execute(...args: any[]): Result<T>
}
``` | /content/code_sandbox/packages/docs-core/lib/Domain/UseCase/SyncUseCaseInterface.ts | xml | 2016-06-08T11:16:51 | 2024-08-16T14:14:27 | WebClients | ProtonMail/WebClients | 4,300 | 32 |
```xml
import {
ChangeDetectionStrategy,
Component,
ViewEncapsulation,
} from '@angular/core';
import { CalendarEvent, CalendarView } from 'angular-calendar';
import { Subject } from 'rxjs';
import { colors } from '../demo-utils/colors';
@Component({
selector: 'mwl-demo-component',
changeDetection: ChangeDetectionStrategy.OnPush,
templateUrl: 'template.html',
styleUrls: ['./styles.scss'],
encapsulation: ViewEncapsulation.None,
})
export class DemoComponent {
view: CalendarView = CalendarView.Month;
viewDate = new Date();
events: CalendarEvent[] = [];
refresh = new Subject<void>();
addEvent(date: Date): void {
this.events.push({
start: date,
title: 'New event',
color: colors.red,
});
this.refresh.next();
}
}
``` | /content/code_sandbox/projects/demos/app/demo-modules/context-menu/component.ts | xml | 2016-04-26T15:19:33 | 2024-08-08T14:23:40 | angular-calendar | mattlewis92/angular-calendar | 2,717 | 177 |
```xml
import { timeRangeDefaultProps as defaults } from '@nivo/calendar'
import { themeProperty, getLegendsProps, groupProperties } from '../../../lib/componentProperties'
import { chartDimensions, isInteractive } from '../../../lib/chart-properties'
import { ChartProperty, Flavor } from '../../../types'
const allFlavors: Flavor[] = ['svg']
const props: ChartProperty[] = [
{
key: 'data',
group: 'Base',
help: 'Chart data.',
flavors: allFlavors,
description: `
Chart data, which must conform to this structure:
\`\`\`
Array<{
day: string, // format must be YYYY-MM-DD
value: number
}>
\`\`\`
You can also add arbitrary data to this structure
to be used in tooltips or event handlers.
`,
type: 'object[]',
required: true,
},
{
key: 'from',
group: 'Base',
flavors: allFlavors,
help: 'start date',
type: 'string | Date',
required: false,
},
{
key: 'to',
group: 'Base',
help: 'end date',
flavors: allFlavors,
type: 'string | Date',
required: false,
},
...chartDimensions(allFlavors),
{
key: 'direction',
help: 'defines calendar layout direction.',
flavors: allFlavors,
type: 'string',
required: false,
defaultValue: defaults.direction,
group: 'Base',
control: {
type: 'radio',
choices: [
{ label: 'horizontal', value: 'horizontal' },
{ label: 'vertical', value: 'vertical' },
],
},
},
{
key: 'align',
help: 'defines how calendar should be aligned inside chart container.',
flavors: allFlavors,
type: 'string',
required: false,
defaultValue: defaults.align,
group: 'Base',
control: {
type: 'boxAnchor',
},
},
{
key: 'minValue',
help: 'Minimum value.',
flavors: allFlavors,
description: `
Minimum value. If 'auto', will pick the lowest value
in the provided data set.
Should be overriden if your data set does not contain
desired lower bound value.
`,
required: false,
defaultValue: defaults.minValue,
type: `number | 'auto'`,
group: 'Base',
control: {
type: 'switchableRange',
disabledValue: 'auto',
defaultValue: 0,
min: -300,
max: 300,
},
},
{
key: 'maxValue',
help: 'Maximum value.',
flavors: allFlavors,
description: `
Maximum value. If 'auto', will pick the highest value
in the provided data set.
Should be overriden if your data set does not contain
desired higher bound value.
`,
required: false,
defaultValue: defaults.maxValue,
type: `number | 'auto'`,
group: 'Base',
control: {
type: 'switchableRange',
disabledValue: 'auto',
defaultValue: 100,
min: 0,
max: 600,
},
},
themeProperty(['svg']),
{
key: 'colors',
group: 'Style',
flavors: allFlavors,
help: 'Cell colors.',
description: `
An array of colors to be used in conjunction with
\`domain\` to compute days' color.
It applies to days having a value defined, otherwise,
\`emptyColor\` will be used.
`,
type: 'string[]',
required: false,
defaultValue: defaults.colors,
},
{
key: 'emptyColor',
help: 'color to use to fill days without available value.',
flavors: allFlavors,
type: 'string',
required: false,
defaultValue: defaults.emptyColor,
control: { type: 'colorPicker' },
group: 'Style',
},
// Months
{
key: 'monthLegend',
help: `can be used to customize months label, returns abbreviated month name (english) by default. This can be used to use a different language`,
flavors: allFlavors,
type: '(year: number, month: number, date: Date) => string | number',
required: false,
group: 'Months',
},
{
key: 'monthLegendPosition',
help: 'defines month legends position.',
flavors: allFlavors,
type: `'before' | 'after'`,
required: false,
defaultValue: defaults.monthLegendPosition,
group: 'Months',
control: {
type: 'radio',
choices: [
{ label: 'before', value: 'before' },
{ label: 'after', value: 'after' },
],
},
},
{
key: 'monthLegendOffset',
help: 'define offset from month edge to its label.',
flavors: allFlavors,
type: 'number',
required: false,
defaultValue: defaults.monthLegendOffset,
group: 'Months',
control: {
type: 'range',
unit: 'px',
min: 0,
max: 36,
},
},
// Weekday
{
key: 'weekdayLegendOffset',
help: 'define offset from weekday edge to its label.',
flavors: allFlavors,
type: 'number',
required: false,
defaultValue: defaults.weekdayLegendOffset,
group: 'Weekday',
control: {
type: 'range',
unit: 'px',
min: 0,
max: 100,
},
},
{
key: 'weekdayTicks',
help: 'define weekday tickmarks to show',
flavors: allFlavors,
type: '(0 | 1 | 2 | 3 | 4 | 5 | 6)[]',
required: false,
defaultValue: [1, 3, 5],
group: 'Weekday',
description: `
Array of weekday tickmarks to display:\n
0 = Sunday\n
1 = Monday\n
2 = Tuesday\n
3 = Wednesday\n
4 = Thursday\n
5 = Friday\n
6 = Saturday\n
`,
},
{
key: 'firstWeekday',
help: `define the first weekday: 'sunday', 'monday', etc.`,
flavors: allFlavors,
type: 'Weekday',
required: false,
defaultValue: defaults.firstWeekday,
group: 'Weekday',
control: {
type: 'radio',
choices: [
{ label: `'sunday'`, value: 'sunday' },
{ label: `'monday'`, value: 'monday' },
],
},
},
// Days
{
key: 'square',
help: 'force day cell into square shape',
flavors: allFlavors,
type: 'boolean',
required: false,
defaultValue: defaults.square,
control: { type: 'switch' },
group: 'Days',
},
{
key: 'dayRadius',
help: 'define border radius of each day cell.',
flavors: allFlavors,
type: 'number',
required: false,
defaultValue: defaults.dayRadius,
group: 'Days',
control: {
type: 'range',
unit: 'px',
min: 0,
max: 20,
},
},
{
key: 'daySpacing',
help: 'define spacing between each day cell.',
flavors: allFlavors,
type: 'number',
required: false,
defaultValue: defaults.daySpacing,
group: 'Days',
control: {
type: 'range',
unit: 'px',
min: 0,
max: 20,
},
},
{
key: 'dayBorderWidth',
help: 'width of days border.',
flavors: allFlavors,
type: 'number',
required: false,
defaultValue: defaults.dayBorderWidth,
control: { type: 'lineWidth' },
group: 'Days',
},
{
key: 'dayBorderColor',
help: 'color to use for days border.',
flavors: allFlavors,
type: 'string',
required: false,
defaultValue: defaults.dayBorderColor,
control: { type: 'colorPicker' },
group: 'Days',
},
isInteractive({
flavors: ['svg'],
defaultValue: defaults.isInteractive,
}),
{
key: 'onClick',
group: 'Interactivity',
flavors: allFlavors,
help: 'onClick handler, it receives clicked day data and mouse event.',
type: '(day, event) => void',
required: false,
},
{
key: 'tooltip',
group: 'Interactivity',
flavors: allFlavors,
type: 'Function',
required: false,
help: 'Custom tooltip component.',
description: `
A function allowing complete tooltip customisation, it must return a valid HTML
element and will receive the following data:
\`\`\`
{
day: string,
date: {Date},
value: number,
color: string,
coordinates: {
x: number,
y: number,
},
height: number
width: number
}
\`\`\`
You can also customize the tooltip style
using the \`theme.tooltip\` object.
`,
},
{
key: 'custom tooltip example',
help: 'Showcase custom tooltip.',
flavors: allFlavors,
type: 'boolean',
required: false,
control: { type: 'switch' },
group: 'Interactivity',
},
{
key: 'legends',
flavors: ['svg'],
type: 'LegendProps[]',
help: `Optional chart's legends.`,
group: 'Legends',
required: false,
control: {
type: 'array',
props: getLegendsProps(['svg']),
shouldCreate: true,
addLabel: 'add legend',
shouldRemove: true,
getItemTitle: (index, legend: any) =>
`legend[${index}]: ${legend.anchor}, ${legend.direction}`,
defaults: {
anchor: 'bottom-right',
direction: 'row',
justify: false,
itemCount: 4,
itemWidth: 42,
itemHeight: 36,
itemsSpacing: 14,
itemDirection: 'right-to-left',
translateX: -85,
translateY: -240,
symbolSize: 20,
onClick: (data: any) => {
console.log(JSON.stringify(data, null, ' '))
},
},
},
},
]
export const groups = groupProperties(props)
``` | /content/code_sandbox/website/src/data/components/time-range/props.ts | xml | 2016-04-16T03:27:56 | 2024-08-16T03:38:37 | nivo | plouc/nivo | 13,010 | 2,405 |
```xml
import {GL} from '@luma.gl/constants';
import {Buffer, isWebGL} from '@luma.gl/webgl-legacy';
import test from 'tape-promise/tape';
import {fixture} from 'test/setup';
test('Buffer#constructor/delete', (t) => {
const {gl} = fixture;
t.ok(isWebGL(gl), 'Created gl context');
// @ts-expect-error
t.throws(() => new Buffer(), 'Buffer throws on missing gl context');
const buffer = new Buffer(gl, {target: GL.ARRAY_BUFFER});
t.ok(buffer instanceof Buffer, 'Buffer construction successful');
buffer.destroy();
t.ok(buffer instanceof Buffer, 'Buffer delete successful');
buffer.destroy();
t.ok(buffer instanceof Buffer, 'Buffer repeated delete successful');
t.end();
});
test('Buffer#constructor offset and size', (t) => {
const {gl2} = fixture;
if (!gl2) {
t.comment('WebGL2 not available, skipping tests');
t.end();
return;
}
const data = new Float32Array([1, 2, 3]);
let buffer = new Buffer(gl2, {data, offset: 8});
let receivedData = buffer.getData();
let expectedData = new Float32Array([0, 0, 1, 2, 3]);
t.deepEqual(receivedData, expectedData, 'Buffer constructor offsets data');
t.equal(buffer.byteLength, expectedData.byteLength, 'Buffer byteLength set properly');
t.equal(buffer.bytesUsed, expectedData.byteLength, 'Buffer byteLength set properly');
buffer = new Buffer(gl2, {data, byteLength: data.byteLength + 12});
receivedData = buffer.getData();
expectedData = new Float32Array([1, 2, 3, 0, 0, 0]);
t.deepEqual(receivedData, expectedData, 'Buffer constructor sets buffer byteLength');
t.equal(buffer.byteLength, expectedData.byteLength, 'Buffer byteLength set properly');
t.equal(buffer.bytesUsed, expectedData.byteLength, 'Buffer byteLength set properly');
buffer = new Buffer(gl2, {data, offset: 8, byteLength: data.byteLength + 12});
receivedData = buffer.getData();
expectedData = new Float32Array([0, 0, 1, 2, 3, 0]);
t.deepEqual(
receivedData,
expectedData,
'Buffer constructor sets buffer byteLength and offsets data'
);
t.equal(buffer.byteLength, expectedData.byteLength, 'Buffer byteLength set properly');
t.equal(buffer.bytesUsed, expectedData.byteLength, 'Buffer byteLength set properly');
t.end();
});
test('Buffer#bind/unbind', (t) => {
const {gl} = fixture;
const buffer = new Buffer(gl, {target: GL.ARRAY_BUFFER}).bind().unbind();
t.ok(buffer instanceof Buffer, 'Buffer bind/unbind successful');
buffer.destroy();
t.end();
});
test('Buffer#bind/unbind with index', (t) => {
const {gl2} = fixture;
if (!gl2) {
t.comment('WebGL2 not available, skipping tests');
t.end();
return;
}
const buffer = new Buffer(gl2, {target: GL.UNIFORM_BUFFER, index: 0}).bind().unbind();
t.ok(buffer instanceof Buffer, 'Buffer bind/unbind with index successful');
buffer.destroy();
t.end();
});
test('Buffer#construction', (t) => {
const {gl} = fixture;
let buffer;
buffer = new Buffer(gl, {target: GL.ARRAY_BUFFER, data: new Float32Array([1, 2, 3])})
.bind()
.unbind();
t.ok(buffer instanceof Buffer, 'Buffer(ARRAY_BUFFER) successful');
buffer.destroy();
// TODO - buffer could check for integer ELEMENT_ARRAY_BUFFER types
buffer = new Buffer(gl, {
target: GL.ELEMENT_ARRAY_BUFFER,
data: new Float32Array([1, 2, 3])
})
.bind()
.unbind();
t.ok(buffer instanceof Buffer, 'Buffer(ELEMENT_ARRAY_BUFFER) successful');
buffer.destroy();
t.end();
});
test('Buffer#initialize/subData', (t) => {
const {gl} = fixture;
let buffer;
buffer = new Buffer(gl, {target: GL.ARRAY_BUFFER})
.initialize({data: new Float32Array([1, 2, 3])})
.bind()
.unbind();
t.ok(buffer instanceof Buffer, 'Buffer.subData(ARRAY_BUFFER) successful');
buffer.destroy();
buffer = new Buffer(gl, {target: GL.ARRAY_BUFFER, data: new Float32Array([1, 2, 3])})
.initialize({data: new Float32Array([1, 2, 3])})
.bind()
.unbind();
t.ok(buffer instanceof Buffer, 'Buffer.subData(ARRAY_BUFFER) successful');
buffer.destroy();
buffer = new Buffer(gl, {target: GL.ELEMENT_ARRAY_BUFFER})
.initialize({data: new Float32Array([1, 2, 3])})
.bind()
.unbind();
t.ok(buffer instanceof Buffer, 'buffer.initialize(ELEMENT_ARRAY_BUFFER) successful');
buffer.destroy();
buffer = new Buffer(gl, {target: GL.ELEMENT_ARRAY_BUFFER})
.initialize({data: new Float32Array([1, 2, 3])})
.subData({data: new Float32Array([1, 1, 1])})
.bind()
.unbind();
t.ok(buffer instanceof Buffer, 'Buffer.subData(ARRAY_ELEMENT_BUFFER) successful');
buffer.destroy();
t.end();
});
test('Buffer#copyData', (t) => {
const {gl2} = fixture;
if (!gl2) {
t.comment('WebGL2 not available, skipping tests');
t.end();
return;
}
const sourceData = new Float32Array([1, 2, 3]);
const sourceBuffer = new Buffer(gl2, {data: sourceData});
const destinationData = new Float32Array([4, 5, 6]);
const destinationBuffer = new Buffer(gl2, {data: destinationData});
let receivedData = destinationBuffer.getData();
let expectedData = new Float32Array([4, 5, 6]);
t.deepEqual(receivedData, expectedData, 'Buffer.getData: default parameters successful');
destinationBuffer.copyData({sourceBuffer, size: 2 * Float32Array.BYTES_PER_ELEMENT});
receivedData = destinationBuffer.getData();
expectedData = new Float32Array([1, 2, 6]);
t.deepEqual(receivedData, expectedData, 'Buffer.copyData: with size successful');
destinationBuffer.copyData({
sourceBuffer,
readOffset: Float32Array.BYTES_PER_ELEMENT,
writeOffset: 2 * Float32Array.BYTES_PER_ELEMENT,
size: Float32Array.BYTES_PER_ELEMENT
});
receivedData = destinationBuffer.getData();
expectedData = new Float32Array([1, 2, 2]);
t.deepEqual(receivedData, expectedData, 'Buffer.copyData: with size and offsets successful');
t.end();
});
test('Buffer#getData', (t) => {
const {gl2} = fixture;
if (!gl2) {
t.comment('WebGL2 not available, skipping tests');
t.end();
return;
}
let data = new Float32Array([1, 2, 3]);
let buffer = new Buffer(gl2, {data});
let receivedData = buffer.getData();
let expectedData = new Float32Array([1, 2, 3]);
t.deepEqual(data, receivedData, 'Buffer.getData: default parameters successful');
receivedData = buffer.getData({
dstData: new Float32Array(2),
srcByteOffset: Float32Array.BYTES_PER_ELEMENT
});
expectedData = new Float32Array([2, 3]);
t.deepEqual(expectedData, receivedData, 'Buffer.getData: with \'dstData\' parameter successful');
receivedData = buffer.getData({
srcByteOffset: Float32Array.BYTES_PER_ELEMENT,
dstOffset: 2
});
expectedData = new Float32Array([0, 0, 2, 3]);
t.deepEqual(expectedData, receivedData, 'Buffer.getData: with src/dst offsets successful');
// NOTE: when source and dst offsets are specified, 'length' needs to be set so that
// source buffer access is not outof bounds, otherwise 'getBufferSubData' will throw exception.
receivedData = buffer.getData({
srcByteOffset: Float32Array.BYTES_PER_ELEMENT * 2,
dstOffset: 1,
length: 1
});
expectedData = new Float32Array([0, 3]);
t.deepEqual(
expectedData,
receivedData,
'Buffer.getData: with src/dst offsets and length successful'
);
// @ts-expect-error
data = new Uint8Array([128, 255, 1]);
buffer = new Buffer(gl2, {data});
receivedData = buffer.getData();
t.deepEqual(data, receivedData, 'Buffer.getData: Uint8Array + default parameters successful');
t.end();
});
test('Buffer#getElementCount', (t) => {
const {gl} = fixture;
let vertexCount;
const buffer1 = new Buffer(gl, {data: new Float32Array([1, 2, 3])});
vertexCount = buffer1.getElementCount();
t.equal(vertexCount, 3, 'Vertex count should match');
let buffer2 = new Buffer(gl, {data: new Int32Array([1, 2, 3, 4]), accessor: {divisor: 1}});
vertexCount = buffer2.getElementCount();
t.equal(vertexCount, 4, 'Vertex count should match');
const {byteLength, usage, accessor} = buffer1;
buffer2 = new Buffer(gl, {byteLength, usage, accessor});
vertexCount = buffer2.getElementCount();
t.equal(vertexCount, 3, 'Vertex count should match');
t.end();
});
test('Buffer#reallocate', (t) => {
const {gl} = fixture;
const buffer = new Buffer(gl, {byteLength: 100});
t.equal(buffer.byteLength, 100, 'byteLength should match');
t.equal(buffer.bytesUsed, 100, 'bytesUsed should match');
let didRealloc = buffer.reallocate(90);
t.equal(didRealloc, false, 'Should not reallocate');
t.equal(buffer.byteLength, 100, 'byteLength should be unchanged');
t.equal(buffer.bytesUsed, 90, 'bytesUsed should have changed');
didRealloc = buffer.reallocate(110);
t.equal(didRealloc, true, 'Should reallocate');
t.equal(buffer.byteLength, 110, 'byteLength should have changed');
t.equal(buffer.byteLength, 110, 'bytesUsed should have changed');
t.end();
});
``` | /content/code_sandbox/wip/modules-wip/webgl-legacy/test/classic/buffer.spec.ts | xml | 2016-01-25T09:41:59 | 2024-08-16T10:03:05 | luma.gl | visgl/luma.gl | 2,280 | 2,414 |
```xml
///
///
///
/// path_to_url
///
/// Unless required by applicable law or agreed to in writing, software
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
///
import { RuleNodeType } from '@shared/models/rule-node.models';
export enum ComponentType {
ENRICHMENT = 'ENRICHMENT',
FILTER = 'FILTER',
TRANSFORMATION = 'TRANSFORMATION',
ACTION = 'ACTION',
EXTERNAL = 'EXTERNAL',
FLOW = 'FLOW'
}
export enum ComponentScope {
SYSTEM = 'SYSTEM',
TENANT = 'TENANT'
}
export enum ComponentClusteringMode {
USER_PREFERENCE = 'USER_PREFERENCE',
ENABLED = 'ENABLED',
SINGLETON = 'SINGLETON'
}
export interface ComponentDescriptor {
type: ComponentType | RuleNodeType;
scope?: ComponentScope;
clusteringMode: ComponentClusteringMode;
hasQueueName?: boolean;
name: string;
clazz: string;
configurationDescriptor?: any;
actions?: string;
}
``` | /content/code_sandbox/ui-ngx/src/app/shared/models/component-descriptor.models.ts | xml | 2016-12-01T09:33:30 | 2024-08-16T19:58:25 | thingsboard | thingsboard/thingsboard | 16,820 | 220 |
```xml
<epp xmlns="urn:ietf:params:xml:ns:epp-1.0">
<response>
<result code="1000">
<msg>Command completed successfully</msg>
</result>
<resData>
<domain:infData
xmlns:domain="urn:ietf:params:xml:ns:domain-1.0">
<domain:name>%DOMAIN%</domain:name>
<domain:roid>8-TLD</domain:roid>
<domain:status s="inactive"/>
<domain:registrant>jd1234</domain:registrant>
<domain:contact type="tech">sh8013</domain:contact>
<domain:contact type="admin">sh8013</domain:contact>
<domain:clID>NewRegistrar</domain:clID>
<domain:crID>NewRegistrar</domain:crID>
<domain:crDate>2000-06-01T00:02:00Z</domain:crDate>
<domain:upID>NewRegistrar</domain:upID>
<domain:upDate>%UPDATE%</domain:upDate>
<domain:exDate>%EXDATE%</domain:exDate>
<domain:authInfo>
<domain:pw>2fooBAR</domain:pw>
</domain:authInfo>
</domain:infData>
</resData>
<extension>
<rgp:infData xmlns:rgp="urn:ietf:params:xml:ns:rgp-1.0">
<rgp:rgpStatus s="%RGPSTATUS%"/>
</rgp:infData>
</extension>
<trID>
<clTRID>ABC-12345</clTRID>
<svTRID>server-trid</svTRID>
</trID>
</response>
</epp>
``` | /content/code_sandbox/core/src/test/resources/google/registry/flows/domain_info_response_inactive_grace_period.xml | xml | 2016-02-29T20:16:48 | 2024-08-15T19:49:29 | nomulus | google/nomulus | 1,685 | 405 |
```xml
'use strict'
import { update } from 'solc/abi'
import webworkify from 'webworkify'
import compilerInput from './compiler-input'
import { EventManager } from 'remix-lib'
import { default as txHelper } from './txHelper';
import { Source, SourceWithTarget, MessageFromWorker, CompilerState, CompilationResult,
visitContractsCallbackParam, visitContractsCallbackInterface, CompilationError,
gatherImportsCallbackInterface } from './types'
/*
trigger compilationFinished, compilerLoaded, compilationStarted, compilationDuration
*/
export class Compiler {
event: EventManager
state: CompilerState
constructor (public handleImportCall: (fileurl: string, cb: Function) => void) {
this.event = new EventManager()
this.state = {
compileJSON: null,
worker: null,
currentVersion: null,
optimize: false,
evmVersion: null,
language: 'Solidity',
compilationStartTime: null,
target: null,
lastCompilationResult: {
data: null,
source: null
}
}
this.event.register('compilationFinished', (success: boolean, data: CompilationResult, source: SourceWithTarget) => {
if (success && this.state.compilationStartTime) {
this.event.trigger('compilationDuration', [(new Date().getTime()) - this.state.compilationStartTime])
}
this.state.compilationStartTime = null
})
this.event.register('compilationStarted', () => {
this.state.compilationStartTime = new Date().getTime()
})
}
/**
* @dev Setter function for CompilerState's properties (used by IDE)
* @param key key
* @param value value of key in CompilerState
*/
set <K extends keyof CompilerState>(key: K, value: CompilerState[K]) {
this.state[key] = value
}
/**
* @dev Internal function to compile the contract after gathering imports
* @param files source file
* @param missingInputs missing import file path list
*/
internalCompile (files: Source, missingInputs?: string[]): void {
this.gatherImports(files, missingInputs, (error, input) => {
if (error) {
this.state.lastCompilationResult = null
this.event.trigger('compilationFinished', [false, {'error': { formattedMessage: error, severity: 'error' }}, files])
} else if(this.state.compileJSON && input)
this.state.compileJSON(input)
})
}
/**
* @dev Compile source files (used by IDE)
* @param files source files
* @param target target file name (This is passed as it is to IDE)
*/
compile (files: Source, target: string): void {
this.state.target = target
this.event.trigger('compilationStarted', [])
this.internalCompile(files)
}
/**
* @dev Called when compiler is loaded, set current compiler version
* @param version compiler version
*/
onCompilerLoaded (version: string): void {
this.state.currentVersion = version
this.event.trigger('compilerLoaded', [version])
}
/**
* @dev Called when compiler is loaded internally (without worker)
*/
onInternalCompilerLoaded (): void {
if (this.state.worker === null) {
const compiler: any = typeof (window) === 'undefined' ? require('solc') : require('solc/wrapper')(window['Module'])
this.state.compileJSON = (source: SourceWithTarget) => {
let missingInputs: string[] = []
const missingInputsCallback = (path: string) => {
missingInputs.push(path)
return { error: 'Deferred import' }
}
let result: CompilationResult = {}
try {
if(source && source.sources) {
const input = compilerInput(source.sources, {optimize: this.state.optimize, evmVersion: this.state.evmVersion, language: this.state.language})
result = JSON.parse(compiler.compile(input, { import: missingInputsCallback }))
}
} catch (exception) {
result = { error: { formattedMessage: 'Uncaught JavaScript exception:\n' + exception, severity: 'error', mode: 'panic' } }
}
this.onCompilationFinished(result, missingInputs, source)
}
this.onCompilerLoaded(compiler.version())
}
}
/**
* @dev Called when compilation is finished
* @param data compilation result data
* @param missingInputs missing imports
* @param source Source
*/
onCompilationFinished (data: CompilationResult, missingInputs?: string[], source?: SourceWithTarget): void {
let noFatalErrors: boolean = true // ie warnings are ok
const checkIfFatalError = (error: CompilationError) => {
// Ignore warnings and the 'Deferred import' error as those are generated by us as a workaround
const isValidError = (error.message && error.message.includes('Deferred import')) ? false : error.severity !== 'warning'
if(isValidError) noFatalErrors = false
}
if (data.error) checkIfFatalError(data.error)
if (data.errors) data.errors.forEach((err) => checkIfFatalError(err))
if (!noFatalErrors) {
// There are fatal errors, abort here
this.state.lastCompilationResult = null
this.event.trigger('compilationFinished', [false, data, source])
} else if (missingInputs !== undefined && missingInputs.length > 0 && source && source.sources) {
// try compiling again with the new set of inputs
this.internalCompile(source.sources, missingInputs)
} else {
data = this.updateInterface(data)
if(source)
{
source.target = this.state.target;
this.state.lastCompilationResult = {
data: data,
source: source
}
}
this.event.trigger('compilationFinished', [true, data, source])
}
}
/**
* @dev Load compiler using given URL (used by IDE)
* @param usingWorker if true, load compiler using worker
* @param url URL to load compiler from
*/
loadVersion (usingWorker: boolean, url: string): void {
console.log('Loading ' + url + ' ' + (usingWorker ? 'with worker' : 'without worker'))
this.event.trigger('loadingCompiler', [url, usingWorker])
if (this.state.worker) {
this.state.worker.terminate()
this.state.worker = null
}
if (usingWorker) {
this.loadWorker(url)
} else {
this.loadInternal(url)
}
}
/**
* @dev Load compiler using 'script' element (without worker)
* @param url URL to load compiler from
*/
loadInternal (url: string): void {
delete window['Module']
// NOTE: workaround some browsers?
window['Module'] = undefined
// Set a safe fallback until the new one is loaded
this.state.compileJSON = (source: SourceWithTarget) => {
this.onCompilationFinished({ error: { formattedMessage: 'Compiler not yet loaded.' } })
}
let newScript: HTMLScriptElement = document.createElement('script')
newScript.type = 'text/javascript'
newScript.src = url
document.getElementsByTagName('head')[0].appendChild(newScript)
const check: number = window.setInterval(() => {
if (!window['Module']) {
return
}
window.clearInterval(check)
this.onInternalCompilerLoaded()
}, 200)
}
/**
* @dev Load compiler using web worker
* @param url URL to load compiler from
*/
loadWorker (url: string): void {
this.state.worker = webworkify(require('./compiler-worker.js').default)
let jobs: Record<'sources', SourceWithTarget> [] = []
this.state.worker.addEventListener('message', (msg: Record <'data', MessageFromWorker>) => {
const data: MessageFromWorker = msg.data
switch (data.cmd) {
case 'versionLoaded':
if(data.data) this.onCompilerLoaded(data.data)
break
case 'compiled':
let result: CompilationResult
if(data.data && data.job !== undefined && data.job >= 0) {
try {
result = JSON.parse(data.data)
} catch (exception) {
result = { error : { formattedMessage: 'Invalid JSON output from the compiler: ' + exception }}
}
let sources: SourceWithTarget = {}
if (data.job in jobs !== undefined) {
sources = jobs[data.job].sources
delete jobs[data.job]
}
this.onCompilationFinished(result, data.missingInputs, sources)
}
break
}
})
this.state.worker.addEventListener('error', (msg: Record <'data', MessageFromWorker>) => {
this.onCompilationFinished({ error: { formattedMessage: 'Worker error: ' + msg.data }})
})
this.state.compileJSON = (source: SourceWithTarget) => {
if(source && source.sources) {
jobs.push({sources: source})
this.state.worker.postMessage({
cmd: 'compile',
job: jobs.length - 1,
input: compilerInput(source.sources, {
optimize: this.state.optimize,
evmVersion: this.state.evmVersion,
language: this.state.language
})
})
}
}
this.state.worker.postMessage({
cmd: 'loadVersion',
data: url
})
}
/**
* @dev Gather imports for compilation
* @param files file sources
* @param importHints import file list
* @param cb callback
*/
gatherImports (files: Source, importHints?: string[], cb?: gatherImportsCallbackInterface): void {
importHints = importHints || []
// FIXME: This will only match imports if the file begins with one '.'
// It should tokenize by lines and check each.
const importRegex: RegExp = /^\s*import\s*[\'\"]([^\'\"]+)[\'\"];/g
for (const fileName in files) {
let match: RegExpExecArray | null
while ((match = importRegex.exec(files[fileName].content))) {
let importFilePath = match[1]
if (importFilePath.startsWith('./')) {
const path: RegExpExecArray | null = /(.*\/).*/.exec(fileName)
importFilePath = path ? importFilePath.replace('./', path[1]) : importFilePath.slice(2)
}
if (!importHints.includes(importFilePath)) importHints.push(importFilePath)
}
}
while (importHints.length > 0) {
const m: string = importHints.pop() as string
if (m && m in files) continue
if (this.handleImportCall) {
this.handleImportCall(m, (err, content: string) => {
if (err && cb) cb(err)
else {
files[m] = { content }
this.gatherImports(files, importHints, cb)
}
})
}
return
}
if(cb)
cb(null, { 'sources': files })
}
/**
* @dev Truncate version string
* @param version version
*/
truncateVersion (version: string): string {
const tmp: RegExpExecArray | null = /^(\d+.\d+.\d+)/.exec(version)
return tmp ? tmp[1] : version
}
/**
* @dev Update ABI according to current compiler version
* @param data Compilation result
*/
updateInterface (data: CompilationResult) : CompilationResult {
txHelper.visitContracts(data.contracts, (contract : visitContractsCallbackParam) => {
if (!contract.object.abi) contract.object.abi = []
if (this.state.language === 'Yul' && contract.object.abi.length === 0) {
// yul compiler does not return any abi,
// we default to accept the fallback function (which expect raw data as argument).
contract.object.abi.push({
'payable': true,
'stateMutability': 'payable',
'type': 'fallback'
})
}
if(data && data.contracts && this.state.currentVersion)
data.contracts[contract.file][contract.name].abi = update(this.truncateVersion(this.state.currentVersion), contract.object.abi)
})
return data
}
/**
* @dev Get contract obj of the given contract name from last compilation result.
* @param name contract name
*/
getContract (name: string): Record<string, any> | null {
if (this.state.lastCompilationResult && this.state.lastCompilationResult.data && this.state.lastCompilationResult.data.contracts) {
return txHelper.getContract(name, this.state.lastCompilationResult.data.contracts)
}
return null
}
/**
* @dev Call the given callback for all the contracts from last compilation result
* @param cb callback
*/
visitContracts (cb: visitContractsCallbackInterface) : void | null {
if (this.state.lastCompilationResult && this.state.lastCompilationResult.data && this.state.lastCompilationResult.data.contracts) {
return txHelper.visitContracts(this.state.lastCompilationResult.data.contracts, cb)
}
return null
}
/**
* @dev Get the compiled contracts data from last compilation result
*/
getContracts () : CompilationResult['contracts'] | null {
if (this.state.lastCompilationResult && this.state.lastCompilationResult.data && this.state.lastCompilationResult.data.contracts) {
return this.state.lastCompilationResult.data.contracts
}
return null
}
/**
* @dev Get sources from last compilation result
*/
getSources () : Source | null | undefined {
if (this.state.lastCompilationResult && this.state.lastCompilationResult.source) {
return this.state.lastCompilationResult.source.sources
}
return null
}
/**
* @dev Get sources of passed file name from last compilation result
* @param fileName file name
*/
getSource (fileName: string) : Source['filename'] | null {
if (this.state.lastCompilationResult && this.state.lastCompilationResult.source && this.state.lastCompilationResult.source.sources) {
return this.state.lastCompilationResult.source.sources[fileName]
}
return null
}
/**
* @dev Get source name at passed index from last compilation result
* @param index - index of the source
*/
getSourceName (index: number): string | null {
if (this.state.lastCompilationResult && this.state.lastCompilationResult.data && this.state.lastCompilationResult.data.sources) {
return Object.keys(this.state.lastCompilationResult.data.sources)[index]
}
return null
}
}
``` | /content/code_sandbox/remix-solidity/src/compiler/compiler.ts | xml | 2016-04-11T09:05:03 | 2024-08-12T19:22:17 | remix | ethereum/remix | 1,177 | 3,191 |
```xml
import { expect } from 'chai';
export default ($) => {
describe('Nested Form isValid', () => {
it('$A isValid should be false', () => expect($.$A.isValid).to.be.false);
it('$R isValid should be true', () => expect($.$R.isValid).to.be.true);
it('$S isValid should be false', () => expect($.$S.isValid).to.be.false);
it('$U isValid should be false', () => expect($.$U.isValid).to.be.false);
});
};
``` | /content/code_sandbox/tests/computed/nested.isValid.ts | xml | 2016-06-20T22:10:41 | 2024-08-10T13:14:33 | mobx-react-form | foxhound87/mobx-react-form | 1,093 | 111 |
```xml
import { IContext } from '../../connectionResolver';
import { sendCoreMessage } from '../../messageBroker';
import { IGrantResponse } from '../../models/definitions/grant';
export default {
async __resolveReference({ _id }, { models }: IContext) {
return models.Responses.findOne({ _id });
},
async user(
{ userId }: { _id: string } & IGrantResponse,
{},
{ subdomain }: IContext
) {
if (!userId) {
return null;
}
const user = await sendCoreMessage({
subdomain,
action: 'users.findOne',
data: {
_id: { $in: userId }
},
isRPC: true,
defaultValue: null
});
return user;
}
};
``` | /content/code_sandbox/packages/plugin-grants-api/src/graphql/customResolvers/response.ts | xml | 2016-11-11T06:54:50 | 2024-08-16T10:26:06 | erxes | erxes/erxes | 3,479 | 167 |
```xml
import { Button } from '~/ui';
import { Container } from './Container';
export function Hero() {
return (
<Container className="pb-36 pt-20 text-center lg:pt-32">
<h1 className="font-display mx-auto max-w-4xl text-5xl font-medium tracking-tight text-slate-900 sm:text-7xl">
Resume review{' '}
<span className="text-primary-500 relative whitespace-nowrap">
<svg
aria-hidden="true"
className="absolute top-2/3 left-0 h-[0.58em] w-full fill-blue-300/70"
preserveAspectRatio="none"
viewBox="0 0 418 42">
<path d="M203.371.916c-26.013-2.078-76.686 1.963-124.73 9.946L67.3 12.749C35.421 18.062 18.2 21.766 6.004 25.934 1.244 27.561.828 27.778.874 28.61c.07 1.214.828 1.121 9.595-1.176 9.072-2.377 17.15-3.92 39.246-7.496C123.565 7.986 157.869 4.492 195.942 5.046c7.461.108 19.25 1.696 19.17 2.582-.107 1.183-7.874 4.31-25.75 10.366-21.992 7.45-35.43 12.534-36.701 13.884-2.173 2.308-.202 4.407 4.442 4.734 2.654.187 3.263.157 15.593-.78 35.401-2.686 57.944-3.488 88.365-3.143 46.327.526 75.721 2.23 130.788 7.584 19.787 1.924 20.814 1.98 24.557 1.332l.066-.011c1.201-.203 1.53-1.825.399-2.335-2.911-1.31-4.893-1.604-22.048-3.261-57.509-5.556-87.871-7.36-132.059-7.842-23.239-.254-33.617-.116-50.627.674-11.629.54-42.371 2.494-46.696 2.967-2.359.259 8.133-3.625 26.504-9.81 23.239-7.825 27.934-10.149 28.304-14.005.417-4.348-3.529-6-16.878-7.066Z" />
</svg>
<span className="relative">made simple</span>
</span>{' '}
for software engineers.
</h1>
<p className="mx-auto mt-6 max-w-2xl text-lg tracking-tight text-slate-700">
Get valuable feedback from the public or checkout reviewed resumes from
your fellow engineers
</p>
<div className="mt-10 flex justify-center gap-x-4">
<Button href="/resumes" label="Start browsing now" variant="primary" />
</div>
<div className="mt-10 flex justify-center">
<iframe
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
allowFullScreen={true}
frameBorder="0"
height="480"
src="path_to_url"
title="Resume Review Walkthrough"
width="853"
/>
</div>
</Container>
);
}
``` | /content/code_sandbox/apps/portal/src/components/resumes/landing/Hero.tsx | xml | 2016-07-05T05:00:48 | 2024-08-16T19:01:19 | tech-interview-handbook | yangshun/tech-interview-handbook | 115,302 | 877 |
```xml
/*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
import * as React from "react";
import type { OverlayInstance } from "../../components/overlay2/overlayInstance";
// N.B. using a mutable ref for the stack is much easier to work with in the world of hooks and FCs.
// This matches the mutable global behavior of the old Overlay implementation in Blueprint v5. An alternative
// approach was considered with an immutable array data structure and a reducer, but that implementation
// caused lots of unnecessary invalidation of `React.useCallback()` for document-level event handlers, which
// led to memory leaks and bugs.
export interface OverlaysContextState {
/**
* Whether the context instance is being used within a tree which has an `<OverlaysProvider>`.
* `useOverlayStack()` will work if this is `false` in Blueprint v5, but this will be unsupported
* in Blueprint v6; all applications with overlays will be required to configure a provider to
* manage global overlay state.
*
* @see path_to_url
*/
hasProvider: boolean;
/**
* The application-wide global overlay stack.
*/
stack: React.MutableRefObject<OverlayInstance[]>;
}
/**
* A React context used to interact with the overlay stack in an application.
* Users should take care to make sure that only _one_ of these is instantiated and used within an
* application.
*
* You will likely not be using this OverlaysContext directly, it's mostly used internally by the
* Overlay2 component.
*
* For more information, see the [OverlaysProvider documentation](path_to_url#core/context/overlays-provider).
*/
export const OverlaysContext = React.createContext<OverlaysContextState>({
hasProvider: false,
stack: { current: [] },
});
export interface OverlaysProviderProps {
/** The component subtree which will have access to this overlay stack context. */
children: React.ReactNode;
}
/**
* Overlays context provider, necessary for the `useOverlayStack` hook.
*
* @see path_to_url#core/context/overlays-provider
*/
export const OverlaysProvider = ({ children }: OverlaysProviderProps) => {
const stack = React.useRef<OverlayInstance[]>([]);
const contextValue = React.useMemo(() => ({ hasProvider: true, stack }), [stack]);
return <OverlaysContext.Provider value={contextValue}>{children}</OverlaysContext.Provider>;
};
``` | /content/code_sandbox/packages/core/src/context/overlays/overlaysProvider.tsx | xml | 2016-10-25T21:17:50 | 2024-08-16T15:14:48 | blueprint | palantir/blueprint | 20,593 | 540 |
```xml
import type { Dependencies } from "@Core/Dependencies";
import type { DependencyRegistry } from "@Core/DependencyRegistry";
import { InMemorySearchIndex } from "./InMemorySearchIndex";
export class SearchIndexModule {
public static bootstrap(dependencyRegistry: DependencyRegistry<Dependencies>) {
const ipcMain = dependencyRegistry.get("IpcMain");
const searchIndex = new InMemorySearchIndex(dependencyRegistry.get("BrowserWindowNotifier"));
dependencyRegistry.register("SearchIndex", searchIndex);
ipcMain.on("extensionDisabled", (_, { extensionId }: { extensionId: string }) =>
searchIndex.removeSearchResultItems(extensionId),
);
ipcMain.on("getSearchResultItems", (event) => (event.returnValue = searchIndex.getSearchResultItems()));
}
}
``` | /content/code_sandbox/src/main/Core/SearchIndex/SearchIndexModule.ts | xml | 2016-10-11T04:59:52 | 2024-08-16T11:53:31 | ueli | oliverschwendener/ueli | 3,543 | 162 |
```xml
/*
*
* See the LICENSE file at the top-level directory of this distribution
* for licensing information.
*
* Unless otherwise agreed in a custom licensing agreement with the Lisk Foundation,
* no part of this software, including this file, may be copied, modified,
* propagated, or distributed except according to the terms contained in the
* LICENSE file.
*
* Removal or modification of this copyright notice is prohibited.
*/
import { BaseTypes } from '../types';
export const getDefaultValue = (dataType: string): BaseTypes => {
switch (dataType) {
case 'string':
return '';
case 'boolean':
return false;
case 'bytes':
return Buffer.alloc(0);
case 'uint32':
case 'sint32':
return 0;
case 'uint64':
case 'sint64':
return BigInt(0);
default:
throw new Error('Invalid data type');
}
};
``` | /content/code_sandbox/elements/lisk-codec/src/utils/default_value.ts | xml | 2016-02-01T21:45:35 | 2024-08-15T19:16:48 | lisk-sdk | LiskArchive/lisk-sdk | 2,721 | 195 |
```xml
import * as fs from 'fs';
import * as path from 'path';
import * as http from 'http';
import * as url from 'url';
import * as querystring from 'querystring';
import * as nodeutil from './nodeutil';
import * as hid from './hid';
import * as net from 'net';
import * as storage from './storage';
import { SUB_WEBAPPS } from './subwebapp';
import { promisify } from "util";
import U = pxt.Util;
import Cloud = pxt.Cloud;
const userProjectsDirName = "projects";
let root = ""
let dirs = [""]
let docfilesdirs = [""]
let userProjectsDir = path.join(process.cwd(), userProjectsDirName);
let docsDir = ""
let packagedDir = ""
let localHexCacheDir = path.join("built", "hexcache");
let serveOptions: ServeOptions;
function setupDocfilesdirs() {
docfilesdirs = [
"docfiles",
path.join(nodeutil.pxtCoreDir, "docfiles")
]
}
function setupRootDir() {
root = nodeutil.targetDir
console.log("Starting server in", root)
console.log(`With pxt core at ${nodeutil.pxtCoreDir}`)
dirs = [
"built/web",
path.join(nodeutil.targetDir, "docs"),
path.join(nodeutil.targetDir, "built"),
path.join(nodeutil.targetDir, "sim/public"),
path.join(nodeutil.targetDir, "node_modules", `pxt-${pxt.appTarget.id}-sim`, "public"),
path.join(nodeutil.pxtCoreDir, "built/web"),
path.join(nodeutil.pxtCoreDir, "webapp/public"),
path.join(nodeutil.pxtCoreDir, "common-docs"),
path.join(nodeutil.pxtCoreDir, "docs"),
]
docsDir = path.join(root, "docs")
packagedDir = path.join(root, "built/packaged")
setupDocfilesdirs()
setupProjectsDir()
pxt.debug(`docs dir:\r\n ${docsDir}`)
pxt.debug(`doc files dir: \r\n ${docfilesdirs.join("\r\n ")}`)
pxt.debug(`dirs:\r\n ${dirs.join('\r\n ')}`)
pxt.debug(`projects dir: ${userProjectsDir}`);
}
function setupProjectsDir() {
nodeutil.mkdirP(userProjectsDir);
}
const statAsync = promisify(fs.stat)
const readdirAsync = promisify(fs.readdir)
const readFileAsync = promisify(fs.readFile)
const writeFileAsync: any = promisify(fs.writeFile)
const unlinkAsync: any = promisify(fs.unlink)
function existsAsync(fn: string): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
fs.exists(fn, resolve)
})
}
function statOptAsync(fn: string): Promise<fs.Stats> {// or null
return statAsync(fn)
.then(st => st, err => null)
}
function throwError(code: number, msg: string = null) {
let err = new Error(msg || "Error " + code);
(err as any).statusCode = code
throw err
}
type FsFile = pxt.FsFile;
type FsPkg = pxt.FsPkg;
function readAssetsAsync(logicalDirname: string): Promise<any> {
let dirname = path.join(userProjectsDir, logicalDirname, "assets")
let pref = "http://" + serveOptions.hostname + ":" + serveOptions.port + "/assets/" + logicalDirname + "/"
return readdirAsync(dirname)
.catch(err => [])
.then(res => U.promiseMapAll(res, fn => statAsync(path.join(dirname, fn)).then(res => ({
name: fn,
size: res.size,
url: pref + fn
}))))
.then(res => ({
files: res
}))
}
const HEADER_JSON = ".header.json"
async function readPkgAsync(logicalDirname: string, fileContents = false): Promise<FsPkg> {
let dirname = path.join(userProjectsDir, logicalDirname)
let buf = await readFileAsync(path.join(dirname, pxt.CONFIG_NAME))
let cfg: pxt.PackageConfig = JSON.parse(buf.toString("utf8"))
let r: FsPkg = {
path: logicalDirname,
config: cfg,
header: null,
files: []
};
for (let fn of pxt.allPkgFiles(cfg).concat([pxt.github.GIT_JSON, pxt.SIMSTATE_JSON])) {
let st = await statOptAsync(path.join(dirname, fn))
let ff: FsFile = {
name: fn,
mtime: st ? st.mtime.getTime() : null
}
let thisFileContents = st && fileContents
if (!st && fn == pxt.SIMSTATE_JSON)
continue
if (fn == pxt.github.GIT_JSON) {
// skip .git.json altogether if missing
if (!st) continue
thisFileContents = true
}
if (thisFileContents) {
let buf = await readFileAsync(path.join(dirname, fn))
ff.content = buf.toString("utf8")
}
r.files.push(ff)
}
if (await existsAsync(path.join(dirname, "icon.jpeg"))) {
r.icon = "/icon/" + logicalDirname
}
// now try reading the header
buf = await readFileAsync(path.join(dirname, HEADER_JSON))
.then(b => b, err => null)
if (buf && buf.length)
r.header = JSON.parse(buf.toString("utf8"))
return r
}
function writeScreenshotAsync(logicalDirname: string, screenshotUri: string, iconUri: string) {
console.log('writing screenshot...');
const dirname = path.join(userProjectsDir, logicalDirname)
nodeutil.mkdirP(dirname)
function writeUriAsync(name: string, uri: string) {
if (!uri) return Promise.resolve();
const m = uri.match(/^data:image\/(png|jpeg);base64,(.*)$/);
if (!m) return Promise.resolve();
const ext = m[1];
const data = m[2];
const fn = path.join(dirname, name + "." + ext);
console.log(`writing ${fn}`)
return writeFileAsync(fn, Buffer.from(data, 'base64'));
}
return Promise.all([
writeUriAsync("screenshot", screenshotUri),
writeUriAsync("icon", iconUri)
]).then(() => { });
}
function writePkgAssetAsync(logicalDirname: string, data: any) {
const dirname = path.join(userProjectsDir, logicalDirname, "assets")
nodeutil.mkdirP(dirname)
return writeFileAsync(dirname + "/" + data.name, Buffer.from(data.data, data.encoding || "base64"))
.then(() => ({
name: data.name
}))
}
function writePkgAsync(logicalDirname: string, data: FsPkg) {
const dirname = path.join(userProjectsDir, logicalDirname)
nodeutil.mkdirP(dirname)
return U.promiseMapAll(data.files, f =>
readFileAsync(path.join(dirname, f.name))
.then(buf => {
if (f.name == pxt.CONFIG_NAME) {
try {
if (!pxt.Package.parseAndValidConfig(f.content)) {
pxt.log("Trying to save invalid JSON config")
pxt.debug(f.content);
throwError(410)
}
} catch (e) {
pxt.log("Trying to save invalid format JSON config")
pxt.log(e)
pxt.debug(f.content);
throwError(410)
}
}
if (buf.toString("utf8") !== f.prevContent) {
pxt.log(`merge error for ${f.name}: previous content changed...`);
throwError(409)
}
}, err => { }))
// no conflict, proceed with writing
.then(() => U.promiseMapAll(data.files, f => {
let d = f.name.replace(/\/[^\/]*$/, "")
if (d != f.name)
nodeutil.mkdirP(path.join(dirname, d))
const fn = path.join(dirname, f.name)
return f.content == null ? unlinkAsync(fn) : writeFileAsync(fn, f.content)
}))
.then(() => {
if (data.header)
return writeFileAsync(path.join(dirname, HEADER_JSON), JSON.stringify(data.header, null, 4))
})
.then(() => readPkgAsync(logicalDirname, false))
}
function returnDirAsync(logicalDirname: string, depth: number): Promise<FsPkg[]> {
logicalDirname = logicalDirname.replace(/^\//, "")
const dirname = path.join(userProjectsDir, logicalDirname)
// load packages under /projects, 3 level deep
return existsAsync(path.join(dirname, pxt.CONFIG_NAME))
// read package if pxt.json exists
.then(ispkg => Promise.all<FsPkg[]>([
// current folder
ispkg ? readPkgAsync(logicalDirname).then<FsPkg[]>(r => [r], err => undefined) : Promise.resolve<FsPkg[]>(undefined),
// nested packets
depth <= 1 ? Promise.resolve<FsPkg[]>(undefined)
: readdirAsync(dirname).then(files => U.promiseMapAll(files, fn =>
statAsync(path.join(dirname, fn)).then<FsPkg[]>(st => {
if (fn[0] != "." && st.isDirectory())
return returnDirAsync(logicalDirname + "/" + fn, depth - 1)
else return undefined
})).then(U.concat)
)
]))
// drop empty arrays
.then(rs => rs.filter(r => !!r))
.then(U.concat);
}
function isAuthorizedLocalRequest(req: http.IncomingMessage): boolean {
// validate token
return req.headers["authorization"]
&& req.headers["authorization"] == serveOptions.localToken;
}
function getCachedHexAsync(sha: string): Promise<any> {
if (!sha) {
return Promise.resolve();
}
let hexFile = path.resolve(localHexCacheDir, sha + ".hex");
return existsAsync(hexFile)
.then((results) => {
if (!results) {
console.log(`offline HEX not found: ${hexFile}`);
return Promise.resolve(null);
}
console.log(`serving HEX from offline cache: ${hexFile}`);
return readFileAsync(hexFile)
.then((fileContent) => {
return {
enums: [],
functions: [],
hex: fileContent.toString()
};
});
});
}
async function handleApiStoreRequestAsync(req: http.IncomingMessage, res: http.ServerResponse, elts: string[]): Promise<void> {
const meth = req.method.toUpperCase();
const container = decodeURIComponent(elts[0]);
const key = decodeURIComponent(elts[1]);
if (!container || !key) { throw throwError(400, "malformed api/store request: " + req.url); }
const origin = req.headers['origin'] || '*';
res.setHeader('Access-Control-Allow-Origin', origin);
if (meth === "GET") {
const val = await storage.getAsync(container, key);
if (val) {
if (typeof val === "object") {
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf8' });
res.end(JSON.stringify(val));
} else {
res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf8' });
res.end(val.toString());
}
} else {
res.writeHead(204);
res.end();
}
} else if (meth === "POST") {
const srec = (await nodeutil.readResAsync(req)).toString("utf8");
const rec = JSON.parse(srec) as storage.Record;
await storage.setAsync(container, key, rec);
res.writeHead(200);
res.end();
} else if (meth === "DELETE") {
await storage.delAsync(container, key);
res.writeHead(200);
res.end();
} else if (meth === "OPTIONS") {
const allowedHeaders = req.headers['access-control-request-headers'] || 'Content-Type';
const allowedMethods = req.headers['access-control-request-method'] || 'GET, POST, DELETE';
res.setHeader('Access-Control-Allow-Headers', allowedHeaders);
res.setHeader('Access-Control-Allow-Methods', allowedMethods);
res.writeHead(200);
res.end();
} else {
throw res.writeHead(400, "Unsupported HTTP method: " + meth);
}
}
function handleApiAsync(req: http.IncomingMessage, res: http.ServerResponse, elts: string[]): Promise<any> {
const opts: pxt.Map<string | string[]> = querystring.parse(url.parse(req.url).query)
const innerPath = elts.slice(2).join("/").replace(/^\//, "")
const filename = path.resolve(path.join(userProjectsDir, innerPath))
const meth = req.method.toUpperCase()
const cmd = meth + " " + elts[1]
const readJsonAsync = () =>
nodeutil.readResAsync(req)
.then(buf => JSON.parse(buf.toString("utf8")))
if (cmd == "GET list")
return returnDirAsync(innerPath, 3)
.then<pxt.FsPkgs>(lst => {
return {
pkgs: lst
}
})
else if (cmd == "GET stat")
return statOptAsync(filename)
.then(st => {
if (!st) return {}
else return {
mtime: st.mtime.getTime()
}
})
else if (cmd == "GET pkg")
return readPkgAsync(innerPath, true)
else if (cmd == "POST pkg")
return readJsonAsync()
.then(d => writePkgAsync(innerPath, d))
else if (cmd == "POST pkgasset")
return readJsonAsync()
.then(d => writePkgAssetAsync(innerPath, d))
else if (cmd == "GET pkgasset")
return readAssetsAsync(innerPath)
else if (cmd == "POST deploy" && pxt.commands.hasDeployFn())
return readJsonAsync()
.then(pxt.commands.deployAsync)
.then((boardCount) => {
return {
boardCount: boardCount
};
});
else if (cmd == "POST screenshot")
return readJsonAsync()
.then(d => writeScreenshotAsync(innerPath, d.screenshot, d.icon));
else if (cmd == "GET compile")
return getCachedHexAsync(innerPath)
.then((res) => {
if (!res) {
return {
notInOfflineCache: true
};
}
return res;
});
else if (cmd == "GET md" && pxt.appTarget.id + "/" == innerPath.slice(0, pxt.appTarget.id.length + 1)) {
// innerpath start with targetid
return readMdAsync(
innerPath.slice(pxt.appTarget.id.length + 1),
opts["lang"] as string);
}
else if (cmd == "GET config" && new RegExp(`${pxt.appTarget.id}\/targetconfig(\/v[0-9.]+)?$`).test(innerPath)) {
// target config
return readFileAsync("targetconfig.json").then(buf => JSON.parse(buf.toString("utf8")));
}
else throw throwError(400, `unknown command ${cmd.slice(0, 140)}`)
}
export function lookupDocFile(name: string) {
if (docfilesdirs.length <= 1)
setupDocfilesdirs()
for (let d of docfilesdirs) {
let foundAt = path.join(d, name)
if (fs.existsSync(foundAt)) return foundAt
}
return null
}
export function expandHtml(html: string, params?: pxt.Map<string>, appTheme?: pxt.AppTheme) {
let theme = U.flatClone(appTheme || pxt.appTarget.appTheme)
html = expandDocTemplateCore(html)
params = params || {};
params["name"] = params["name"] || pxt.appTarget.appTheme.title;
params["description"] = params["description"] || pxt.appTarget.appTheme.description;
params["locale"] = params["locale"] || pxt.appTarget.appTheme.defaultLocale || "en"
// page overrides
let m = /<title>([^<>@]*)<\/title>/.exec(html)
if (m) params["name"] = m[1]
m = /<meta name="Description" content="([^"@]*)"/.exec(html)
if (m) params["description"] = m[1]
let d: pxt.docs.RenderData = {
html: html,
params: params,
theme: theme,
// Note that breadcrumb and filepath expansion are not supported in the cloud
// so we don't do them here either.
}
pxt.docs.prepTemplate(d)
return d.finish().replace(/@-(\w+)-@/g, (f, w) => "@" + w + "@")
}
export function expandDocTemplateCore(template: string) {
template = template
.replace(/<!--\s*@include\s+(\S+)\s*-->/g,
(full, fn) => {
return `
<!-- include ${fn} -->
${expandDocFileTemplate(fn)}
<!-- end include ${fn} -->
`
})
return template
}
export function expandDocFileTemplate(name: string) {
let fn = lookupDocFile(name)
let template = fn ? fs.readFileSync(fn, "utf8") : ""
return expandDocTemplateCore(template)
}
let wsSerialClients: WebSocket[] = [];
let webappReady = false;
function initSocketServer(wsPort: number, hostname: string) {
console.log(`starting local ws server at ${wsPort}...`)
const WebSocket = require('faye-websocket');
function startSerial(request: any, socket: any, body: any) {
let ws = new WebSocket(request, socket, body);
wsSerialClients.push(ws);
ws.on('message', function (event: any) {
// ignore
});
ws.on('close', function (event: any) {
console.log('ws connection closed')
wsSerialClients.splice(wsSerialClients.indexOf(ws), 1)
ws = null;
});
ws.on('error', function () {
console.log('ws connection closed')
wsSerialClients.splice(wsSerialClients.indexOf(ws), 1)
ws = null;
})
}
function objToString(obj: any) {
if (obj == null)
return "null"
let r = "{\n"
for (let k of Object.keys(obj)) {
r += " " + k + ": "
let s = JSON.stringify(obj[k])
if (!s) s = "(null)"
if (s.length > 60) s = s.slice(0, 60) + "..."
r += s + "\n"
}
r += "}"
return r
}
let hios: pxt.Map<Promise<pxt.HF2.Wrapper>> = {};
function startHID(request: http.IncomingMessage, socket: WebSocket, body: any) {
let ws = new WebSocket(request, socket, body);
ws.on('open', () => {
ws.send(JSON.stringify({ id: "ready" }))
})
ws.on('message', function (event: any) {
try {
let msg = JSON.parse(event.data);
pxt.debug(`hid: msg ${msg.op}`) // , objToString(msg.arg))
// check that HID is installed
if (!hid.isInstalled(true)) {
if (!ws) return;
ws.send(JSON.stringify({
result: {
errorMessage: "node-hid not installed",
},
op: msg.op,
id: msg.id
}))
return;
}
Promise.resolve()
.then(() => {
let hio = hios[msg.arg.path]
if (!hio && msg.arg.path)
hios[msg.arg.path] = hio = hid.hf2ConnectAsync(msg.arg.path, !!msg.arg.raw)
return hio
})
.then(hio => {
switch (msg.op) {
case "disconnect":
return hio.disconnectAsync()
.then(() => ({}))
case "init":
return hio.reconnectAsync()
.then(() => {
hio.io.onEvent = v => {
if (!ws) return
ws.send(JSON.stringify({
op: "event",
result: {
path: msg.arg.path,
data: U.toHex(v),
}
}))
}
if (hio.rawMode)
hio.io.onData = hio.io.onEvent
hio.onSerial = (v, isErr) => {
if (!ws) return
ws.send(JSON.stringify({
op: "serial",
result: {
isError: isErr,
path: msg.arg.path,
data: U.toHex(v),
}
}))
}
return {}
})
case "send":
if (!hio.rawMode)
return null
return hio.io.sendPacketAsync(U.fromHex(msg.arg.data))
.then(() => ({}))
case "talk":
return U.promiseMapAllSeries(msg.arg.cmds, (obj: any) => {
pxt.debug(`hid talk ${obj.cmd}`)
return hio.talkAsync(obj.cmd, U.fromHex(obj.data))
.then(res => ({ data: U.toHex(res) }))
});
case "sendserial":
return hio.sendSerialAsync(U.fromHex(msg.arg.data), msg.arg.isError);
case "list":
return hid.getHF2DevicesAsync()
.then(devices => { return { devices } as any; });
default: // unknown message
pxt.log(`unknown hid message ${msg.op}`)
return null;
}
})
.then(resp => {
if (!ws) return;
pxt.debug(`hid: resp ${objToString(resp)}`)
ws.send(JSON.stringify({
op: msg.op,
id: msg.id,
result: resp
}))
}, error => {
pxt.log(`hid: error ${error.message}`)
if (!ws) return;
ws.send(JSON.stringify({
result: {
errorMessage: error.message || "Error",
errorStackTrace: error.stack,
},
op: msg.op,
id: msg.id
}))
})
} catch (e) {
console.log("ws hid error", e.stack)
}
});
ws.on('close', function (event: any) {
console.log('ws hid connection closed')
ws = null;
});
ws.on('error', function () {
console.log('ws hid connection closed')
ws = null;
})
}
let openSockets: pxt.Map<net.Socket> = {};
function startTCP(request: http.IncomingMessage, socket: WebSocket, body: any) {
let ws = new WebSocket(request, socket, body);
let netSockets: net.Socket[] = []
ws.on('open', () => {
ws.send(JSON.stringify({ id: "ready" }))
})
ws.on('message', function (event: any) {
try {
let msg = JSON.parse(event.data);
pxt.debug(`tcp: msg ${msg.op}`) // , objToString(msg.arg))
Promise.resolve()
.then(() => {
let sock = openSockets[msg.arg.socket]
switch (msg.op) {
case "close":
sock.end();
let idx = netSockets.indexOf(sock)
if (idx >= 0)
netSockets.splice(idx, 1)
return {}
case "open":
return new Promise((resolve, reject) => {
const newSock = new net.Socket()
netSockets.push(newSock)
const id = pxt.U.guidGen()
newSock.on('error', err => {
if (ws)
ws.send(JSON.stringify({ op: "error", result: { socket: id, error: err.message } }))
})
newSock.connect(msg.arg.port, msg.arg.host, () => {
openSockets[id] = newSock
resolve({ socket: id })
})
newSock.on('data', d => {
if (ws)
ws.send(JSON.stringify({ op: "data", result: { socket: id, data: d.toString("base64"), encoding: "base64" } }))
})
newSock.on('close', () => {
if (ws)
ws.send(JSON.stringify({ op: "close", result: { socket: id } }))
})
})
case "send":
sock.write(Buffer.from(msg.arg.data, msg.arg.encoding || "utf8"))
return {}
default: // unknown message
pxt.log(`unknown tcp message ${msg.op}`)
return null;
}
})
.then(resp => {
if (!ws) return;
pxt.debug(`hid: resp ${objToString(resp)}`)
ws.send(JSON.stringify({
op: msg.op,
id: msg.id,
result: resp
}))
}, error => {
pxt.log(`hid: error ${error.message}`)
if (!ws) return;
ws.send(JSON.stringify({
result: {
errorMessage: error.message || "Error",
errorStackTrace: error.stack,
},
op: msg.op,
id: msg.id
}))
})
} catch (e) {
console.log("ws tcp error", e.stack)
}
});
function closeAll() {
console.log('ws tcp connection closed')
ws = null;
for (let s of netSockets) {
try {
s.end()
} catch (e) { }
}
}
ws.on('close', closeAll);
ws.on('error', closeAll);
}
function startDebug(request: http.IncomingMessage, socket: WebSocket, body: any) {
let ws = new WebSocket(request, socket, body);
let dapjs: any
ws.on('open', () => {
ws.send(JSON.stringify({ id: "ready" }))
})
ws.on('message', function (event: any) {
try {
let msg = JSON.parse(event.data);
if (!dapjs) dapjs = require("dapjs")
let toHandle = msg.arg
toHandle.op = msg.op
console.log("DEBUGMSG", objToString(toHandle))
Promise.resolve()
.then(() => dapjs.handleMessageAsync(toHandle))
.then(resp => {
if (resp == null || typeof resp != "object")
resp = { response: resp }
console.log("DEBUGRESP", objToString(resp))
ws.send(JSON.stringify({
op: msg.op,
id: msg.id,
result: resp
}))
}, error => {
console.log("DEBUGERR", error.stack)
ws.send(JSON.stringify({
result: {
errorMessage: error.message || "Error",
errorStackTrace: error.stack,
},
op: msg.op,
id: msg.id
}))
})
} catch (e) {
console.log("ws debug error", e.stack)
}
});
ws.on('close', function (event: any) {
console.log('ws debug connection closed')
ws = null;
});
ws.on('error', function () {
console.log('ws debug connection closed')
ws = null;
})
}
let wsserver = http.createServer();
wsserver.on('upgrade', function (request: http.IncomingMessage, socket: WebSocket, body: any) {
try {
if (WebSocket.isWebSocket(request)) {
console.log('ws connection at ' + request.url);
if (request.url == "/" + serveOptions.localToken + "/serial")
startSerial(request, socket, body);
else if (request.url == "/" + serveOptions.localToken + "/debug")
startDebug(request, socket, body);
else if (request.url == "/" + serveOptions.localToken + "/hid")
startHID(request, socket, body);
else if (request.url == "/" + serveOptions.localToken + "/tcp")
startTCP(request, socket, body);
else {
console.log('refused connection at ' + request.url);
socket.close(403);
}
}
} catch (e) {
console.log('upgrade failed...')
}
});
return new Promise<void>((resolve, reject) => {
wsserver.on("Error", reject);
wsserver.listen(wsPort, hostname, () => resolve());
});
}
function sendSerialMsg(msg: string) {
//console.log('sending ' + msg);
wsSerialClients.forEach(function (client: any) {
client.send(msg);
})
}
function initSerialMonitor() {
// TODO HID
}
export interface ServeOptions {
localToken: string;
autoStart: boolean;
packaged?: boolean;
browser?: string;
port?: number;
hostname?: string;
wsPort?: number;
serial?: boolean;
noauth?: boolean;
}
// can use path_to_url for testing
function streamPageTestAsync(id: string) {
return Cloud.privateGetAsync(id)
.then((info: pxt.streams.JsonStream) => {
let html = pxt.docs.renderMarkdown({
template: expandDocFileTemplate("stream.html"),
markdown: "",
theme: pxt.appTarget.appTheme,
pubinfo: info as any,
filepath: "/" + id
})
return html
})
}
function certificateTestAsync(): Promise<string> {
return Promise.resolve(expandDocFileTemplate("certificates.html"));
}
// use path_to_url for testing
function scriptPageTestAsync(id: string) {
return Cloud.privateGetAsync(pxt.Cloud.parseScriptId(id))
.then((info: Cloud.JsonScript) => {
// if running against old cloud, infer 'thumb' field
// can be removed after new cloud deployment
if (info.thumb !== undefined)
return info
return Cloud.privateGetTextAsync(id + "/thumb")
.then(_ => {
info.thumb = true
return info
}, _ => {
info.thumb = false
return info
})
})
.then((info: Cloud.JsonScript) => {
let infoA = info as any
infoA.cardLogo = info.thumb
? Cloud.apiRoot + id + "/thumb"
: pxt.appTarget.appTheme.thumbLogo || pxt.appTarget.appTheme.cardLogo
let html = pxt.docs.renderMarkdown({
template: expandDocFileTemplate(pxt.appTarget.appTheme.leanShare
? "leanscript.html" : "script.html"),
markdown: "",
theme: pxt.appTarget.appTheme,
pubinfo: info as any,
filepath: "/" + id
})
return html
});
}
// use path_to_url for testing
function pkgPageTestAsync(id: string) {
return pxt.packagesConfigAsync()
.then(config => pxt.github.repoAsync(id, config))
.then(repo => {
if (!repo)
return "Not found"
return Cloud.privateGetAsync("gh/" + id + "/text")
.then((files: pxt.Map<string>) => {
let info = JSON.parse(files["pxt.json"])
info["slug"] = id
info["id"] = "gh/" + id
if (repo.status == pxt.github.GitRepoStatus.Approved)
info["official"] = "yes"
else
info["official"] = ""
const html = pxt.docs.renderMarkdown({
template: expandDocFileTemplate("package.html"),
markdown: files["README.md"] || "No `README.md`",
theme: pxt.appTarget.appTheme,
pubinfo: info,
filepath: "/pkg/" + id,
repo: { name: repo.name, fullName: repo.fullName, tag: "v" + info.version }
})
return html
})
})
}
function readMdAsync(pathname: string, lang: string): Promise<string> {
if (!lang || lang == "en") {
const content = nodeutil.resolveMd(root, pathname);
if (content) return Promise.resolve(content);
return Promise.resolve(`# Not found ${pathname}\nChecked:\n` + [docsDir].concat(dirs).concat(nodeutil.lastResolveMdDirs).map(s => "* ``" + s + "``\n").join(""));
} else {
// ask makecode cloud for translations
const mdpath = pathname.replace(/^\//, '');
return pxt.Cloud.markdownAsync(mdpath, lang);
}
}
function resolveTOC(pathname: string): pxt.TOCMenuEntry[] {
// find summary.md
let summarydir = pathname.replace(/^\//, '');
let presummarydir = "";
while (summarydir !== presummarydir) {
const summaryf = path.join(summarydir, "SUMMARY");
// find "closest summary"
const summaryMd = nodeutil.resolveMd(root, summaryf)
if (summaryMd) {
try {
return pxt.docs.buildTOC(summaryMd);
} catch (e) {
pxt.log(`invalid ${summaryf} format - ${e.message}`)
pxt.log(e.stack);
}
break;
}
presummarydir = summarydir;
summarydir = path.dirname(summarydir);
}
// not found
pxt.log(`SUMMARY.md not found`)
return undefined;
}
const compiledCache: pxt.Map<string> = {}
export async function compileScriptAsync(id: string) {
if (compiledCache[id])
return compiledCache[id]
const scrText = await Cloud.privateGetAsync(id + "/text")
const res = await pxt.simpleCompileAsync(scrText, {})
let r = ""
if (res.errors)
r = `throw new Error(${JSON.stringify(res.errors)})`
else
r = res.outfiles["binary.js"]
compiledCache[id] = r
return r
}
export function serveAsync(options: ServeOptions) {
serveOptions = options;
if (!serveOptions.port) serveOptions.port = 3232;
if (!serveOptions.wsPort) serveOptions.wsPort = 3233;
if (!serveOptions.hostname) serveOptions.hostname = "localhost";
setupRootDir();
const wsServerPromise = initSocketServer(serveOptions.wsPort, serveOptions.hostname);
if (serveOptions.serial)
initSerialMonitor();
const server = http.createServer(async (req, res) => {
const error = (code: number, msg: string = null) => {
res.writeHead(code, { "Content-Type": "text/plain" })
res.end(msg || "Error " + code)
}
const sendJson = (v: any) => {
if (typeof v == "string") {
res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf8' })
res.end(v)
} else {
res.writeHead(200, { 'Content-Type': 'application/json; charset=utf8' })
res.end(JSON.stringify(v))
}
}
const sendHtml = (s: string, code = 200) => {
res.writeHead(code, { 'Content-Type': 'text/html; charset=utf8' })
res.end(s.replace(
/(<img [^>]* src=")(?:\/docs|\.)\/static\/([^">]+)"/g,
function (f, pref, addr) { return pref + '/static/' + addr + '"'; }
))
}
const sendFile = (filename: string) => {
try {
let stat = fs.statSync(filename);
res.writeHead(200, {
'Content-Type': U.getMime(filename),
'Content-Length': stat.size
});
fs.createReadStream(filename).pipe(res);
} catch (e) {
error(404, "File missing: " + filename)
}
}
let uri = url.parse(req.url);
let pathname = decodeURI(uri.pathname);
const opts: pxt.Map<string | string[]> = querystring.parse(url.parse(req.url).query);
const htmlParams: pxt.Map<string> = {};
if (opts["lang"] || opts["forcelang"])
htmlParams["locale"] = (opts["lang"] as string || opts["forcelang"] as string);
if (pathname == "/") {
res.writeHead(301, { location: '/index.html' })
res.end()
return
}
if (pathname == "/oauth-redirect") {
res.writeHead(301, { location: '/oauth-redirect.html' })
res.end()
return
}
let elts = pathname.split("/").filter(s => !!s)
if (elts.some(s => s[0] == ".")) {
return error(400, "Bad path :-(\n")
}
// Strip leading version number
if (elts.length && /^v\d+/.test(elts[0])) {
elts.shift();
}
// Rebuild pathname without leading version number
pathname = "/" + elts.join("/");
const expandWebappHtml = (appname: string, html: string) => {
// Expand templates
html = expandHtml(html);
// Rewrite application resource references
html = html.replace(/src="(\/static\/js\/[^"]*)"/, (m, f) => `src="/${appname}${f}"`);
html = html.replace(/src="(\/static\/css\/[^"]*)"/, (m, f) => `src="/${appname}${f}"`);
return html;
};
const serveWebappFile = (webappName: string, webappPath: string) => {
const webappUri = url.parse(`path_to_url{webappPath}${uri.search || ""}`);
const request = http.get(webappUri, r => {
let body = "";
r.on("data", (chunk) => {
body += chunk;
});
r.on("end", () => {
if (body.includes("<title>Error</title>")) { // CRA development server returns this for missing files
res.writeHead(404, {
'Content-Type': 'text/html; charset=utf8',
});
res.write(body);
return res.end();
}
if (!webappPath || webappPath === "index.html") {
body = expandWebappHtml(webappName, body);
}
if (webappPath) {
res.writeHead(200, {
'Content-Type': U.getMime(webappPath),
});
} else {
res.writeHead(200, {
'Content-Type': 'text/html; charset=utf8',
});
}
res.write(body);
res.end();
});
});
request.on("error", (e) => {
console.error(`Error fetching ${webappUri.href} .. ${e.message}`);
error(500, e.message);
});
};
const webappNames = SUB_WEBAPPS.filter(w => w.localServeEndpoint).map(w => w.localServeEndpoint);
const webappIdx = webappNames.findIndex(s => new RegExp(`^-{0,3}${s}$`).test(elts[0] || ''));
if (webappIdx >= 0) {
const webappName = webappNames[webappIdx];
const webappPath = pathname.split("/").slice(2).join('/'); // remove /<webappName>/ from path
return serveWebappFile(webappName, webappPath);
}
if (elts[0] == "api") {
if (elts[1] == "streams") {
let trg = Cloud.apiRoot + req.url.slice(5)
res.setHeader("Location", trg)
error(302, "Redir: " + trg)
return
}
if (elts[1] == "immreader") {
let trg = Cloud.apiRoot + elts[1];
res.setHeader("Location", trg)
error(302, "Redir: " + trg)
return
}
if (elts[1] == "store") {
return await handleApiStoreRequestAsync(req, res, elts.slice(2));
}
if (/^\d\d\d[\d\-]*$/.test(elts[1]) && elts[2] == "js") {
return compileScriptAsync(elts[1])
.then(data => {
res.writeHead(200, { 'Content-Type': 'application/javascript' })
res.end(data)
}, err => {
error(500)
console.log(err.stack)
})
}
if (!options.noauth && !isAuthorizedLocalRequest(req)) {
error(403);
return null;
}
return handleApiAsync(req, res, elts)
.then(sendJson, err => {
if (err.statusCode) {
error(err.statusCode, err.message || "");
console.log("Error " + err.statusCode);
}
else {
error(500)
console.log(err.stack)
}
})
}
if (elts[0] == "icon") {
const name = path.join(userProjectsDir, elts[1], "icon.jpeg");
return existsAsync(name)
.then(exists => exists ? sendFile(name) : error(404));
}
if (elts[0] == "assets") {
if (/^[a-z0-9\-_]/.test(elts[1]) && !/[\/\\]/.test(elts[1]) && !/^[.]/.test(elts[2])) {
let filename = path.join(userProjectsDir, elts[1], "assets", elts[2])
if (nodeutil.fileExistsSync(filename)) {
return sendFile(filename)
} else {
return error(404, "Asset not found")
}
} else {
return error(400, "Invalid asset path")
}
}
if (options.packaged) {
let filename = path.resolve(path.join(packagedDir, pathname))
if (nodeutil.fileExistsSync(filename)) {
return sendFile(filename)
} else {
return error(404, "Packaged file not found")
}
}
if (pathname.slice(0, pxt.appTarget.id.length + 2) == "/" + pxt.appTarget.id + "/") {
res.writeHead(301, { location: req.url.slice(pxt.appTarget.id.length + 1) })
res.end()
return
}
let publicDir = path.join(nodeutil.pxtCoreDir, "webapp/public")
if (pathname == "/--embed" || pathname === "/---embed") {
sendFile(path.join(publicDir, 'embed.js'));
return
}
if (pathname == "/--run") {
sendFile(path.join(publicDir, 'run.html'));
return
}
if (pathname == "/--multi") {
sendFile(path.join(publicDir, 'multi.html'));
return
}
if (pathname == "/--asseteditor") {
sendFile(path.join(publicDir, 'asseteditor.html'));
return
}
for (const subapp of SUB_WEBAPPS) {
if (subapp.localServeWebConfigUrl && pathname === `/--${subapp.name}`) {
sendFile(path.join(publicDir, `${subapp.name}.html`));
return
}
}
if (/\/-[-]*docs.*$/.test(pathname)) {
sendFile(path.join(publicDir, 'docs.html'));
return
}
if (pathname == "/--codeembed") {
// path_to_url#pub:20467-26471-70207-51013
sendFile(path.join(publicDir, 'codeembed.html'));
return
}
if (!!pxt.Cloud.parseScriptId(pathname)) {
scriptPageTestAsync(pathname)
.then(sendHtml)
.catch(() => error(404, "Script not found"));
return
}
if (/^\/(pkg|package)\/.*$/.test(pathname)) {
pkgPageTestAsync(pathname.replace(/^\/[^\/]+\//, ""))
.then(sendHtml)
.catch(() => error(404, "Packaged file not found"));
return
}
if (elts[0] == "streams") {
streamPageTestAsync(elts[0] + "/" + elts[1])
.then(sendHtml)
return
}
if (elts[0] == "certificates") {
certificateTestAsync().then(sendHtml);
return;
}
if (/\.js\.map$/.test(pathname)) {
error(404, "map files disabled")
return;
}
let dd = dirs
let mm = /^\/(cdn|parts|sim|doccdn|blb|trgblb)(\/.*)/.exec(pathname)
if (mm) {
pathname = mm[2]
} else if (U.startsWith(pathname, "/docfiles/")) {
pathname = pathname.slice(10)
dd = docfilesdirs
}
for (let dir of dd) {
let filename = path.resolve(path.join(dir, pathname))
if (nodeutil.fileExistsSync(filename)) {
if (/\.html$/.test(filename)) {
let html = expandHtml(fs.readFileSync(filename, "utf8"), htmlParams)
sendHtml(html)
} else {
sendFile(filename)
}
return;
}
}
if (/simulator\.html/.test(pathname)) {
// Special handling for missing simulator: redirect to the live sim
res.writeHead(302, { location: `path_to_url{pxt.appTarget.id}.userpxt.io/---simulator` });
res.end();
return;
}
// redirect
let redirectFile = path.join(docsDir, pathname + "-ref.json");
if (nodeutil.fileExistsSync(redirectFile)) {
const redir = nodeutil.readJson(redirectFile);
res.writeHead(301, { location: redir["redirect"] })
res.end()
return;
}
let webFile = path.join(docsDir, pathname)
if (!nodeutil.fileExistsSync(webFile)) {
if (nodeutil.fileExistsSync(webFile + ".html")) {
webFile += ".html"
pathname += ".html"
} else {
webFile = ""
}
}
if (webFile) {
if (/\.html$/.test(webFile)) {
let html = expandHtml(fs.readFileSync(webFile, "utf8"), htmlParams)
sendHtml(html)
} else {
sendFile(webFile)
}
} else {
const m = /^\/(v\d+)(.*)/.exec(pathname);
if (m) pathname = m[2];
const lang = (opts["translate"] && ts.pxtc.Util.TRANSLATION_LOCALE)
|| opts["lang"] as string
|| opts["forcelang"] as string;
readMdAsync(pathname, lang)
.then(md => {
const mdopts = <pxt.docs.RenderOptions>{
template: expandDocFileTemplate("docs.html"),
markdown: md,
theme: pxt.appTarget.appTheme,
filepath: pathname,
TOC: resolveTOC(pathname),
pubinfo: {
locale: lang,
crowdinproject: pxt.appTarget.appTheme.crowdinProject
}
};
if (opts["translate"])
mdopts.pubinfo["incontexttranslations"] = "1";
const html = pxt.docs.renderMarkdown(mdopts)
sendHtml(html, U.startsWith(md, "# Not found") ? 404 : 200)
});
}
return
});
// if user has a server.js file, require it
const serverjs = path.resolve(path.join(root, 'built', 'server.js'))
if (nodeutil.fileExistsSync(serverjs)) {
console.log('loading ' + serverjs)
require(serverjs);
}
const serverPromise = new Promise<void>((resolve, reject) => {
server.on("error", reject);
server.listen(serveOptions.port, serveOptions.hostname, () => resolve());
});
return Promise.all([wsServerPromise, serverPromise])
.then(() => {
const start = `path_to_url{serveOptions.hostname}:${serveOptions.port}/#local_token=${options.localToken}&wsport=${serveOptions.wsPort}`;
console.log(`---------------------------------------------`);
console.log(``);
console.log(`To launch the editor, open this URL:`);
console.log(start);
console.log(``);
console.log(`---------------------------------------------`);
if (options.autoStart) {
nodeutil.openUrl(start, options.browser);
}
});
}
``` | /content/code_sandbox/cli/server.ts | xml | 2016-01-24T19:35:52 | 2024-08-16T16:39:39 | pxt | microsoft/pxt | 2,069 | 10,584 |
```xml
// This file is part of Moonfire NVR, a security camera network video recorder.
import CssBaseline from "@mui/material/CssBaseline";
import {
Experimental_CssVarsProvider,
experimental_extendTheme,
} from "@mui/material/styles";
import StyledEngineProvider from "@mui/material/StyledEngineProvider";
import { LocalizationProvider } from "@mui/x-date-pickers/LocalizationProvider";
import "@fontsource/roboto";
import React from "react";
import { createRoot } from "react-dom/client";
import App from "./App";
import ErrorBoundary from "./ErrorBoundary";
import { SnackbarProvider } from "./snackbars";
import { AdapterDateFns } from "@mui/x-date-pickers/AdapterDateFns";
import "./index.css";
import { HashRouter } from "react-router-dom";
import ThemeMode from "./components/ThemeMode";
const themeExtended = experimental_extendTheme({
colorSchemes: {
dark: {
palette: {
primary: {
main: "#000000",
},
secondary: {
main: "#e65100",
},
},
},
},
});
const container = document.getElementById("root");
const root = createRoot(container!);
root.render(
<React.StrictMode>
<StyledEngineProvider injectFirst>
{/* <ThemeProvider theme={theme}> */}
<Experimental_CssVarsProvider defaultMode="system" theme={themeExtended}>
<CssBaseline />
<ThemeMode>
<ErrorBoundary>
<LocalizationProvider dateAdapter={AdapterDateFns}>
<SnackbarProvider autoHideDuration={5000}>
<HashRouter>
<App />
</HashRouter>
</SnackbarProvider>
</LocalizationProvider>
</ErrorBoundary>
</ThemeMode>
</Experimental_CssVarsProvider>
{/* </ThemeProvider> */}
</StyledEngineProvider>
</React.StrictMode>
);
``` | /content/code_sandbox/ui/src/index.tsx | xml | 2016-01-02T06:05:42 | 2024-08-16T11:13:05 | moonfire-nvr | scottlamb/moonfire-nvr | 1,209 | 390 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="path_to_url" xmlns:flowable="path_to_url" typeLanguage="path_to_url"
expressionLanguage="path_to_url" targetNamespace="Examples">
<process id="scriptExecutionListenerProcess" name="Script Execution Listener Example">
<startEvent id="startevent1" name="Start"></startEvent>
<sequenceFlow id="flow1" name="" sourceRef="startevent1" targetRef="endevent1">
<extensionElements>
<flowable:executionListener event="take" type="script">
<flowable:script language="JavaScript" resultVariable="myVar"><![CDATA[var MyError = Packages.java.lang.RuntimeException;
throw new MyError("Illegal argument in listener");]]>
</flowable:script>
</flowable:executionListener>
</extensionElements>
</sequenceFlow>
<endEvent id="endevent1" name="End"></endEvent>
</process>
</definitions>
``` | /content/code_sandbox/modules/flowable-engine/src/test/resources/org/flowable/examples/bpmn/executionlistener/ScriptTypeExecutionListenerTest.testThrowNonFlowableException.bpmn20.xml | xml | 2016-10-13T07:21:43 | 2024-08-16T15:23:14 | flowable-engine | flowable/flowable-engine | 7,715 | 221 |
```xml
import { ILocationOption } from "@erxes/api-utils/src/types";
import { Document, Schema } from "mongoose";
import { field, schemaWrapper } from "./utils";
import { INPUT_TYPE } from "../../../constants";
export interface ISubmission {
_id: string;
value: any;
type?: string;
validation?: string;
associatedFieldId?: string;
stageId?: string;
groupId?: string;
column?: number;
productId?: string;
regexValidation?: string;
}
export interface ILogic {
fieldId: string;
tempFieldId?: string;
logicOperator?: string;
logicValue?: string | number | Date | string[];
}
export const logicSchema = new Schema(
{
fieldId: field({ type: String }),
logicOperator: field({
type: String,
optional: true
}),
logicValue: field({
type: Schema.Types.Mixed,
optional: true
})
},
{ _id: false }
);
const ObjectListSchema = new Schema({
key: field({ type: String, optional: true, label: "Key" }),
label: field({ type: String, optional: true, label: "Label" }),
type: field({
type: String,
enum: INPUT_TYPE.map(option => option.value),
optional: true,
label: "Type"
})
});
interface IVisibility {
isVisible?: boolean;
isVisibleInDetail?: boolean;
}
interface IObjectListConfig {
key: string;
label: string;
type: string;
}
export interface IField extends IVisibility {
contentType?: string;
contentTypeId?: string;
type?: string;
validation?: string;
regexValidation?: string;
text: string;
content?: string;
description?: string;
options?: string[];
locationOptions?: ILocationOption[];
objectListConfigs?: IObjectListConfig[];
optionsValues?: string;
isRequired?: boolean;
isDefinedByErxes?: boolean;
isVisibleToCreate?: boolean;
isPermanent?: boolean;
isLocked?: boolean;
order?: number;
groupId?: string;
canHide?: boolean;
lastUpdatedUserId?: string;
associatedFieldId?: string;
code?: string;
logics?: ILogic[];
logicAction?: string;
tempFieldId?: string;
column?: number;
groupName?: string;
pageNumber?: number;
showInCard?: boolean;
productCategoryId?: string;
relationType?: string;
subFieldIds?: string[];
}
export interface IFieldDocument extends IField, Document {
_id: string;
}
export interface IFieldGroup extends IVisibility {
name?: string;
contentType?: string;
parentId?: string;
order?: number;
isDefinedByErxes?: boolean;
alwaysOpen?: boolean;
description?: string;
lastUpdatedUserId?: string;
code?: string;
config?: any;
logics?: ILogic[];
logicAction?: string;
}
export interface IFieldGroupDocument extends IFieldGroup, Document {
_id: string;
}
// Mongoose schemas =============
export const fieldSchema = schemaWrapper(
new Schema({
_id: field({ pkey: true }),
// form, customer, company
contentType: field({ type: String, label: "Content type" }),
// formId when contentType is form
contentTypeId: field({ type: String, label: "Content type item" }),
type: field({ type: String, label: "Type" }),
validation: field({
type: String,
optional: true,
label: "Validation"
}),
regexValidation: field({
type: String,
optional: true,
label: "Regex validation"
}),
text: field({ type: String, label: "Text" }),
field: field({ type: String, optional: true, label: "Field identifier" }),
description: field({
type: String,
optional: true,
label: "Description"
}),
code: field({
type: String,
optional: true,
label: "Unique code"
}),
options: field({
type: [String],
optional: true,
label: "Options"
}),
locationOptions: field({
type: Array,
optional: true,
label: "Location Options"
}),
objectListConfigs: field({
type: [ObjectListSchema],
optional: true,
label: "object list config"
}),
optionsValues: field({
type: String,
label: "Field Options object"
}),
isRequired: field({ type: Boolean, label: "Is required" }),
isDefinedByErxes: field({ type: Boolean, label: "Is defined by erxes" }),
order: field({ type: Number, label: "Order" }),
groupId: field({ type: String, label: "Field group" }),
isVisible: field({ type: Boolean, default: true, label: "Is visible" }),
isVisibleInDetail: field({
type: Boolean,
default: true,
label: "Is group visible in detail"
}),
canHide: field({
type: Boolean,
default: true,
label: "Can toggle isVisible"
}),
isVisibleToCreate: field({
type: Boolean,
default: false,
label: "Is visible to create"
}),
searchable: field({
type: Boolean,
default: false,
label: "Useful for searching"
}),
lastUpdatedUserId: field({ type: String, label: "Last updated by" }),
associatedFieldId: field({
type: String,
optional: true,
label: "Stores custom property fieldId for form field id"
}),
logics: field({ type: [logicSchema] }),
column: field({ type: Number, optional: true }),
logicAction: field({
type: String,
label:
"If action is show field will appear when logics fulfilled, if action is hide it will disappear when logic fulfilled"
}),
content: field({
type: String,
optional: true,
label: "Stores html content form of field type with html"
}),
pageNumber: field({
type: Number,
optional: true,
label: "Number of page",
min: 1
}),
showInCard: field({
type: Boolean,
default: false,
optional: true,
label: "Show in card"
}),
productCategoryId: field({
type: String,
optional: true,
label: "Product category"
}),
relationType: field({
type: String,
optional: true,
label: "Relation type"
}),
subFieldIds: field({
type: [String],
optional: true,
label: "Sub field ids"
})
})
);
export const fieldGroupSchema = schemaWrapper(
new Schema({
_id: field({ pkey: true }),
name: field({ type: String, label: "Name" }),
// customer, company
contentType: field({
type: String,
label: "Content type"
}),
order: field({ type: Number, label: "Order" }),
isDefinedByErxes: field({
type: Boolean,
default: false,
label: "Is defined by erxes"
}),
description: field({ type: String, label: "Description" }),
parentId: field({ type: String, label: "Parent Group ID", optional: true }),
code: field({
type: String,
optional: true,
label: "Unique code"
}),
// Id of user who updated the group
lastUpdatedUserId: field({ type: String, label: "Last updated by" }),
isMultiple: field({ type: Boolean, default: false, label: "Is multple" }),
isVisible: field({ type: Boolean, default: true, label: "Is visible" }),
isVisibleInDetail: field({
type: Boolean,
default: true,
label: "Is group visible in detail"
}),
alwaysOpen: field({
type: Boolean,
default: false,
label: "Always open"
}),
config: { type: Object },
logics: field({ type: [logicSchema] }),
logicAction: field({
type: String,
label:
"If action is show field will appear when logics fulfilled, if action is hide it will disappear when logic fulfilled"
})
})
);
``` | /content/code_sandbox/packages/core/src/db/models/definitions/fields.ts | xml | 2016-11-11T06:54:50 | 2024-08-16T10:26:06 | erxes | erxes/erxes | 3,479 | 1,843 |
```xml
import * as React from 'react';
import { getIntrinsicElementProps, slot } from '@fluentui/react-utilities';
import type { BreadcrumbDividerProps, BreadcrumbDividerState } from './BreadcrumbDivider.types';
import { ChevronRightRegular, ChevronLeftRegular } from '@fluentui/react-icons';
import { useBreadcrumbContext_unstable } from '../Breadcrumb/BreadcrumbContext';
import { useFluent_unstable as useFluent } from '@fluentui/react-shared-contexts';
/**
* Create the state required to render BreadcrumbDivider.
*
* The returned state can be modified with hooks such as useBreadcrumbDividerStyles_unstable,
* before being passed to renderBreadcrumbDivider_unstable.
*
* @param props - props from this instance of BreadcrumbDivider
* @param ref - reference to root HTMLElement of BreadcrumbDivider
*/
export const useBreadcrumbDivider_unstable = (
props: BreadcrumbDividerProps,
ref: React.Ref<HTMLLIElement>,
): BreadcrumbDividerState => {
const { size } = useBreadcrumbContext_unstable();
const { dir } = useFluent();
const icon = getDividerIcon(dir);
return {
components: {
root: 'li',
},
root: slot.always(
getIntrinsicElementProps('li', {
ref,
'aria-hidden': true,
children: icon,
...props,
}),
{ elementType: 'li' },
),
size,
};
};
/**
* Get icon of the divider
*
* @param dir - RTL or LTR
*/
function getDividerIcon(dir: string) {
return dir === 'rtl' ? <ChevronLeftRegular /> : <ChevronRightRegular />;
}
``` | /content/code_sandbox/packages/react-components/react-breadcrumb/library/src/components/BreadcrumbDivider/useBreadcrumbDivider.tsx | xml | 2016-06-06T15:03:44 | 2024-08-16T18:49:29 | fluentui | microsoft/fluentui | 18,221 | 358 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<android.support.v7.widget.CardView
android:id="@+id/home_item_root_view"
xmlns:android="path_to_url"
xmlns:app="path_to_url"
xmlns:tools="path_to_url"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginBottom="4dp"
android:layout_marginLeft="2dp"
android:layout_marginRight="2dp"
app:cardBackgroundColor="?android:attr/itemBackground"
app:cardCornerRadius="2dp"
app:cardElevation="0dp">
<RelativeLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:padding="2dp"
android:orientation="vertical">
<!--android:background="?android:attr/itemBackground"-->
<ImageView
android:id="@+id/iv_video_summary"
android:layout_width="100dp"
android:layout_height="100dp"
android:scaleType="centerCrop"
android:transitionName="photos"
tools:src="@drawable/ic_header"/>
<TextView
android:id="@+id/tv_video_summary"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignRight="@id/iv_video_summary"
android:layout_below="@id/iv_video_summary"
android:paddingTop="8dp"
android:paddingLeft="6dp"
android:paddingRight="6dp"
android:paddingBottom="6dp"
android:textColor="?android:attr/textColorSecondary"
android:textAppearance="@style/TextAppearance.AppCompat.Caption"
tools:text="Sunshine"/>
</RelativeLayout>
</android.support.v7.widget.CardView>
``` | /content/code_sandbox/app/src/main/res/layout/item_video_summary.xml | xml | 2016-02-29T16:24:11 | 2024-08-07T10:06:04 | OuNews | oubowu/OuNews | 1,574 | 390 |
```xml
/*
* @license Apache-2.0
*
*
*
* path_to_url
*
* Unless required by applicable law or agreed to in writing, software
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*/
// TypeScript Version: 4.1
/// <reference types="@stdlib/types"/>
/**
* If provided a value, returns an updated sum; otherwise, returns the current sum.
*
* ## Notes
*
* - If provided `NaN` or a value which, when used in computations, results in `NaN`, the accumulated value is `NaN` for all future invocations.
*
* @param x - value
* @returns sum
*/
type accumulator = ( x?: number ) => number | null;
/**
* Returns an accumulator function which incrementally computes a moving sum.
*
* ## Notes
*
* - The `W` parameter defines the number of values over which to compute the moving sum.
* - As `W` values are needed to fill the window buffer, the first `W-1` returned values are calculated from smaller sample sizes. Until the window is full, each returned value is calculated from all provided values.
*
* @param W - window size
* @throws must provide a positive integer
* @returns accumulator function
*
* @example
* var accumulator = incrmsum( 3 );
*
* var sum = accumulator();
* // returns null
*
* sum = accumulator( 2.0 );
* // returns 2.0
*
* sum = accumulator( -5.0 );
* // returns -3.0
*
* sum = accumulator( 3.0 );
* // returns 0.0
*
* sum = accumulator( 5.0 );
* // returns 3.0
*
* sum = accumulator();
* // returns 3.0
*/
declare function incrmsum( W: number ): accumulator;
// EXPORTS //
export = incrmsum;
``` | /content/code_sandbox/lib/node_modules/@stdlib/stats/incr/msum/docs/types/index.d.ts | xml | 2016-03-24T04:19:52 | 2024-08-16T09:03:19 | stdlib | stdlib-js/stdlib | 4,266 | 409 |
```xml
import React, { useMemo } from 'react';
import { useEventCallback } from '@/internals/hooks';
import useTreeValue from './hooks/useTreeValue';
import CheckTreeView, { type CheckTreeViewProps } from './CheckTreeView';
import useFlattenTree from '../Tree/hooks/useFlattenTree';
import useTreeWithChildren from '../Tree/hooks/useTreeWithChildren';
import useExpandTree from '../Tree/hooks/useExpandTree';
import { TreeProvider } from '@/internals/Tree/TreeProvider';
import type { RsRefForwardingComponent } from '@/internals/types';
import type { TreeExtraProps } from '../Tree/types';
export type ValueType = (string | number)[];
export interface CheckTreeProps<T = ValueType> extends CheckTreeViewProps<T>, TreeExtraProps {
/**
* Default selected Value
*/
defaultValue?: T;
/**
* The shadow of the content when scrolling
*/
scrollShadow?: boolean;
}
/**
* The `CheckTree` component is used for selecting multiple options which are organized in a tree structure.
* @see path_to_url
*/
const CheckTree: RsRefForwardingComponent<'div', CheckTreeProps> = React.forwardRef(
(props, ref: React.Ref<HTMLDivElement>) => {
const {
value: controlledValue,
data,
defaultValue,
defaultExpandAll = false,
defaultExpandItemValues = [],
uncheckableItemValues,
expandItemValues: controlledExpandItemValues,
childrenKey = 'children',
labelKey = 'label',
valueKey = 'value',
virtualized,
cascade = true,
scrollShadow,
renderTreeIcon,
renderTreeNode,
getChildren,
onExpand,
onChange,
...rest
} = props;
const [value, setValue] = useTreeValue(controlledValue, {
defaultValue,
uncheckableItemValues
});
const itemDataKeys = { childrenKey, labelKey, valueKey };
const { treeData, loadingNodeValues, appendChild } = useTreeWithChildren(data, itemDataKeys);
const { expandItemValues, handleExpandTreeNode } = useExpandTree(data, {
...itemDataKeys,
defaultExpandAll,
defaultExpandItemValues,
controlledExpandItemValues,
onExpand,
getChildren,
appendChild
});
const flattenedNodes = useFlattenTree(treeData, {
...itemDataKeys,
uncheckableItemValues,
multiple: true,
cascade,
value
});
const handleChange = useEventCallback((nextValue: ValueType, event: React.SyntheticEvent) => {
setValue(nextValue);
onChange?.(nextValue, event);
});
const treeContext = useMemo(
() => ({
props: {
labelKey,
valueKey,
childrenKey,
virtualized,
scrollShadow,
renderTreeIcon,
renderTreeNode
}
}),
[childrenKey, labelKey, valueKey, virtualized, scrollShadow, renderTreeIcon, renderTreeNode]
);
return (
<TreeProvider value={treeContext}>
<CheckTreeView
{...rest}
ref={ref}
value={value}
cascade={cascade}
data={treeData}
loadingNodeValues={loadingNodeValues}
flattenedNodes={flattenedNodes}
uncheckableItemValues={uncheckableItemValues}
expandItemValues={expandItemValues}
onChange={handleChange}
onExpand={handleExpandTreeNode}
/>
</TreeProvider>
);
}
);
CheckTree.displayName = 'CheckTree';
export default CheckTree;
``` | /content/code_sandbox/src/CheckTree/CheckTree.tsx | xml | 2016-06-06T02:27:46 | 2024-08-16T16:41:54 | rsuite | rsuite/rsuite | 8,263 | 764 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="14113" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" colorMatched="YES" initialViewController="o5S-Pz-giN">
<device id="retina4_7" orientation="portrait">
<adaptation id="fullscreen"/>
</device>
<dependencies>
<deployment identifier="iOS"/>
<plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="14088"/>
<capability name="Constraints to layout margins" minToolsVersion="6.0"/>
<capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
</dependencies>
<scenes>
<!--Navigation Controller-->
<scene sceneID="jK6-G9-h8d">
<objects>
<navigationController storyboardIdentifier="IndividualEventNavController" id="o5S-Pz-giN" sceneMemberID="viewController">
<navigationBar key="navigationBar" contentMode="scaleToFill" id="3q8-XM-GmX">
<rect key="frame" x="0.0" y="20" width="375" height="44"/>
<autoresizingMask key="autoresizingMask"/>
<color key="barTintColor" red="0.8264998197555542" green="0.0" blue="0.019660282880067825" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<textAttributes key="titleTextAttributes">
<color key="textColor" red="0.97479069232940674" green="1" blue="0.97394168376922607" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
</textAttributes>
</navigationBar>
<connections>
<segue destination="7sQ-cA-ql5" kind="relationship" relationship="rootViewController" id="3Gk-Qs-Pr8"/>
</connections>
</navigationController>
<placeholder placeholderIdentifier="IBFirstResponder" id="5y1-ck-Rdu" userLabel="First Responder" sceneMemberID="firstResponder"/>
</objects>
<point key="canvasLocation" x="2337" y="-274"/>
</scene>
<!--Navigation Controller-->
<scene sceneID="edo-R3-haB">
<objects>
<navigationController storyboardIdentifier="SessionEmptyStateViewController" id="MzQ-Xy-RbM" sceneMemberID="viewController">
<navigationBar key="navigationBar" contentMode="scaleToFill" id="olo-Dx-IT8">
<rect key="frame" x="0.0" y="20" width="375" height="44"/>
<autoresizingMask key="autoresizingMask"/>
<color key="barTintColor" red="0.8264998197555542" green="0.0" blue="0.019660282880067825" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
</navigationBar>
<connections>
<segue destination="oWk-Ig-N2H" kind="relationship" relationship="rootViewController" id="7Xk-uc-YkG"/>
</connections>
</navigationController>
<placeholder placeholderIdentifier="IBFirstResponder" id="Eye-XP-OcK" userLabel="First Responder" sceneMemberID="firstResponder"/>
</objects>
<point key="canvasLocation" x="2327" y="476"/>
</scene>
<!--View Controller-->
<scene sceneID="pCM-Cq-7tk">
<objects>
<viewController id="oWk-Ig-N2H" sceneMemberID="viewController">
<layoutGuides>
<viewControllerLayoutGuide type="top" id="yHj-GE-3xZ"/>
<viewControllerLayoutGuide type="bottom" id="Q7F-NH-dL4"/>
</layoutGuides>
<view key="view" contentMode="scaleToFill" id="m9v-0e-Lfa">
<rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
<autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
<subviews>
<stackView opaque="NO" contentMode="scaleToFill" axis="vertical" distribution="equalCentering" alignment="center" spacing="24" translatesAutoresizingMaskIntoConstraints="NO" id="XWn-qC-jdB">
<rect key="frame" x="48.5" y="197" width="278" height="273"/>
<subviews>
<label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Welcome to FOSSAsia!" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="Mvz-Vv-sWY">
<rect key="frame" x="51.5" y="0.0" width="175.5" height="20.5"/>
<fontDescription key="fontDescription" type="system" pointSize="17"/>
<color key="textColor" red="0.0" green="0.0" blue="0.0" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<nil key="highlightedColor"/>
</label>
<imageView userInteractionEnabled="NO" contentMode="scaleToFill" horizontalHuggingPriority="251" verticalHuggingPriority="251" image="welcome_glyph" translatesAutoresizingMaskIntoConstraints="NO" id="IJP-ZR-tR0">
<rect key="frame" x="47.5" y="45" width="183" height="183"/>
<constraints>
<constraint firstAttribute="width" constant="183" id="JpJ-nM-4FK"/>
<constraint firstAttribute="height" constant="183" id="aPX-9Y-nj5"/>
</constraints>
</imageView>
<label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Select a session on the left to begin!" textAlignment="natural" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="IoJ-Ub-p6l">
<rect key="frame" x="0.5" y="252.5" width="277.5" height="20.5"/>
<fontDescription key="fontDescription" type="system" pointSize="17"/>
<color key="textColor" red="0.0" green="0.0" blue="0.0" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<nil key="highlightedColor"/>
</label>
</subviews>
<constraints>
<constraint firstAttribute="height" constant="273" id="3Mz-Is-kmz"/>
<constraint firstAttribute="width" constant="278" id="kzL-E3-ucI"/>
</constraints>
</stackView>
</subviews>
<color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<constraints>
<constraint firstItem="XWn-qC-jdB" firstAttribute="centerX" secondItem="m9v-0e-Lfa" secondAttribute="centerX" id="KOD-4h-baR"/>
<constraint firstItem="XWn-qC-jdB" firstAttribute="centerY" secondItem="m9v-0e-Lfa" secondAttribute="centerY" id="Nye-BD-0qN"/>
</constraints>
</view>
<navigationItem key="navigationItem" id="vxR-AL-knK"/>
</viewController>
<placeholder placeholderIdentifier="IBFirstResponder" id="plU-LB-gMt" userLabel="First Responder" sceneMemberID="firstResponder"/>
</objects>
<point key="canvasLocation" x="3146" y="476"/>
</scene>
<!--Event-->
<scene sceneID="Udv-0b-z2n">
<objects>
<viewController storyboardIdentifier="EventViewController" automaticallyAdjustsScrollViewInsets="NO" id="7sQ-cA-ql5" customClass="EventViewController" customModule="FOSSAsia" customModuleProvider="target" sceneMemberID="viewController">
<layoutGuides>
<viewControllerLayoutGuide type="top" id="0Z8-bz-0zu"/>
<viewControllerLayoutGuide type="bottom" id="Cva-T1-Cte"/>
</layoutGuides>
<view key="view" contentMode="scaleToFill" id="ljF-ga-Apg">
<rect key="frame" x="0.0" y="0.0" width="375" height="603"/>
<autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
<subviews>
<scrollView clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="scaleToFill" showsHorizontalScrollIndicator="NO" translatesAutoresizingMaskIntoConstraints="NO" id="iYz-ho-dCf">
<rect key="frame" x="-4" y="0.0" width="383" height="603"/>
<subviews>
<view contentMode="scaleToFill" verticalHuggingPriority="251" verticalCompressionResistancePriority="749" placeholderIntrinsicWidth="600" placeholderIntrinsicHeight="488" translatesAutoresizingMaskIntoConstraints="NO" id="ov1-VO-pkC" userLabel="Content View">
<rect key="frame" x="0.0" y="0.0" width="383" height="603.5"/>
<subviews>
<view contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="UQs-dw-Qdl" userLabel="Talk Description View" customClass="EventInfoView" customModule="FOSSAsia" customModuleProvider="target">
<rect key="frame" x="8" y="8" width="367" height="93.5"/>
<subviews>
<label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Santosh Viswanatham" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="b3B-gf-smR">
<rect key="frame" x="8" y="36.5" width="351" height="20.5"/>
<fontDescription key="fontDescription" type="system" pointSize="17"/>
<color key="textColor" red="0.3255770206451416" green="0.33555895090103149" blue="0.38799157738685608" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<nil key="highlightedColor"/>
</label>
<label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Mozilla JFDI Blk71" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="0XL-9Z-ufs">
<rect key="frame" x="8" y="65" width="351" height="20.5"/>
<fontDescription key="fontDescription" type="system" pointSize="17"/>
<color key="textColor" red="0.3255770206451416" green="0.33555895090103149" blue="0.38799157738685608" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<nil key="highlightedColor"/>
</label>
<label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Collaborative Webmaking using TogetherJS" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="6KL-h6-aGX">
<rect key="frame" x="8" y="8" width="351" height="20.5"/>
<fontDescription key="fontDescription" type="system" weight="semibold" pointSize="17"/>
<color key="textColor" red="0.21433287858963013" green="0.22071753442287445" blue="0.25580373406410217" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<nil key="highlightedColor"/>
</label>
</subviews>
<color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<constraints>
<constraint firstItem="0XL-9Z-ufs" firstAttribute="leading" secondItem="UQs-dw-Qdl" secondAttribute="leading" constant="8" id="0Xc-O8-hkp"/>
<constraint firstItem="0XL-9Z-ufs" firstAttribute="top" secondItem="b3B-gf-smR" secondAttribute="bottom" constant="8" id="57V-zB-ds8"/>
<constraint firstItem="6KL-h6-aGX" firstAttribute="leading" secondItem="UQs-dw-Qdl" secondAttribute="leading" constant="8" id="Gjb-bp-vgg"/>
<constraint firstAttribute="bottom" secondItem="0XL-9Z-ufs" secondAttribute="bottom" constant="8" id="HXq-eq-1wZ"/>
<constraint firstAttribute="trailing" secondItem="6KL-h6-aGX" secondAttribute="trailing" constant="8" id="a62-lS-6ql"/>
<constraint firstAttribute="trailing" secondItem="b3B-gf-smR" secondAttribute="trailing" constant="8" id="kEs-ur-YdQ"/>
<constraint firstItem="6KL-h6-aGX" firstAttribute="top" secondItem="UQs-dw-Qdl" secondAttribute="top" constant="8" id="lQX-uL-cKd"/>
<constraint firstItem="b3B-gf-smR" firstAttribute="top" secondItem="6KL-h6-aGX" secondAttribute="bottom" constant="8" id="oIv-8U-wgH"/>
<constraint firstAttribute="trailing" secondItem="0XL-9Z-ufs" secondAttribute="trailing" constant="8" id="pik-a8-0ax"/>
<constraint firstItem="b3B-gf-smR" firstAttribute="top" secondItem="6KL-h6-aGX" secondAttribute="bottom" constant="8" id="tUQ-Im-8Tv"/>
<constraint firstItem="0XL-9Z-ufs" firstAttribute="top" secondItem="b3B-gf-smR" secondAttribute="bottom" constant="8" id="ufk-4P-vuX"/>
<constraint firstItem="b3B-gf-smR" firstAttribute="leading" secondItem="UQs-dw-Qdl" secondAttribute="leading" constant="8" id="ylt-5s-pVk"/>
</constraints>
<connections>
<outlet property="eventLabel" destination="6KL-h6-aGX" id="lxL-p3-mBn"/>
<outlet property="locationLabel" destination="0XL-9Z-ufs" id="g7G-ss-W0u"/>
<outlet property="speakerLabel" destination="b3B-gf-smR" id="HsG-Ge-cJD"/>
</connections>
</view>
<view contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="l1P-zW-uzf">
<rect key="frame" x="0.0" y="109.5" width="383" height="1"/>
<color key="backgroundColor" red="0.86793619394302368" green="0.86875742673873901" blue="0.86803185939788818" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<constraints>
<constraint firstAttribute="height" constant="1" id="a6Y-pA-CMj"/>
<constraint firstAttribute="height" constant="1" id="h5d-jW-MKa"/>
</constraints>
<variation key="default">
<mask key="constraints">
<exclude reference="h5d-jW-MKa"/>
</mask>
</variation>
</view>
<textView clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="scaleToFill" scrollEnabled="NO" editable="NO" translatesAutoresizingMaskIntoConstraints="NO" id="hnB-J0-qpW">
<rect key="frame" x="8" y="118.5" width="367" height="360"/>
<color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<string key="text">Collaboration is an amazing option which adds beauty to work,reduces work burden,helps in Innovation and many more by enhancing teamwork option and enabling people to work collectively. TogetherJS is an Open source javascript library which adds collaborative features to a website.Thimble is an amazing Webmaker Tool which helps you to create Webpages and instantly preview your work.You can even publish the created webpages with a Single click.Awesomeness is when these two gets combine "Thimble" and "TogetherJS" where more than one person can work and code on a single webpage.Two or more people can work on a single webpage and instantly view the output.They can even discuss with the help of chatbox.
</string>
<fontDescription key="fontDescription" type="system" weight="light" pointSize="16"/>
<textInputTraits key="textInputTraits" autocapitalizationType="sentences"/>
</textView>
<label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" text="Monday, 8 June, 10:00AM - 12:00PM" textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="LVQ-C4-9Wm">
<rect key="frame" x="65" y="514.5" width="253.5" height="18"/>
<fontDescription key="fontDescription" type="system" pointSize="15"/>
<color key="textColor" red="0.0" green="0.0" blue="0.0" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<nil key="highlightedColor"/>
</label>
<button opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" lineBreakMode="middleTruncation" translatesAutoresizingMaskIntoConstraints="NO" id="xOk-0C-oEj">
<rect key="frame" x="69.5" y="550.5" width="244" height="35"/>
<constraints>
<constraint firstAttribute="width" constant="244" id="1FK-n9-LVP"/>
<constraint firstAttribute="height" constant="35" id="j1W-HR-LOZ"/>
</constraints>
<state key="normal" image="calendar_add_btn"/>
<state key="selected" image="calendar_add_btn_selected"/>
<state key="highlighted" image="calendar_add_btn_selected"/>
<connections>
<action selector="eventAddToCalendar:" destination="7sQ-cA-ql5" eventType="touchUpInside" id="XY4-U3-kM2"/>
</connections>
</button>
<view contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="mCu-OM-EsL">
<rect key="frame" x="0.0" y="494.5" width="383" height="1"/>
<color key="backgroundColor" red="0.86793619394302368" green="0.86875742673873901" blue="0.86803185939788818" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<constraints>
<constraint firstAttribute="height" constant="1" id="GId-f3-DJr"/>
<constraint firstAttribute="height" constant="1" id="QSn-bx-chZ"/>
</constraints>
<variation key="default">
<mask key="constraints">
<exclude reference="QSn-bx-chZ"/>
</mask>
</variation>
</view>
</subviews>
<color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<constraints>
<constraint firstItem="hnB-J0-qpW" firstAttribute="centerX" secondItem="ov1-VO-pkC" secondAttribute="centerX" id="1IB-yt-UZe"/>
<constraint firstItem="xOk-0C-oEj" firstAttribute="centerX" secondItem="LVQ-C4-9Wm" secondAttribute="centerX" id="3CS-Ng-dea"/>
<constraint firstItem="l1P-zW-uzf" firstAttribute="centerX" secondItem="ov1-VO-pkC" secondAttribute="centerX" id="4YY-J4-kob"/>
<constraint firstAttribute="bottom" secondItem="xOk-0C-oEj" secondAttribute="bottom" constant="18" id="5Wm-gi-6vc"/>
<constraint firstItem="LVQ-C4-9Wm" firstAttribute="top" secondItem="mCu-OM-EsL" secondAttribute="bottom" constant="19" id="7nB-sY-gld"/>
<constraint firstItem="xOk-0C-oEj" firstAttribute="top" secondItem="LVQ-C4-9Wm" secondAttribute="bottom" constant="18" id="BtD-2s-i0C"/>
<constraint firstAttribute="trailing" secondItem="l1P-zW-uzf" secondAttribute="trailing" id="Diu-m6-4yp"/>
<constraint firstItem="hnB-J0-qpW" firstAttribute="top" secondItem="l1P-zW-uzf" secondAttribute="bottom" constant="8" id="QL1-A3-8Ag"/>
<constraint firstItem="UQs-dw-Qdl" firstAttribute="top" secondItem="ov1-VO-pkC" secondAttribute="top" constant="8" id="Yt3-5d-f2G"/>
<constraint firstAttribute="height" constant="1024" id="ZIR-n1-E9O"/>
<constraint firstItem="mCu-OM-EsL" firstAttribute="top" secondItem="hnB-J0-qpW" secondAttribute="bottom" constant="16" id="bPK-mP-IlN"/>
<constraint firstItem="l1P-zW-uzf" firstAttribute="top" secondItem="UQs-dw-Qdl" secondAttribute="bottom" constant="8" id="c9W-Ig-dwS"/>
<constraint firstAttribute="trailing" secondItem="UQs-dw-Qdl" secondAttribute="trailing" constant="8" id="cPb-w6-xjn"/>
<constraint firstItem="LVQ-C4-9Wm" firstAttribute="centerX" secondItem="hnB-J0-qpW" secondAttribute="centerX" id="e0P-Mb-hrP"/>
<constraint firstItem="UQs-dw-Qdl" firstAttribute="centerX" secondItem="ov1-VO-pkC" secondAttribute="centerX" id="fBl-Sm-mkH"/>
<constraint firstItem="l1P-zW-uzf" firstAttribute="leading" secondItem="ov1-VO-pkC" secondAttribute="leading" id="pfS-BU-x1X"/>
<constraint firstAttribute="trailing" secondItem="mCu-OM-EsL" secondAttribute="trailing" id="sZT-yo-NBz"/>
<constraint firstItem="mCu-OM-EsL" firstAttribute="leading" secondItem="ov1-VO-pkC" secondAttribute="leading" id="tcG-Fr-3MW"/>
<constraint firstItem="UQs-dw-Qdl" firstAttribute="leading" secondItem="ov1-VO-pkC" secondAttribute="leading" constant="8" id="uP9-lA-wrQ"/>
<constraint firstAttribute="trailing" secondItem="hnB-J0-qpW" secondAttribute="trailing" constant="8" id="xEq-m1-NG3"/>
</constraints>
<variation key="default">
<mask key="constraints">
<exclude reference="ZIR-n1-E9O"/>
</mask>
</variation>
</view>
</subviews>
<constraints>
<constraint firstAttribute="bottom" secondItem="ov1-VO-pkC" secondAttribute="bottom" constant="-488" id="9Tb-i9-HLF"/>
<constraint firstItem="ov1-VO-pkC" firstAttribute="centerY" secondItem="iYz-ho-dCf" secondAttribute="centerY" id="E7w-Yh-4Uj"/>
<constraint firstItem="ov1-VO-pkC" firstAttribute="leading" secondItem="iYz-ho-dCf" secondAttribute="leading" id="E8V-kM-XPb"/>
<constraint firstAttribute="bottom" secondItem="ov1-VO-pkC" secondAttribute="bottom" id="H99-oA-DQ6"/>
<constraint firstAttribute="trailing" secondItem="ov1-VO-pkC" secondAttribute="trailing" id="LBX-1a-07o"/>
<constraint firstItem="ov1-VO-pkC" firstAttribute="top" secondItem="iYz-ho-dCf" secondAttribute="top" id="aT4-TU-3u3"/>
<constraint firstItem="ov1-VO-pkC" firstAttribute="centerX" secondItem="iYz-ho-dCf" secondAttribute="centerX" id="y6R-9n-h8Z"/>
</constraints>
<variation key="default">
<mask key="constraints">
<exclude reference="E7w-Yh-4Uj"/>
<exclude reference="H99-oA-DQ6"/>
</mask>
</variation>
</scrollView>
</subviews>
<color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<constraints>
<constraint firstItem="iYz-ho-dCf" firstAttribute="top" secondItem="0Z8-bz-0zu" secondAttribute="bottom" id="8Jq-8k-RqP"/>
<constraint firstItem="Cva-T1-Cte" firstAttribute="top" secondItem="iYz-ho-dCf" secondAttribute="bottom" id="L7e-w6-XCL"/>
<constraint firstAttribute="trailingMargin" secondItem="iYz-ho-dCf" secondAttribute="trailing" constant="-20" id="OEn-gd-YRh"/>
<constraint firstItem="iYz-ho-dCf" firstAttribute="leading" secondItem="ljF-ga-Apg" secondAttribute="leadingMargin" constant="-20" id="R1M-nd-5Vf"/>
</constraints>
</view>
<navigationItem key="navigationItem" title="Event" id="uVq-Bq-U0U">
<barButtonItem key="backBarButtonItem" id="p0T-Qj-CDs">
<color key="tintColor" red="0.99495029449462891" green="0.98418152332305908" blue="0.82213884592056274" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
</barButtonItem>
<barButtonItem key="rightBarButtonItem" image="navbar_fave" id="25w-e6-2aO">
<color key="tintColor" red="0.99495029449462891" green="0.98418152332305908" blue="0.82213884592056274" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
<connections>
<action selector="favoriteEvent:" destination="7sQ-cA-ql5" id="kt2-UF-99I"/>
</connections>
</barButtonItem>
</navigationItem>
<simulatedNavigationBarMetrics key="simulatedTopBarMetrics" translucent="NO" prompted="NO"/>
<connections>
<outlet property="contentView" destination="ov1-VO-pkC" id="bBJ-0u-cJn"/>
<outlet property="eventAddToCalendarButton" destination="xOk-0C-oEj" id="cci-nI-H5u"/>
<outlet property="eventAddToCalendarButtonBottomConstraint" destination="5Wm-gi-6vc" id="BwJ-YP-O1P"/>
<outlet property="eventDateTimeLabel" destination="LVQ-C4-9Wm" id="Fxq-1V-tqH"/>
<outlet property="eventDescriptionTextView" destination="hnB-J0-qpW" id="1lK-Dh-e1m"/>
<outlet property="eventInfoView" destination="UQs-dw-Qdl" id="djP-eg-MW7"/>
<outlet property="navBarButtonItem" destination="25w-e6-2aO" id="HdR-AC-3c9"/>
<outlet property="scrollView" destination="iYz-ho-dCf" id="3WC-dH-aPj"/>
</connections>
</viewController>
<placeholder placeholderIdentifier="IBFirstResponder" id="q6W-UB-SSr" userLabel="First Responder" sceneMemberID="firstResponder"/>
</objects>
<point key="canvasLocation" x="3280" y="-274"/>
</scene>
</scenes>
<resources>
<image name="calendar_add_btn" width="244" height="34"/>
<image name="calendar_add_btn_selected" width="244" height="34"/>
<image name="navbar_fave" width="28" height="26"/>
<image name="welcome_glyph" width="183" height="183"/>
</resources>
</document>
``` | /content/code_sandbox/FOSSAsia/IndividualEvent.storyboard | xml | 2016-02-02T06:38:44 | 2024-08-06T13:59:28 | open-event-attendee-ios | fossasia/open-event-attendee-ios | 1,570 | 6,972 |
```xml
<schemalist>
<schema id='org.gtk.test.schema'>
<key name='test' type='i'>
<range min='22.5' max='27'/>
<default>25</default>
</key>
</schema>
</schemalist>
``` | /content/code_sandbox/utilities/glib/gio/tests/schema-tests/range-parse-error.gschema.xml | xml | 2016-10-27T09:31:28 | 2024-08-16T19:00:35 | nexmon | seemoo-lab/nexmon | 2,381 | 61 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="path_to_url">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="debug|x64">
<Configuration>debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="checked|x64">
<Configuration>checked</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="profile|x64">
<Configuration>profile</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="release|x64">
<Configuration>release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{CB1D4F57-8DC5-76DF-DA0B-C9B21949C83A}</ProjectGuid>
<RootNamespace>SnippetSplitFetchResults</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v141</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='checked|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v141</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='profile|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v141</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<PlatformToolset>v141</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='checked|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='profile|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='debug|x64'">
<OutDir>./../../../bin/vc15win64\</OutDir>
<IntDir>./x64/SnippetSplitFetchResults/debug\</IntDir>
<TargetExt>.exe</TargetExt>
<TargetName>$(ProjectName)DEBUG</TargetName>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules />
<CodeAnalysisRuleAssemblies />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='debug|x64'">
<ClCompile>
<TreatWarningAsError>true</TreatWarningAsError>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FloatingPointModel>Fast</FloatingPointModel>
<BasicRuntimeChecks>UninitializedLocalUsageCheck</BasicRuntimeChecks>
<AdditionalOptions>/GR- /GF /MP /Wall /wd4514 /wd4820 /wd4127 /wd4710 /wd4711 /wd4435 /wd4577 /wd4464 /wd4623 /wd4626 /wd5027 /wd4987 /wd5038 /wd5045 /wd4548 /wd4350 /wd4668 /wd4365 /wd4548 /wd4625 /wd5026 /Zi /d2Zi+</AdditionalOptions>
<Optimization>Disabled</Optimization>
<AdditionalIncludeDirectories>./../../../Include;./../../../../PxShared/include;./../../../../PxShared/src/foundation/include;./../../../../PxShared/src/fastxml/include;./../../Graphics/include/win32/GL;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_HAS_EXCEPTIONS=0;WIN32;WIN64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_WINSOCK_DEPRECATED_NO_WARNINGS;PHYSX_PROFILE_SDK;RENDER_SNIPPET;_DEBUG;PX_DEBUG=1;PX_CHECKED=1;PX_NVTX=1;PX_SUPPORT_PVD=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ExceptionHandling>false</ExceptionHandling>
<WarningLevel>Level4</WarningLevel>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile></PrecompiledHeaderFile>
<ProgramDataBaseFileName>$(TargetDir)\$(TargetName).pdb</ProgramDataBaseFileName>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<AdditionalOptions>/LIBPATH:../../../Lib/vc15win64 PhysX3CommonDEBUG_x64.lib PhysX3DEBUG_x64.lib PhysX3CookingDEBUG_x64.lib PhysX3CharacterKinematicDEBUG_x64.lib PhysX3ExtensionsDEBUG.lib PhysX3VehicleDEBUG.lib PxTaskDEBUG_x64.lib PxFoundationDEBUG_x64.lib PsFastXmlDEBUG_x64.lib PxPvdSDKDEBUG_x64.lib /LIBPATH:../../lib/vc15win64 SnippetUtilsDEBUG.lib /DEBUG</AdditionalOptions>
<AdditionalDependencies>Winmm.lib;OpenGL32.lib;glut32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>$(OutDir)$(ProjectName)DEBUG.exe</OutputFile>
<AdditionalLibraryDirectories>./../../../Common/lib/vc15win64;./../../lib/vc15win64;./../../../../PxShared/lib/vc15win64;./../../Graphics/lib/win64/glut;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>$(TargetDir)\$(TargetName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
<GenerateDebugInformation>true</GenerateDebugInformation>
<TargetMachine>MachineX64</TargetMachine>
</Link>
<ResourceCompile>
</ResourceCompile>
<ProjectReference>
</ProjectReference>
<PostBuildEvent>
<Command>XCOPY "../../../../PxShared/bin\vc15win64\PxFoundationDEBUG_x64.dll" "$(OutDir)" /D /Y
 XCOPY "../../../../PxShared/bin\vc15win64\PxPvdSDKDEBUG_x64.dll" "$(OutDir)" /D /Y</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='checked|x64'">
<OutDir>./../../../bin/vc15win64\</OutDir>
<IntDir>./x64/SnippetSplitFetchResults/checked\</IntDir>
<TargetExt>.exe</TargetExt>
<TargetName>$(ProjectName)CHECKED</TargetName>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules />
<CodeAnalysisRuleAssemblies />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='checked|x64'">
<ClCompile>
<TreatWarningAsError>true</TreatWarningAsError>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FloatingPointModel>Fast</FloatingPointModel>
<AdditionalOptions>/GR- /GF /MP /Wall /wd4514 /wd4820 /wd4127 /wd4710 /wd4711 /wd4435 /wd4577 /wd4464 /wd4623 /wd4626 /wd5027 /wd4987 /wd5038 /wd5045 /wd4548 /wd4350 /wd4668 /wd4365 /wd4548 /wd4625 /wd5026 /d2Zi+</AdditionalOptions>
<Optimization>Full</Optimization>
<AdditionalIncludeDirectories>./../../../Include;./../../../../PxShared/include;./../../../../PxShared/src/foundation/include;./../../../../PxShared/src/fastxml/include;./../../Graphics/include/win32/GL;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_HAS_EXCEPTIONS=0;WIN32;WIN64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_WINSOCK_DEPRECATED_NO_WARNINGS;PHYSX_PROFILE_SDK;RENDER_SNIPPET;NDEBUG;PX_CHECKED=1;PX_NVTX=1;PX_SUPPORT_PVD=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ExceptionHandling>false</ExceptionHandling>
<WarningLevel>Level4</WarningLevel>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile></PrecompiledHeaderFile>
<ProgramDataBaseFileName>$(TargetDir)\$(TargetName).pdb</ProgramDataBaseFileName>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<AdditionalOptions>/LIBPATH:../../../Lib/vc15win64 PhysX3CommonCHECKED_x64.lib PhysX3CHECKED_x64.lib PhysX3CookingCHECKED_x64.lib PhysX3CharacterKinematicCHECKED_x64.lib PhysX3ExtensionsCHECKED.lib PhysX3VehicleCHECKED.lib PxTaskCHECKED_x64.lib PxFoundationCHECKED_x64.lib PsFastXmlCHECKED_x64.lib PxPvdSDKCHECKED_x64.lib /LIBPATH:../../lib/vc15win64 SnippetUtilsCHECKED.lib</AdditionalOptions>
<AdditionalDependencies>Winmm.lib;OpenGL32.lib;glut32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>$(OutDir)$(ProjectName)CHECKED.exe</OutputFile>
<AdditionalLibraryDirectories>./../../../Common/lib/vc15win64;./../../lib/vc15win64;./../../../../PxShared/lib/vc15win64;./../../Graphics/lib/win64/glut;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>$(TargetDir)\$(TargetName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
<GenerateDebugInformation>true</GenerateDebugInformation>
<TargetMachine>MachineX64</TargetMachine>
</Link>
<ResourceCompile>
</ResourceCompile>
<ProjectReference>
</ProjectReference>
<PostBuildEvent>
<Command>XCOPY "../../../../PxShared/bin\vc15win64\PxFoundationCHECKED_x64.dll" "$(OutDir)" /D /Y
 XCOPY "../../../../PxShared/bin\vc15win64\PxPvdSDKCHECKED_x64.dll" "$(OutDir)" /D /Y</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='profile|x64'">
<OutDir>./../../../bin/vc15win64\</OutDir>
<IntDir>./x64/SnippetSplitFetchResults/profile\</IntDir>
<TargetExt>.exe</TargetExt>
<TargetName>$(ProjectName)PROFILE</TargetName>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules />
<CodeAnalysisRuleAssemblies />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='profile|x64'">
<ClCompile>
<TreatWarningAsError>true</TreatWarningAsError>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FloatingPointModel>Fast</FloatingPointModel>
<AdditionalOptions>/GR- /GF /MP /Wall /wd4514 /wd4820 /wd4127 /wd4710 /wd4711 /wd4435 /wd4577 /wd4464 /wd4623 /wd4626 /wd5027 /wd4987 /wd5038 /wd5045 /wd4548 /wd4350 /wd4668 /wd4365 /wd4548 /wd4625 /wd5026 /d2Zi+</AdditionalOptions>
<Optimization>Full</Optimization>
<AdditionalIncludeDirectories>./../../../Include;./../../../../PxShared/include;./../../../../PxShared/src/foundation/include;./../../../../PxShared/src/fastxml/include;./../../Graphics/include/win32/GL;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_HAS_EXCEPTIONS=0;WIN32;WIN64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_WINSOCK_DEPRECATED_NO_WARNINGS;PHYSX_PROFILE_SDK;RENDER_SNIPPET;NDEBUG;PX_PROFILE=1;PX_NVTX=1;PX_SUPPORT_PVD=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ExceptionHandling>false</ExceptionHandling>
<WarningLevel>Level4</WarningLevel>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile></PrecompiledHeaderFile>
<ProgramDataBaseFileName>$(TargetDir)\$(TargetName).pdb</ProgramDataBaseFileName>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<AdditionalOptions>/INCREMENTAL:NO /LIBPATH:../../../Lib/vc15win64 PhysX3CommonPROFILE_x64.lib PhysX3PROFILE_x64.lib PhysX3CookingPROFILE_x64.lib PhysX3CharacterKinematicPROFILE_x64.lib PhysX3ExtensionsPROFILE.lib PhysX3VehiclePROFILE.lib PxTaskPROFILE_x64.lib PxFoundationPROFILE_x64.lib PsFastXmlPROFILE_x64.lib PxPvdSDKPROFILE_x64.lib /LIBPATH:../../lib/vc15win64 SnippetUtilsPROFILE.lib /DEBUG</AdditionalOptions>
<AdditionalDependencies>Winmm.lib;OpenGL32.lib;glut32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>$(OutDir)$(ProjectName)PROFILE.exe</OutputFile>
<AdditionalLibraryDirectories>./../../../Common/lib/vc15win64;./../../lib/vc15win64;./../../../../PxShared/lib/vc15win64;./../../Graphics/lib/win64/glut;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>$(TargetDir)\$(TargetName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
<GenerateDebugInformation>true</GenerateDebugInformation>
<TargetMachine>MachineX64</TargetMachine>
</Link>
<ResourceCompile>
</ResourceCompile>
<ProjectReference>
</ProjectReference>
<PostBuildEvent>
<Command>XCOPY "../../../../PxShared/bin\vc15win64\PxFoundationPROFILE_x64.dll" "$(OutDir)" /D /Y
 XCOPY "../../../../PxShared/bin\vc15win64\PxPvdSDKPROFILE_x64.dll" "$(OutDir)" /D /Y</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='release|x64'">
<OutDir>./../../../bin/vc15win64\</OutDir>
<IntDir>./x64/SnippetSplitFetchResults/release\</IntDir>
<TargetExt>.exe</TargetExt>
<TargetName>$(ProjectName)</TargetName>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules />
<CodeAnalysisRuleAssemblies />
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='release|x64'">
<ClCompile>
<TreatWarningAsError>true</TreatWarningAsError>
<BufferSecurityCheck>false</BufferSecurityCheck>
<FloatingPointModel>Fast</FloatingPointModel>
<AdditionalOptions>/GR- /GF /MP /Wall /wd4514 /wd4820 /wd4127 /wd4710 /wd4711 /wd4435 /wd4577 /wd4464 /wd4623 /wd4626 /wd5027 /wd4987 /wd5038 /wd5045 /wd4548 /wd4350 /wd4668 /wd4365 /wd4548 /wd4625 /wd5026 /d2Zi+</AdditionalOptions>
<Optimization>Full</Optimization>
<AdditionalIncludeDirectories>./../../../Include;./../../../../PxShared/include;./../../../../PxShared/src/foundation/include;./../../../../PxShared/src/fastxml/include;./../../Graphics/include/win32/GL;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>_HAS_EXCEPTIONS=0;WIN32;WIN64;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_WINSOCK_DEPRECATED_NO_WARNINGS;PHYSX_PROFILE_SDK;RENDER_SNIPPET;NDEBUG;PX_SUPPORT_PVD=0;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ExceptionHandling>false</ExceptionHandling>
<WarningLevel>Level4</WarningLevel>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<PrecompiledHeader>NotUsing</PrecompiledHeader>
<PrecompiledHeaderFile></PrecompiledHeaderFile>
<ProgramDataBaseFileName>$(TargetDir)\$(TargetName).pdb</ProgramDataBaseFileName>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<AdditionalOptions>/INCREMENTAL:NO /LIBPATH:../../../Lib/vc15win64 PhysX3Common_x64.lib PhysX3_x64.lib PhysX3Cooking_x64.lib PhysX3CharacterKinematic_x64.lib PhysX3Extensions.lib PhysX3Vehicle.lib PxTask_x64.lib PxFoundation_x64.lib PsFastXml_x64.lib PxPvdSDK_x64.lib /LIBPATH:../../lib/vc15win64 SnippetUtils.lib</AdditionalOptions>
<AdditionalDependencies>Winmm.lib;OpenGL32.lib;glut32.lib;%(AdditionalDependencies)</AdditionalDependencies>
<OutputFile>$(OutDir)$(ProjectName).exe</OutputFile>
<AdditionalLibraryDirectories>./../../../Common/lib/vc15win64;./../../lib/vc15win64;./../../../../PxShared/lib/vc15win64;./../../Graphics/lib/win64/glut;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<ProgramDatabaseFile>$(TargetDir)\$(TargetName).pdb</ProgramDatabaseFile>
<SubSystem>Console</SubSystem>
<ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
<GenerateDebugInformation>true</GenerateDebugInformation>
<TargetMachine>MachineX64</TargetMachine>
</Link>
<ResourceCompile>
</ResourceCompile>
<ProjectReference>
</ProjectReference>
<PostBuildEvent>
<Command>XCOPY "../../../../PxShared/bin\vc15win64\PxFoundation_x64.dll" "$(OutDir)" /D /Y
 XCOPY "../../../../PxShared/bin\vc15win64\PxPvdSDK_x64.dll" "$(OutDir)" /D /Y</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="..\..\SnippetCommon\ClassicMain.cpp">
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\SnippetSplitFetchResults\SnippetSplitFetchResults.cpp">
</ClCompile>
<ClCompile Include="..\..\SnippetSplitFetchResults\SnippetSplitFetchResultsRender.cpp">
</ClCompile>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="./SnippetUtils.vcxproj">
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="./SnippetRender.vcxproj">
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets"></ImportGroup>
</Project>
``` | /content/code_sandbox/PhysX_3.4/Snippets/compiler/vc15win64/SnippetSplitFetchResults.vcxproj | xml | 2016-10-12T16:34:31 | 2024-08-16T09:40:38 | PhysX-3.4 | NVIDIAGameWorks/PhysX-3.4 | 2,343 | 4,853 |
```xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "path_to_url">
<mapper
namespace="org.activiti.engine.impl.persistence.entity.VariableInstanceEntity">
<!-- VARIABLE INSTANCE INSERT -->
<insert id="insertVariableInstance"
parameterType="org.activiti.engine.impl.persistence.entity.VariableInstanceEntity">
insert into ${prefix}ACT_RU_VARIABLE (ID_, REV_,
TYPE_, NAME_, PROC_INST_ID_, EXECUTION_ID_, TASK_ID_, BYTEARRAY_ID_,
DOUBLE_, LONG_ , TEXT_, TEXT2_)
values (
#{id, jdbcType=VARCHAR},
1,
#{type, jdbcType=VARCHAR },
#{name, jdbcType=VARCHAR},
#{processInstanceId, jdbcType=VARCHAR},
#{executionId, jdbcType=VARCHAR},
#{taskId, jdbcType=VARCHAR},
#{byteArrayRef, typeHandler=ByteArrayRefTypeHandler},
#{doubleValue, jdbcType=DOUBLE},
#{longValue, jdbcType=BIGINT},
#{textValue, jdbcType=VARCHAR},
#{textValue2, jdbcType=VARCHAR}
)
</insert>
<insert id="bulkInsertVariableInstance"
parameterType="java.util.List">
INSERT INTO ${prefix}ACT_RU_VARIABLE (ID_, REV_,
TYPE_, NAME_, PROC_INST_ID_, EXECUTION_ID_, TASK_ID_, BYTEARRAY_ID_,
DOUBLE_, LONG_ , TEXT_, TEXT2_) VALUES
<foreach collection="list" item="variable" index="index" separator=",">
(#{variable.id, jdbcType=VARCHAR},
1,
#{variable.typeName, jdbcType=VARCHAR },
#{variable.name, jdbcType=VARCHAR},
#{variable.processInstanceId, jdbcType=VARCHAR},
#{variable.executionId, jdbcType=VARCHAR},
#{variable.taskId, jdbcType=VARCHAR},
#{variable.byteArrayRef, typeHandler=ByteArrayRefTypeHandler},
#{variable.doubleValue, jdbcType=DOUBLE},
#{variable.longValue, jdbcType=BIGINT},
#{variable.textValue, jdbcType=VARCHAR},
#{variable.textValue2, jdbcType=VARCHAR})
</foreach>
</insert>
<insert id="bulkInsertVariableInstance_oracle" parameterType="java.util.List">
INSERT ALL
<foreach collection="list" item="variable" index="index">
INTO ${prefix}ACT_RU_VARIABLE (ID_, REV_,
TYPE_, NAME_, PROC_INST_ID_, EXECUTION_ID_, TASK_ID_, BYTEARRAY_ID_,
DOUBLE_, LONG_ , TEXT_, TEXT2_) VALUES
(#{variable.id, jdbcType=VARCHAR},
1,
#{variable.typeName, jdbcType=VARCHAR },
#{variable.name, jdbcType=VARCHAR},
#{variable.processInstanceId, jdbcType=VARCHAR},
#{variable.executionId, jdbcType=VARCHAR},
#{variable.taskId, jdbcType=VARCHAR},
#{variable.byteArrayRef, typeHandler=ByteArrayRefTypeHandler},
#{variable.doubleValue, jdbcType=DOUBLE},
#{variable.longValue, jdbcType=BIGINT},
#{variable.textValue, jdbcType=VARCHAR},
#{variable.textValue2, jdbcType=VARCHAR})
</foreach>
SELECT * FROM dual
</insert>
<!-- VARIABLE INSTANCE UPDATE -->
<update id="updateVariableInstance"
parameterType="org.activiti.engine.impl.persistence.entity.VariableInstanceEntity">
update ${prefix}ACT_RU_VARIABLE
set
REV_ = #{revisionNext, jdbcType=INTEGER},
EXECUTION_ID_ = #{executionId, jdbcType=VARCHAR},
BYTEARRAY_ID_ = #{byteArrayRef, typeHandler=ByteArrayRefTypeHandler},
TYPE_ = #{type, jdbcType=VARCHAR },
DOUBLE_ = #{doubleValue, jdbcType=DOUBLE},
LONG_ = #{longValue, jdbcType=BIGINT},
TEXT_ = #{textValue, jdbcType=VARCHAR},
TEXT2_ = #{textValue2, jdbcType=VARCHAR}
where ID_ = #{id, jdbcType=VARCHAR}
and REV_ = #{revision, jdbcType=INTEGER}
</update>
<!-- VARIABLE INSTANCE DELETE -->
<delete id="deleteVariableInstance"
parameterType="org.activiti.engine.impl.persistence.entity.VariableInstanceEntity">
delete from ${prefix}ACT_RU_VARIABLE where ID_ = #{id,
jdbcType=VARCHAR} and REV_ = #{revision}
</delete>
<delete id="bulkDeleteVariableInstance" parameterType="java.util.Collection">
delete from ${prefix}ACT_RU_VARIABLE where
<foreach item="variable" collection="list" index="index" separator=" or ">
ID_ = #{variable.id, jdbcType=VARCHAR}
</foreach>
</delete>
<!-- VARIABLE INSTANCE RESULTMAP -->
<resultMap id="variableInstanceResultMap" type="org.activiti.engine.impl.persistence.entity.VariableInstanceEntity">
<id property="id" column="ID_" jdbcType="VARCHAR" />
<result property="revision" column="REV_" jdbcType="INTEGER" />
<result property="type" column="TYPE_" javaType="org.flowable.variable.api.types.VariableType" jdbcType="VARCHAR" />
<result property="name" column="NAME_" javaType="String" jdbcType="VARCHAR" />
<result property="processInstanceId" column="PROC_INST_ID_" jdbcType="VARCHAR" />
<result property="executionId" column="EXECUTION_ID_" jdbcType="VARCHAR" />
<result property="taskId" column="TASK_ID_" jdbcType="VARCHAR" />
<result property="activityId" column="ACTIVITY_ID_" jdbcType="VARCHAR" />
<result property="isActive" column="IS_ACTIVE_" jdbcType="BOOLEAN" />
<result property="isConcurrencyScope" column="IS_CONCURRENCY_SCOPE_" jdbcType="BOOLEAN" />
<result property="byteArrayRef" column="BYTEARRAY_ID_" typeHandler="ByteArrayRefTypeHandler"/>
<result property="doubleValue" column="DOUBLE_" jdbcType="DOUBLE" />
<result property="textValue" column="TEXT_" jdbcType="VARCHAR" />
<result property="textValue2" column="TEXT2_" jdbcType="VARCHAR" />
<result property="longValue" column="LONG_" jdbcType="BIGINT" />
</resultMap>
<!-- VARIABLE INSTANCE SELECT -->
<select id="selectVariableInstance" parameterType="string"
resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE where ID_ = #{id, jdbcType=VARCHAR}
</select>
<select id="selectVariablesByExecutionId"
parameterType="org.activiti.engine.impl.db.ListQueryParameterObject"
resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE
where EXECUTION_ID_ = #{parameter, jdbcType=VARCHAR}
and TASK_ID_ is null
</select>
<select id="selectVariablesByExecutionIds"
parameterType="org.activiti.engine.impl.db.ListQueryParameterObject"
resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE
where TASK_ID_ is null
and EXECUTION_ID_ in
<foreach item="item" index="index" collection="parameter" open="(" separator="," close=")">
#{item}
</foreach>
</select>
<select id="selectVariableInstanceByExecutionAndName" parameterType="java.util.Map" resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE
where EXECUTION_ID_ = #{executionId, jdbcType=VARCHAR} and NAME_= #{name, jdbcType=VARCHAR} and TASK_ID_ is null
</select>
<select id="selectVariableInstancesByExecutionAndNames" parameterType="java.util.Map" resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE
where EXECUTION_ID_ = #{parameter.executionId, jdbcType=VARCHAR} and TASK_ID_ is null
<if test="parameter.names != null and parameter.names.size > 0">
and (
<foreach collection="parameter.names" index="index" item="name" separator=" or ">
NAME_= #{name, jdbcType=VARCHAR}
</foreach>
)
</if>
</select>
<select id="selectVariablesByTaskId"
parameterType="org.activiti.engine.impl.db.ListQueryParameterObject"
resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE where
TASK_ID_ = #{parameter, jdbcType=VARCHAR}
</select>
<select id="selectVariablesByTaskIds"
parameterType="org.activiti.engine.impl.db.ListQueryParameterObject"
resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE
where TASK_ID_ in
<foreach item="item" index="index" collection="parameter" open="(" separator="," close=")">
#{item}
</foreach>
</select>
<select id="selectVariableInstanceByTaskAndName" parameterType="java.util.Map" resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE
where TASK_ID_ = #{taskId, jdbcType=VARCHAR} and NAME_= #{name, jdbcType=VARCHAR}
</select>
<select id="selectVariableInstancesByTaskAndNames" parameterType="java.util.Map" resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE
where TASK_ID_ = #{parameter.taskId, jdbcType=VARCHAR}
<if test="parameter.names != null and parameter.names.size > 0">
and (
<foreach collection="parameter.names" index="index" item="name" separator=" or ">
NAME_= #{name, jdbcType=VARCHAR}
</foreach>
)
</if>
</select>
<select id="selectVariableInstancesBySubScopeIdAndScopeType" parameterType="java.util.Map" resultMap="variableInstanceResultMap">
select * from ${prefix}ACT_RU_VARIABLE
where SUB_SCOPE_ID_ = #{parameter.subScopeId, jdbcType=VARCHAR} AND SCOPE_TYPE_ = #{parameter.scopeType, jdbcType=VARCHAR}
</select>
</mapper>
``` | /content/code_sandbox/modules/flowable5-engine/src/main/resources/org/activiti/db/mapping/entity/VariableInstance.xml | xml | 2016-10-13T07:21:43 | 2024-08-16T15:23:14 | flowable-engine | flowable/flowable-engine | 7,715 | 2,232 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout xmlns:android="path_to_url"
xmlns:app="path_to_url"
xmlns:tools="path_to_url"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".PahoExampleActivity">
<android.support.design.widget.AppBarLayout
android:id="@+id/app_bar"
android:layout_width="match_parent"
android:layout_height="@dimen/app_bar_height"
android:theme="@style/AppTheme.AppBarOverlay">
<android.support.design.widget.CollapsingToolbarLayout
android:id="@+id/toolbar_layout"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fitsSystemWindows="true"
app:contentScrim="?attr/colorPrimary"
app:layout_scrollFlags="scroll|exitUntilCollapsed">
<android.support.v7.widget.Toolbar
android:id="@+id/toolbar"
android:layout_width="match_parent"
android:layout_height="?attr/actionBarSize"
app:layout_collapseMode="pin"
app:popupTheme="@style/AppTheme.PopupOverlay" />
</android.support.design.widget.CollapsingToolbarLayout>
</android.support.design.widget.AppBarLayout>
<android.support.v7.widget.RecyclerView
android:id="@+id/history_recycler_view"
android:layout_width="match_parent"
android:layout_height="match_parent"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:context=".PahoExampleActivity"
android:fillViewport="true"/>
<android.support.design.widget.FloatingActionButton
android:id="@+id/fab"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_margin="@dimen/fab_margin"
android:src="@android:drawable/ic_dialog_email"
app:layout_anchor="@id/app_bar"
app:layout_anchorGravity="bottom|end" />
<View
android:layout_width="match_parent"
android:layout_height=".3dp"
android:visibility="visible"/>
</android.support.design.widget.CoordinatorLayout>
``` | /content/code_sandbox/paho.mqtt.android.example/src/main/res/layout/activity_scrolling.xml | xml | 2016-02-19T15:44:50 | 2024-08-15T08:21:05 | paho.mqtt.android | eclipse/paho.mqtt.android | 2,902 | 486 |
```xml
import { Component } from '@angular/core';
import { IMarkdownNavigatorItem } from '@covalent/markdown-navigator';
@Component({
selector: 'markdown-navigator-demo-children-url-start-at',
styleUrls: ['./markdown-navigator-demo-children-url-start-at.component.scss'],
templateUrl: './markdown-navigator-demo-children-url-start-at.component.html',
})
export class MarkdownNavigatorDemoChildrenUrlStartAtComponent {
startAt: IMarkdownNavigatorItem[] = [
{ id: 'url-children-demo' },
{ id: 'child-2' },
{ id: 'grandchild-2' },
];
items: IMarkdownNavigatorItem[] = [
{
id: 'url-children-demo',
title: 'Url children demo',
childrenUrl: 'assets/demos-data/children_url_1.json',
/*
For ref:
children_url_1.json:
[
{
"title": "Child 1",
"id": "child-1",
"markdownString": "> This is child 1"
},
{
"title": "Child 2",
"id": "child-2",
"markdownString": "> This is child 2",
"childrenUrl": "/assets/demos-data/children_url_2.json"
}
]
children_url_2.json:
[
{
"title": "Grandchild 1",
"id": "grandchild-1",
"markdownString": "> This is grandchild 1"
},
{
"title": "Grandchild 2",
"id": "grandchild-2",
"markdownString": "> This is grandchild 2"
}
]
*/
},
];
}
``` | /content/code_sandbox/apps/docs-app/src/app/content/components/component-demos/markdown-navigator/demos/markdown-navigator-demo-children-url-start-at/markdown-navigator-demo-children-url-start-at.component.ts | xml | 2016-07-11T23:30:52 | 2024-08-15T15:20:45 | covalent | Teradata/covalent | 2,228 | 374 |
```xml
export { default as af } from './af'
export { default as ar } from './ar'
export { default as bg } from './bg'
export { default as ca } from './ca'
export { default as ckb } from './ckb'
export { default as cs } from './cs'
export { default as da } from './da'
export { default as de } from './de'
export { default as el } from './el'
export { default as en } from './en'
export { default as es } from './es'
export { default as et } from './et'
export { default as fa } from './fa'
export { default as fi } from './fi'
export { default as fr } from './fr'
export { default as hr } from './hr'
export { default as hu } from './hu'
export { default as he } from './he'
export { default as id } from './id'
export { default as it } from './it'
export { default as ja } from './ja'
export { default as km } from './km'
export { default as ko } from './ko'
export { default as lv } from './lv'
export { default as lt } from './lt'
export { default as nl } from './nl'
export { default as no } from './no'
export { default as pl } from './pl'
export { default as pt } from './pt'
export { default as ro } from './ro'
export { default as ru } from './ru'
export { default as sk } from './sk'
export { default as sl } from './sl'
export { default as srCyrl } from './sr-Cyrl'
export { default as srLatn } from './sr-Latn'
export { default as sv } from './sv'
export { default as th } from './th'
export { default as tr } from './tr'
export { default as az } from './az'
export { default as uk } from './uk'
export { default as vi } from './vi'
export { default as zhHans } from './zh-Hans'
export { default as zhHant } from './zh-Hant'
``` | /content/code_sandbox/packages/vuetify/src/locale/index.ts | xml | 2016-09-12T00:39:35 | 2024-08-16T20:06:39 | vuetify | vuetifyjs/vuetify | 39,539 | 451 |
```xml
import {getNodeScroll} from '@floating-ui/utils/dom';
import {getDocumentElement} from '../platform/getDocumentElement';
import {getBoundingClientRect} from './getBoundingClientRect';
export function getWindowScrollBarX(element: Element): number {
// If <html> has a CSS width greater than the viewport, then this will be
// incorrect for RTL.
return (
getBoundingClientRect(getDocumentElement(element)).left +
getNodeScroll(element).scrollLeft
);
}
``` | /content/code_sandbox/packages/dom/src/utils/getWindowScrollBarX.ts | xml | 2016-03-29T17:00:47 | 2024-08-16T16:29:40 | floating-ui | floating-ui/floating-ui | 29,450 | 97 |
```xml
<dict>
<key>CommonPeripheralDSP</key>
<array>
<dict>
<key>DeviceID</key>
<integer>0</integer>
<key>DeviceType</key>
<string>Headphone</string>
</dict>
<dict>
<key>DeviceID</key>
<integer>1</integer>
<key>DeviceType</key>
<string>Headphone</string>
</dict>
<dict>
<key>DeviceID</key>
<integer>2</integer>
<key>DeviceType</key>
<string>Headphone</string>
</dict>
<dict>
<key>DeviceID</key>
<integer>3</integer>
<key>DeviceType</key>
<string>Headphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspEqualization32</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>9</key>
<integer>0</integer>
<key>Filter</key>
<array>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>15</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1161543809</integer>
<key>7</key>
<integer>1081372503</integer>
<key>8</key>
<integer>-1069580896</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>17</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1174701470</integer>
<key>7</key>
<integer>1088021041</integer>
<key>8</key>
<integer>-1060791771</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>15</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1161543809</integer>
<key>7</key>
<integer>1081372503</integer>
<key>8</key>
<integer>-1069580896</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>17</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1174701470</integer>
<key>7</key>
<integer>1088021041</integer>
<key>8</key>
<integer>-1060791771</integer>
</dict>
</array>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>4</integer>
<key>DeviceType</key>
<string>Headphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1050798235</integer>
<key>3</key>
<integer>1050798235</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspEqualization32</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>9</key>
<integer>0</integer>
<key>Filter</key>
<array>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1117303413</integer>
<key>7</key>
<integer>1056964608</integer>
<key>8</key>
<integer>1081640911</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>14</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1161086411</integer>
<key>7</key>
<integer>1079184896</integer>
<key>8</key>
<integer>-1049132273</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>17</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1170946752</integer>
<key>7</key>
<integer>1079355022</integer>
<key>8</key>
<integer>-1056742098</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1117303413</integer>
<key>7</key>
<integer>1056964608</integer>
<key>8</key>
<integer>1081640911</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>14</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1161086411</integer>
<key>7</key>
<integer>1079184896</integer>
<key>8</key>
<integer>-1049132273</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>17</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1170946752</integer>
<key>7</key>
<integer>1079355022</integer>
<key>8</key>
<integer>-1056742098</integer>
</dict>
</array>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1092616192</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>1092616192</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>5</integer>
<key>DeviceType</key>
<string>Headphone</string>
</dict>
<dict>
<key>DeviceID</key>
<integer>6</integer>
<key>DeviceType</key>
<string>Headphone</string>
</dict>
<dict>
<key>DeviceID</key>
<integer>7</integer>
<key>DeviceType</key>
<string>Headphone</string>
</dict>
<dict>
<key>DeviceID</key>
<integer>5778</integer>
<key>DeviceType</key>
<string>Headphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspEqualization32</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>9</key>
<integer>0</integer>
<key>Filter</key>
<array>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1105173360</integer>
<key>7</key>
<integer>1060382189</integer>
<key>8</key>
<integer>-1069328564</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>1</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>5</integer>
<key>6</key>
<integer>1118435519</integer>
<key>7</key>
<integer>1057990469</integer>
<key>8</key>
<integer>1078436775</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>2</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1165213103</integer>
<key>7</key>
<integer>1073658087</integer>
<key>8</key>
<integer>1082152683</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>3</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1169937955</integer>
<key>7</key>
<integer>1082006527</integer>
<key>8</key>
<integer>-1081440652</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>4</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>6</integer>
<key>6</key>
<integer>1174053019</integer>
<key>7</key>
<integer>1103438072</integer>
<key>8</key>
<integer>1084288774</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1105173360</integer>
<key>7</key>
<integer>1060382189</integer>
<key>8</key>
<integer>-1069328564</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>1</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>5</integer>
<key>6</key>
<integer>1118435519</integer>
<key>7</key>
<integer>1057990469</integer>
<key>8</key>
<integer>1078436775</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>2</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1165213103</integer>
<key>7</key>
<integer>1073658087</integer>
<key>8</key>
<integer>1082152683</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>3</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1169937955</integer>
<key>7</key>
<integer>1082006527</integer>
<key>8</key>
<integer>-1081440652</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>4</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>6</integer>
<key>6</key>
<integer>1174053019</integer>
<key>7</key>
<integer>1103438072</integer>
<key>8</key>
<integer>1084288774</integer>
</dict>
</array>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>-1063256064</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1063256064</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>5924</integer>
<key>DeviceType</key>
<string>Headphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspEqualization32</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>9</key>
<integer>0</integer>
<key>Filter</key>
<array>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1105173360</integer>
<key>7</key>
<integer>1060382189</integer>
<key>8</key>
<integer>-1069328564</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>1</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>5</integer>
<key>6</key>
<integer>1118435519</integer>
<key>7</key>
<integer>1057990469</integer>
<key>8</key>
<integer>1078436775</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>2</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1162382127</integer>
<key>7</key>
<integer>1077789549</integer>
<key>8</key>
<integer>-1073319056</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>3</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1170318836</integer>
<key>7</key>
<integer>1077908751</integer>
<key>8</key>
<integer>-1063194874</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>4</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>6</integer>
<key>6</key>
<integer>1174033784</integer>
<key>7</key>
<integer>1103422943</integer>
<key>8</key>
<integer>1031954541</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1105173360</integer>
<key>7</key>
<integer>1060382189</integer>
<key>8</key>
<integer>-1069328564</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>1</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>5</integer>
<key>6</key>
<integer>1118435519</integer>
<key>7</key>
<integer>1057990469</integer>
<key>8</key>
<integer>1078436775</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>2</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1162382127</integer>
<key>7</key>
<integer>1077789549</integer>
<key>8</key>
<integer>-1073319056</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>3</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1170318836</integer>
<key>7</key>
<integer>1077908751</integer>
<key>8</key>
<integer>-1063194874</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>4</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>6</integer>
<key>6</key>
<integer>1174033784</integer>
<key>7</key>
<integer>1103422943</integer>
<key>8</key>
<integer>1031954541</integer>
</dict>
</array>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>-1069547520</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1069547520</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>6436</integer>
<key>DeviceType</key>
<string>Headphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspEqualization32</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>9</key>
<integer>0</integer>
<key>Filter</key>
<array>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1105173360</integer>
<key>7</key>
<integer>1060382189</integer>
<key>8</key>
<integer>-1069328564</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>1</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>5</integer>
<key>6</key>
<integer>1118435519</integer>
<key>7</key>
<integer>1057990469</integer>
<key>8</key>
<integer>1078436775</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>2</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1162382127</integer>
<key>7</key>
<integer>1077789549</integer>
<key>8</key>
<integer>-1073319056</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>3</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1170318836</integer>
<key>7</key>
<integer>1077908751</integer>
<key>8</key>
<integer>-1063194874</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>4</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>6</integer>
<key>6</key>
<integer>1174033784</integer>
<key>7</key>
<integer>1103422943</integer>
<key>8</key>
<integer>1031954541</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1105173360</integer>
<key>7</key>
<integer>1060382189</integer>
<key>8</key>
<integer>-1069328564</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>1</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>5</integer>
<key>6</key>
<integer>1118435519</integer>
<key>7</key>
<integer>1057990469</integer>
<key>8</key>
<integer>1078436775</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>2</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1162382127</integer>
<key>7</key>
<integer>1077789549</integer>
<key>8</key>
<integer>-1073319056</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>3</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1170318836</integer>
<key>7</key>
<integer>1077908751</integer>
<key>8</key>
<integer>-1063194874</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>4</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>6</integer>
<key>6</key>
<integer>1174033784</integer>
<key>7</key>
<integer>1103422943</integer>
<key>8</key>
<integer>1031954541</integer>
</dict>
</array>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>-1069547520</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1069547520</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>5851</integer>
<key>DeviceType</key>
<string>Headphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspEqualization32</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>9</key>
<integer>0</integer>
<key>Filter</key>
<array>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>15</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1161543809</integer>
<key>7</key>
<integer>1081372503</integer>
<key>8</key>
<integer>-1069580896</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>17</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1174701470</integer>
<key>7</key>
<integer>1088021041</integer>
<key>8</key>
<integer>-1060791771</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>15</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1161543809</integer>
<key>7</key>
<integer>1081372503</integer>
<key>8</key>
<integer>-1069580896</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>17</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>4</integer>
<key>6</key>
<integer>1174701470</integer>
<key>7</key>
<integer>1088021041</integer>
<key>8</key>
<integer>-1060791771</integer>
</dict>
</array>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>0</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>-1067450368</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1067450368</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspNoiseReduction</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1073900105</integer>
<key>5</key>
<data>BK9/your_sha256_hashwpCGlMIcWZbC/your_sha512_hash+oMLibqPC21yjwhjOpsLhQqfCEH+nwojDpsLqEabCkoihwrZko8KYFqTCnWWmwhj/qcLplqrCAhyrwvEgq8JwjKjCurCkws+your_sha256_hashyour_sha256_hashyour_sha256_hash9rML3/K/your_sha256_hashCkrmzwmBWsMIQqrHC1kmwwloussKnybLC+your_sha256_hashZ7JwixDzMJm5c/C1FrRwgVZ2MIqAN3CI4rlwpaa78KO4vfCiywAw3HFA8OL1wvD</data>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction3</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>3</integer>
<key>DspFuncName</key>
<string>DspEqualization32</string>
<key>DspFuncProcessingIndex</key>
<integer>3</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>9</key>
<integer>0</integer>
<key>Filter</key>
<array>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1117798621</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>1099519471</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>31</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
<key>6</key>
<integer>1184151638</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>0</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1117798621</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>1099519471</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>31</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
<key>6</key>
<integer>1184151638</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>0</integer>
</dict>
</array>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction4</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>4</integer>
<key>DspFuncName</key>
<string>DspClientGainAdjustStage</string>
<key>DspFuncProcessingIndex</key>
<integer>4</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>1</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>-1069547520</integer>
<key>4</key>
<integer>1095761920</integer>
<key>5</key>
<integer>3</integer>
<key>6</key>
<integer>1082130432</integer>
<key>7</key>
<integer>3</integer>
<key>8</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>3</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>3</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>1</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>2</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>3</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>-1065353216</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1065353216</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspNoiseReduction</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1073900105</integer>
<key>5</key>
<data>aouLwiBHdMIsbXTClNV6wpl0gMLLGoPCsqCFwk+Sh8KXQYnCNLGKwpoejMIuCY3C1uyNwvU6jcJ6No/Cs5GPwiu4kMJ8cpLCBiCTwlZdk8JhopPC/SKTwgBAksK6fJTCD++Twge/lcLr+your_sha256_hashprCfUeXwr4wmcJoWpnCiCGawtXzm8JHcZzCGs6cws2TnMKUeJvCgWaZwrB2m8Ib+your_sha256_hash5/CaCqgwnjtn8Ina53C9hmewuKuncJgS57CYg+gwp7nn8JiC6HCJhKhwr4eoMK3FJ7CwNyfwqCwnsL0JKDCMb+gwrpUocL1WqLCTomiwvc6ocIifaDC/iOhwsmon8Klw6HC2k2hwiEKo8Ju4KPCvbGjwr45osJuoaLCUwqiwlGLocJ2+your_sha256_hashqnCqkGqwihiqsI+UazCPeerwsdar8K2nLDCi3qzwkoht8KahLnC/PO7whIgv8Ky6sLC6unFwtOazMJnjtHCq2nZwrI94sKiEuvCohP1wtjb/cJ5LwfD</data>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction3</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>3</integer>
<key>DspFuncName</key>
<string>DspEqualization32</string>
<key>DspFuncProcessingIndex</key>
<integer>3</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>9</key>
<integer>0</integer>
<key>Filter</key>
<array>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1117798621</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>1099519471</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>31</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
<key>6</key>
<integer>1184151638</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>0</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1117798621</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>1099519471</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>31</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
<key>6</key>
<integer>1184151638</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>0</integer>
</dict>
</array>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction4</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>4</integer>
<key>DspFuncName</key>
<string>DspClientGainAdjustStage</string>
<key>DspFuncProcessingIndex</key>
<integer>4</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>1</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>-1069547520</integer>
<key>4</key>
<integer>1095761920</integer>
<key>5</key>
<integer>3</integer>
<key>6</key>
<integer>1082130432</integer>
<key>7</key>
<integer>3</integer>
<key>8</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>3</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>3</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>4</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>-1067450368</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1067450368</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspNoiseReduction</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1073900105</integer>
<key>5</key>
<data>aouLwiBHdMIsbXTClNV6wpl0gMLLGoPCsqCFwk+Sh8KXQYnCNLGKwpoejMIuCY3C1uyNwvU6jcJ6No/Cs5GPwiu4kMJ8cpLCBiCTwlZdk8JhopPC/SKTwgBAksK6fJTCD++Twge/lcLr+your_sha256_hashprCfUeXwr4wmcJoWpnCiCGawtXzm8JHcZzCGs6cws2TnMKUeJvCgWaZwrB2m8Ib+your_sha256_hash5/CaCqgwnjtn8Ina53C9hmewuKuncJgS57CYg+gwp7nn8JiC6HCJhKhwr4eoMK3FJ7CwNyfwqCwnsL0JKDCMb+gwrpUocL1WqLCTomiwvc6ocIifaDC/iOhwsmon8Klw6HC2k2hwiEKo8Ju4KPCvbGjwr45osJuoaLCUwqiwlGLocJ2+your_sha256_hashqnCqkGqwihiqsI+UazCPeerwsdar8K2nLDCi3qzwkoht8KahLnC/PO7whIgv8Ky6sLC6unFwtOazMJnjtHCq2nZwrI94sKiEuvCohP1wtjb/cJ5LwfD</data>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction3</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>3</integer>
<key>DspFuncName</key>
<string>DspEqualization32</string>
<key>DspFuncProcessingIndex</key>
<integer>3</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>9</key>
<integer>0</integer>
<key>Filter</key>
<array>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1117798621</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>1099519471</integer>
</dict>
<dict>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>31</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
<key>6</key>
<integer>1184151638</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>0</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>1</integer>
<key>6</key>
<integer>1117798621</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>1099519471</integer>
</dict>
<dict>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>31</integer>
<key>4</key>
<integer>0</integer>
<key>5</key>
<integer>0</integer>
<key>6</key>
<integer>1184151638</integer>
<key>7</key>
<integer>1060439283</integer>
<key>8</key>
<integer>0</integer>
</dict>
</array>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction4</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>4</integer>
<key>DspFuncName</key>
<string>DspClientGainAdjustStage</string>
<key>DspFuncProcessingIndex</key>
<integer>4</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>1</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>-1069547520</integer>
<key>4</key>
<integer>1095761920</integer>
<key>5</key>
<integer>3</integer>
<key>6</key>
<integer>1082130432</integer>
<key>7</key>
<integer>3</integer>
<key>8</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>3</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>3</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>5</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>6</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>7</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>5778</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>-1067450368</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1067450368</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspNoiseReduction</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1073900105</integer>
<key>5</key>
<data>BK9/your_sha256_hashwpCGlMIcWZbC/your_sha512_hash+oMLibqPC21yjwhjOpsLhQqfCEH+nwojDpsLqEabCkoihwrZko8KYFqTCnWWmwhj/qcLplqrCAhyrwvEgq8JwjKjCurCkws+your_sha256_hashyour_sha256_hashyour_sha256_hash9rML3/K/your_sha256_hashCkrmzwmBWsMIQqrHC1kmwwloussKnybLC+your_sha256_hashZ7JwixDzMJm5c/C1FrRwgVZ2MIqAN3CI4rlwpaa78KO4vfCiywAw3HFA8OL1wvD</data>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction3</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>3</integer>
<key>DspFuncName</key>
<string>DspClientGainAdjustStage</string>
<key>DspFuncProcessingIndex</key>
<integer>3</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>1</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>-1069547520</integer>
<key>4</key>
<integer>1095761920</integer>
<key>5</key>
<integer>3</integer>
<key>6</key>
<integer>1082130432</integer>
<key>7</key>
<integer>3</integer>
<key>8</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>5924</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>-1067450368</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1067450368</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspNoiseReduction</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1073900105</integer>
<key>5</key>
<data>BK9/your_sha256_hashwpCGlMIcWZbC/your_sha512_hash+oMLibqPC21yjwhjOpsLhQqfCEH+nwojDpsLqEabCkoihwrZko8KYFqTCnWWmwhj/qcLplqrCAhyrwvEgq8JwjKjCurCkws+your_sha256_hashyour_sha256_hashyour_sha256_hash9rML3/K/your_sha256_hashCkrmzwmBWsMIQqrHC1kmwwloussKnybLC+your_sha256_hashZ7JwixDzMJm5c/C1FrRwgVZ2MIqAN3CI4rlwpaa78KO4vfCiywAw3HFA8OL1wvD</data>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction3</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>3</integer>
<key>DspFuncName</key>
<string>DspClientGainAdjustStage</string>
<key>DspFuncProcessingIndex</key>
<integer>3</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>1</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>-1069547520</integer>
<key>4</key>
<integer>1095761920</integer>
<key>5</key>
<integer>3</integer>
<key>6</key>
<integer>1082130432</integer>
<key>7</key>
<integer>3</integer>
<key>8</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
<dict>
<key>DeviceID</key>
<integer>5851</integer>
<key>DeviceType</key>
<string>Microphone</string>
<key>SignalProcessing</key>
<dict>
<key>SoftwareDSP</key>
<dict>
<key>DspFunction0</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>0</integer>
<key>DspFuncName</key>
<string>DspPreGainStage</string>
<key>DspFuncProcessingIndex</key>
<integer>0</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1065353216</integer>
<key>3</key>
<integer>1065353216</integer>
</dict>
<key>PatchbayInfo</key>
<dict/>
</dict>
<key>DspFunction1</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>1</integer>
<key>DspFuncName</key>
<string>DspVolume</string>
<key>DspFuncProcessingIndex</key>
<integer>1</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>-1067450368</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1067450368</integer>
<key>5</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>0</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction2</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>2</integer>
<key>DspFuncName</key>
<string>DspNoiseReduction</string>
<key>DspFuncProcessingIndex</key>
<integer>2</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>0</integer>
<key>2</key>
<integer>1</integer>
<key>3</key>
<integer>0</integer>
<key>4</key>
<integer>-1073900105</integer>
<key>5</key>
<data>BK9/your_sha256_hashwpCGlMIcWZbC/your_sha512_hash+oMLibqPC21yjwhjOpsLhQqfCEH+nwojDpsLqEabCkoihwrZko8KYFqTCnWWmwhj/qcLplqrCAhyrwvEgq8JwjKjCurCkws+your_sha256_hashyour_sha256_hashyour_sha256_hash9rML3/K/your_sha256_hashCkrmzwmBWsMIQqrHC1kmwwloussKnybLC+your_sha256_hashZ7JwixDzMJm5c/C1FrRwgVZ2MIqAN3CI4rlwpaa78KO4vfCiywAw3HFA8OL1wvD</data>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>1</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
<key>DspFunction3</key>
<dict>
<key>FunctionInfo</key>
<dict>
<key>DspFuncInstance</key>
<integer>3</integer>
<key>DspFuncName</key>
<string>DspClientGainAdjustStage</string>
<key>DspFuncProcessingIndex</key>
<integer>3</integer>
</dict>
<key>ParameterInfo</key>
<dict>
<key>1</key>
<integer>1</integer>
<key>2</key>
<integer>0</integer>
<key>3</key>
<integer>-1069547520</integer>
<key>4</key>
<integer>1095761920</integer>
<key>5</key>
<integer>3</integer>
<key>6</key>
<integer>1082130432</integer>
<key>7</key>
<integer>3</integer>
<key>8</key>
<integer>0</integer>
</dict>
<key>PatchbayInfo</key>
<dict>
<key>InputPort0</key>
<dict>
<key>PortInstance</key>
<integer>0</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>0</integer>
</dict>
<key>InputPort1</key>
<dict>
<key>PortInstance</key>
<integer>1</integer>
<key>PortWidth</key>
<integer>1</integer>
<key>SourceFuncInstance</key>
<integer>2</integer>
<key>SourcePortIndex</key>
<integer>1</integer>
</dict>
</dict>
</dict>
</dict>
</dict>
</dict>
</array>
<key>PathMaps</key>
<array>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
<dict>
<key>Boost</key>
<integer>1</integer>
<key>NodeID</key>
<integer>18</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>33</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>1</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Boost</key>
<integer>1</integer>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>2</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>3</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>0</integer>
</dict>
</array>
<key>HardwareDownmixToMono</key>
<true/>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>4</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Boost</key>
<integer>1</integer>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>5</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>6</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Boost</key>
<integer>1</integer>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>6</integer>
<key>ProcessingState</key>
<true/>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>14</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>7</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>8</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>9</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
<key>RetaskDetectDelegate</key>
<integer>9</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>10</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>11</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>12</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>9</integer>
<key>RateCapsDelegate</key>
<integer>39</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>39</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>13</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
<key>RetaskDetectDelegate</key>
<integer>9</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>14</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>22</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>15</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>16</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>22</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>17</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Boost</key>
<integer>28</integer>
<key>NodeID</key>
<integer>9</integer>
<key>RateCapsDelegate</key>
<integer>39</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>39</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>18</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>19</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>9</integer>
<key>RateCapsDelegate</key>
<integer>39</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>39</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>22</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>20</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>21</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>22</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>22</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>38</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>27</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>23</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>24</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>25</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Boost</key>
<integer>28</integer>
<key>NodeID</key>
<integer>9</integer>
<key>RateCapsDelegate</key>
<integer>39</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>39</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>26</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>27</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>27</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>28</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>27</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>29</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>30</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>29</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>16</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>16</integer>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>10</integer>
<key>TDM</key>
<dict>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>32</integer>
<integer>96</integer>
<integer>0</integer>
<integer>128</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>31</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>NodeID</key>
<integer>34</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>68</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>74</integer>
<key>NodeID</key>
<integer>52</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>74</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>18</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>1</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>44</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>10</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>32</integer>
<integer>96</integer>
</array>
<key>TDMDevice</key>
<integer>1</integer>
</dict>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>45</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<false/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>11</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>128</integer>
</array>
<key>TDMDevice</key>
<integer>1</integer>
</dict>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>73</integer>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>73</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>2</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>0</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>32</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>34</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>68</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>74</integer>
<key>NodeID</key>
<integer>60</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>74</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>26</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>1</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>2</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMAltDevice</key>
<integer>2</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>1</integer>
</dict>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>3</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMAltDevice</key>
<integer>4</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>64</integer>
<integer>96</integer>
</array>
<key>TDMDevice</key>
<integer>3</integer>
</dict>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>73</integer>
<key>NodeID</key>
<integer>44</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>73</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>10</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>0</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>33</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>34</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>68</integer>
</dict>
</array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>3</integer>
<key>Channel</key>
<integer>3</integer>
</dict>
<dict>
<key>Bind</key>
<integer>4</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>69</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>74</integer>
<key>NodeID</key>
<integer>60</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>74</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>26</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>1</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>2</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMAltDevice</key>
<integer>2</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>1</integer>
</dict>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>3</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMAltDevice</key>
<integer>4</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>64</integer>
<integer>96</integer>
</array>
<key>TDMDevice</key>
<integer>3</integer>
</dict>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>73</integer>
<key>NodeID</key>
<integer>44</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>73</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>10</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>0</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>34</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>34</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>68</integer>
</dict>
</array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>3</integer>
</dict>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>69</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>74</integer>
<key>NodeID</key>
<integer>60</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>74</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>26</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>1</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>2</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMAltDevice</key>
<integer>2</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>1</integer>
</dict>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>73</integer>
<key>NodeID</key>
<integer>44</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>73</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>10</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>0</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>35</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>34</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>68</integer>
</dict>
</array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>3</integer>
<key>Channel</key>
<integer>3</integer>
</dict>
<dict>
<key>Bind</key>
<integer>4</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>69</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>74</integer>
<key>NodeID</key>
<integer>60</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>74</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>26</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>1</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>2</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMAltDevice</key>
<integer>2</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>1</integer>
</dict>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>3</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMAltDevice</key>
<integer>4</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>64</integer>
<integer>96</integer>
</array>
<key>TDMDevice</key>
<integer>3</integer>
</dict>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>73</integer>
<key>NodeID</key>
<integer>44</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>73</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>10</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>0</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>37</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>27</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>40</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>27</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>41</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>27</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>42</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>27</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>20</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>22</integer>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>43</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>44</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
<key>RetaskDetectDelegate</key>
<integer>9</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>45</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>46</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>47</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>48</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>49</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Mux</key>
<integer>9</integer>
<key>NodeID</key>
<integer>15</integer>
<key>PublishPath</key>
<false/>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>50</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>51</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>52</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>53</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>54</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>55</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>2</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
<key>RetaskDetectDelegate</key>
<integer>9</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>56</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>28</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>33</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>57</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>28</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>33</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>58</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>25</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>DetectDelegate</key>
<integer>32</integer>
<key>NodeID</key>
<integer>31</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>26</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>21</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>13</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>60</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>63</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>34</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>68</integer>
</dict>
</array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>3</integer>
</dict>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>4</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>35</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>69</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>74</integer>
<key>NodeID</key>
<integer>60</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>74</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>26</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>1</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>2</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMAltDevice</key>
<integer>2</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>1</integer>
</dict>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>3</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMAltDevice</key>
<integer>4</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>64</integer>
<integer>96</integer>
</array>
<key>TDMDevice</key>
<integer>3</integer>
</dict>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>73</integer>
<key>NodeID</key>
<integer>44</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>73</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>10</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>0</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>IsocSampleRate</key>
<integer>48000</integer>
<key>IsocSupport</key>
<true/>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>64</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>28</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MaximumBitDepth</key>
<integer>16</integer>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>68</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>34</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>DeferPublication</key>
<true/>
<key>DetectDelegate</key>
<dict>
<key>NAND</key>
<integer>33</integer>
<key>OR</key>
<array>
<integer>17</integer>
<integer>23</integer>
</array>
</dict>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<dict>
<key>AND</key>
<integer>33</integer>
<key>OR</key>
<array>
<integer>17</integer>
<integer>23</integer>
</array>
</dict>
<key>NodeID</key>
<integer>33</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>72</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>28</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NoPinSense</key>
<true/>
<key>NodeID</key>
<integer>34</integer>
<key>PublishPath</key>
<false/>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>29</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>16</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>10</integer>
<key>TDM</key>
<dict>
<key>SRMultiple</key>
<integer>64</integer>
<key>TDMChannel</key>
<integer>0</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>32</integer>
<integer>96</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>30</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<false/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>37</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>16</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>11</integer>
<key>TDM</key>
<dict>
<key>SRMultiple</key>
<integer>64</integer>
<key>TDMChannel</key>
<integer>0</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>32</integer>
<integer>96</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>33</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>73</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Mux</key>
<integer>9</integer>
<key>NodeID</key>
<integer>15</integer>
<key>PublishPath</key>
<false/>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>24</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>3</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>74</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>28</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>33</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>75</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Boost</key>
<integer>0</integer>
<key>NodeID</key>
<integer>28</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>33</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>76</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>DeferPublication</key>
<true/>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>23</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DeferPublication</key>
<true/>
<key>MaximumSampleRate</key>
<integer>96000</integer>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>DeferPublication</key>
<integer>1</integer>
<key>NodeID</key>
<integer>34</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>0</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Boost</key>
<integer>67</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>MinimumSampleRate</key>
<integer>32000</integer>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>33</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>77</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>22</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>4206</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>13</integer>
<key>NodeID</key>
<integer>16</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>4207</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>282984455</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>DeferPublication</key>
<true/>
<key>DetectDelegate</key>
<integer>17</integer>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>33</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>14</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>4208</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>NodeID</key>
<integer>34</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>68</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>74</integer>
<key>NodeID</key>
<integer>52</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<true/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<true/>
</dict>
<key>NodeID</key>
<integer>74</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>18</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>1</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>44</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>10</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>32</integer>
<integer>96</integer>
</array>
<key>TDMDevice</key>
<integer>1</integer>
</dict>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>45</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
<key>TransducerType</key>
<integer>0</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<false/>
<key>SoftwareVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>72</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>11</integer>
<key>TDM</key>
<dict>
<key>FrameStartDelay</key>
<integer>0</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>128</integer>
</array>
<key>TDMDevice</key>
<integer>1</integer>
</dict>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>DetectDelegate</key>
<integer>73</integer>
<key>NodeID</key>
<integer>36</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>73</integer>
</dict>
<dict>
<key>MaximumBitDepth</key>
<integer>24</integer>
<key>MaximumSampleRate</key>
<integer>48000</integer>
<key>MinimumBitDepth</key>
<integer>24</integer>
<key>MinimumSampleRate</key>
<integer>44100</integer>
<key>NodeID</key>
<integer>2</integer>
<key>TDM</key>
<dict>
<key>DeviceBusReference</key>
<integer>1</integer>
<key>DeviceChannelID</key>
<integer>0</integer>
<key>FrameStartDelay</key>
<integer>2</integer>
<key>LRClockHigh</key>
<integer>0</integer>
<key>SRMultiple</key>
<integer>256</integer>
<key>TDMChannelsOffsets</key>
<array>
<integer>0</integer>
<integer>32</integer>
</array>
<key>TDMDevice</key>
<integer>0</integer>
</dict>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>8409</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>24</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>8800</integer>
</dict>
<dict>
<key>PathMap</key>
<array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>3</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>9</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>11</integer>
</dict>
<dict>
<key>Boost</key>
<integer>3</integer>
<key>NodeID</key>
<integer>13</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>2</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>10</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>12</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>5</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>16</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>18</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>7</integer>
</dict>
</array>
<array>
<dict>
<key>NodeID</key>
<integer>19</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>5</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>6</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<false/>
<key>PublishVolume</key>
<false/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>8</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>15</integer>
</dict>
<dict>
<key>NodeID</key>
<integer>4</integer>
</dict>
</array>
</array>
</array>
<array>
<array>
<array>
<dict>
<key>NodeID</key>
<integer>17</integer>
</dict>
<dict>
<key>Amp</key>
<dict>
<key>Channels</key>
<array>
<dict>
<key>Bind</key>
<integer>1</integer>
<key>Channel</key>
<integer>1</integer>
</dict>
<dict>
<key>Bind</key>
<integer>2</integer>
<key>Channel</key>
<integer>2</integer>
</dict>
</array>
<key>MuteInputAmp</key>
<false/>
<key>PublishMute</key>
<true/>
<key>PublishVolume</key>
<true/>
<key>VolumeInputAmp</key>
<false/>
</dict>
<key>NodeID</key>
<integer>6</integer>
</dict>
</array>
</array>
</array>
</array>
<key>PathMapID</key>
<integer>8801</integer>
</dict>
</array>
</dict>
``` | /content/code_sandbox/Resources/ALC282/Platforms29.xml | xml | 2016-03-07T20:45:58 | 2024-08-14T08:57:03 | AppleALC | acidanthera/AppleALC | 3,420 | 155,903 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<vector xmlns:android="path_to_url"
android:width="24dp"
android:height="24dp"
android:viewportWidth="24"
android:viewportHeight="24">
<path
android:fillColor="?colorOnSurface"
android:pathData="M20.5,11H19V7C19,5.89 18.1,5 17,5H13V3.5A2.5,2.5 0 0,0 10.5,1A2.5,2.5 0 0,0 8,3.5V5H4A2,2 0 0,0 2,7V10.8H3.5C5,10.8 6.2,12 6.2,13.5C6.2,15 5,16.2 3.5,16.2H2V20A2,2 0 0,0 4,22H7.8V20.5C7.8,19 9,17.8 10.5,17.8C12,17.8 13.2,19 13.2,20.5V22H17A2,2 0 0,0 19,20V16H20.5A2.5,2.5 0 0,0 23,13.5A2.5,2.5 0 0,0 20.5,11Z" />
</vector>
``` | /content/code_sandbox/app/apk/src/main/res/drawable/ic_module_filled_md2.xml | xml | 2016-09-08T12:42:53 | 2024-08-16T19:41:25 | Magisk | topjohnwu/Magisk | 46,424 | 349 |
```xml
export class ResetSecret {
input_secret: string;
confirm_secret: string;
constructor() {
this.confirm_secret = '';
this.input_secret = '';
}
}
``` | /content/code_sandbox/src/portal/src/app/base/account-settings/account.ts | xml | 2016-01-28T21:10:28 | 2024-08-16T15:28:34 | harbor | goharbor/harbor | 23,335 | 37 |
```xml
export default {
get forceTouchAvailable() {
return false;
},
};
``` | /content/code_sandbox/src/PlatformConstants.web.ts | xml | 2016-10-27T08:31:38 | 2024-08-16T12:03:40 | react-native-gesture-handler | software-mansion/react-native-gesture-handler | 5,989 | 18 |
```xml
/**
* @license
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at path_to_url
*/
/**
* Template string function that can be used to dedent a given string
* literal. The smallest common indentation will be omitted.
*/
export function dedent(strings: TemplateStringsArray, ...values: any[]) {
let joinedString = '';
for (let i = 0; i < values.length; i++) {
joinedString += `${strings[i]}${values[i]}`;
}
joinedString += strings[strings.length - 1];
const matches = joinedString.match(/^[ \t]*(?=\S)/gm);
if (matches === null) {
return joinedString;
}
const minLineIndent = Math.min(...matches.map(el => el.length));
const omitMinIndentRegex = new RegExp(`^[ \\t]{${minLineIndent}}`, 'gm');
return minLineIndent > 0 ? joinedString.replace(omitMinIndentRegex, '') : joinedString;
}
``` | /content/code_sandbox/src/cdk/testing/private/text-dedent.ts | xml | 2016-01-04T18:50:02 | 2024-08-16T11:21:13 | components | angular/components | 24,263 | 226 |
```xml
<AssumeRoleResponse xmlns="path_to_url"> <AssumeRoleResult>
<AssumedRoleUser>
<AssumedRoleId>AROARZQKN6ARBA3MU7HQ4:iam-demo-role-session-facb92a0-a797-44e1-8430-c79a5b067201</AssumedRoleId>
<Arn>arn:aws:sts::1111111222222:assumed-role/iam-demo-role/iam-demo-role-session-facb92a0-a797-44e1-8430-c79a5b067201</Arn>
</AssumedRoleUser>
<Credentials>
<AccessKeyId>AAABBBBBBBBB</AccessKeyId>
<SecretAccessKey>AAABBBBBBBBB</SecretAccessKey>
<SessionToken>AAABBBBBBBBB+USs</SessionToken>
<Expiration>2040-03-11T15:19:02Z</Expiration>
</Credentials>
</AssumeRoleResult>
<ResponseMetadata>
<RequestId>d52b113b-597f-41e6-99d6-ed6e53a915bf</RequestId>
</ResponseMetadata>
</AssumeRoleResponse>
``` | /content/code_sandbox/cpp/example_code/iam/tests/mock_input/10-AssumeRole.xml | xml | 2016-08-18T19:06:57 | 2024-08-16T18:59:44 | aws-doc-sdk-examples | awsdocs/aws-doc-sdk-examples | 9,298 | 261 |
```xml
import { FormError } from '../FormError';
import { InputLabeled } from '../Input/InputLabeled';
import { ItemProps } from '../InputList';
import { EnvVar } from './types';
export function EnvironmentVariableItem({
item,
onChange,
disabled,
error,
readOnly,
index,
}: ItemProps<EnvVar>) {
return (
<div className="relative flex w-full flex-col">
<div className="flex w-full items-start gap-2">
<div className="w-1/2">
<InputLabeled
className="w-full"
data-cy={`env-name_${index}`}
label="name"
required
value={item.name}
onChange={(e) => handleChange({ name: e.target.value })}
disabled={disabled}
needsDeletion={item.needsDeletion}
readOnly={readOnly}
placeholder="e.g. FOO"
size="small"
id={`env-name${index}`}
/>
{error && (
<div>
<FormError className="!mb-0 mt-1">
{Object.values(error)[0]}
</FormError>
</div>
)}
</div>
<InputLabeled
className="w-1/2"
data-cy={`env-value_${index}`}
label="value"
value={item.value}
onChange={(e) => handleChange({ value: e.target.value })}
disabled={disabled}
needsDeletion={item.needsDeletion}
readOnly={readOnly}
placeholder="e.g. bar"
size="small"
id={`env-value${index}`}
/>
</div>
</div>
);
function handleChange(partial: Partial<EnvVar>) {
onChange({ ...item, ...partial });
}
}
``` | /content/code_sandbox/app/react/components/form-components/EnvironmentVariablesFieldset/EnvironmentVariableItem.tsx | xml | 2016-05-19T20:15:28 | 2024-08-16T19:15:14 | portainer | portainer/portainer | 30,083 | 384 |
```xml
import { ObjectType } from "./ObjectType"
import { EntitySchema } from ".."
/**
* Entity target.
*/
export type EntityTarget<Entity> =
| ObjectType<Entity>
| EntitySchema<Entity>
| string
| { type: Entity; name: string }
``` | /content/code_sandbox/src/common/EntityTarget.ts | xml | 2016-02-29T07:41:14 | 2024-08-16T18:28:52 | typeorm | typeorm/typeorm | 33,875 | 56 |
```xml
import { deepMix } from '@antv/util';
import { TransformComponent as TC } from '../runtime';
import { JitterXTransform } from '../spec';
import { column, columnOf } from './utils/helper';
import { rangeOf, interpolate } from './jitter';
export type JitterXOptions = Omit<JitterXTransform, 'type'>;
/**
* The JitterX transform produce dy channels for marks (especially for point)
* with ordinal x and y dimension, say to make them jitter in their own space.
*/
export const JitterX: TC<JitterXOptions> = (options = {}) => {
const { padding = 0, random = Math.random } = options;
return (I, mark) => {
const { encode, scale } = mark;
const { x: scaleX } = scale;
const [X] = columnOf(encode, 'x');
const rangeX = rangeOf(X, scaleX, padding);
const DX = I.map(() => interpolate(random(), ...rangeX));
return [
I,
deepMix({ scale: { x: { padding: 0.5 } } }, mark, {
encode: { dx: column(DX) },
}),
];
};
};
JitterX.props = {};
``` | /content/code_sandbox/src/transform/jitterX.ts | xml | 2016-05-26T09:21:04 | 2024-08-15T16:11:17 | G2 | antvis/G2 | 12,060 | 270 |
```xml
/*
* one or more contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright ownership.
*/
import React from 'react';
import {formatDate} from 'modules/utils/date';
import {TimeStamp} from './styled';
import {flowNodeTimeStampStore} from 'modules/stores/flowNodeTimeStamp';
import {observer} from 'mobx-react';
type Props = {
timeStamp: null | string;
};
const TimeStampLabel: React.FC<Props> = observer(({timeStamp}) => {
const {isTimeStampVisible} = flowNodeTimeStampStore.state;
return isTimeStampVisible && timeStamp ? (
<TimeStamp>{formatDate(timeStamp)}</TimeStamp>
) : null;
});
export {TimeStampLabel};
``` | /content/code_sandbox/operate/client/src/App/ProcessInstance/FlowNodeInstancesTree/Bar/TimeStampLabel/index.tsx | xml | 2016-03-20T03:38:04 | 2024-08-16T19:59:58 | camunda | camunda/camunda | 3,172 | 153 |
```xml
import * as React from 'react';
import createSvgIcon from '../utils/createSvgIcon';
const EditStyleIcon = createSvgIcon({
svg: ({ classes }) => (
<svg xmlns="path_to_url" viewBox="0 0 2048 2048" className={classes.svg} focusable="false">
<path d="M1055 896H609l-85 256H384L768 0h128l330 988-106 105-65-197zm-43-128L832 228 652 768h360zm581 131q42 0 78 14t63 41 42 61 16 79q0 39-15 76t-43 65l-717 717-377 94 94-377 717-716q28-28 65-41t77-13zm50 246q21-21 21-51 0-32-20-50t-52-19q-14 0-27 4t-23 14l-692 692-34 135 135-34 692-691z" />
</svg>
),
displayName: 'EditStyleIcon',
});
export default EditStyleIcon;
``` | /content/code_sandbox/packages/react-icons-mdl2/src/components/EditStyleIcon.tsx | xml | 2016-06-06T15:03:44 | 2024-08-16T18:49:29 | fluentui | microsoft/fluentui | 18,221 | 266 |
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "path_to_url">
<plist version="1.0">
<dict>
<key>BuildMachineOSBuild</key>
<string>16F73</string>
<key>CFBundleDevelopmentRegion</key>
<string>English</string>
<key>CFBundleExecutable</key>
<string>USBInjectAll</string>
<key>CFBundleGetInfoString</key>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleName</key>
<string>USBInjectAll</string>
<key>CFBundlePackageType</key>
<string>KEXT</string>
<key>CFBundleShortVersionString</key>
<string>0.6.0</string>
<key>CFBundleSignature</key>
<string>????</string>
<key>CFBundleSupportedPlatforms</key>
<array>
<string>MacOSX</string>
</array>
<key>CFBundleVersion</key>
<string>0.6.0</string>
<key>DTCompiler</key>
<string>com.apple.compilers.llvm.clang.1_0</string>
<key>DTPlatformBuild</key>
<string>8E2002</string>
<key>DTPlatformVersion</key>
<string>GM</string>
<key>DTSDKBuild</key>
<string>15E60</string>
<key>DTSDKName</key>
<string>macosx10.11</string>
<key>DTXcode</key>
<string>0832</string>
<key>DTXcodeBuild</key>
<string>8E2002</string>
<key>IOKitPersonalities</key>
<dict>
<key>ConfigurationData</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>Configuration</key>
<dict>
<key>8086_1e31</key>
<dict>
<key>port-count</key>
<data>
CAAAAA==
</data>
<key>ports</key>
<dict>
<key>HS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AQAAAA==
</data>
</dict>
<key>HS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AgAAAA==
</data>
</dict>
<key>HS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AwAAAA==
</data>
</dict>
<key>HS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BAAAAA==
</data>
</dict>
<key>SSP5</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BQAAAA==
</data>
</dict>
<key>SSP6</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BgAAAA==
</data>
</dict>
<key>SSP7</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BwAAAA==
</data>
</dict>
<key>SSP8</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CAAAAA==
</data>
</dict>
</dict>
</dict>
<key>8086_8xxx</key>
<dict>
<key>port-count</key>
<data>
FQAAAA==
</data>
<key>ports</key>
<dict>
<key>HS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AQAAAA==
</data>
</dict>
<key>HS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AgAAAA==
</data>
</dict>
<key>HS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AwAAAA==
</data>
</dict>
<key>HS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BAAAAA==
</data>
</dict>
<key>HS05</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BQAAAA==
</data>
</dict>
<key>HS06</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BgAAAA==
</data>
</dict>
<key>HS07</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BwAAAA==
</data>
</dict>
<key>HS08</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CAAAAA==
</data>
</dict>
<key>HS09</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CQAAAA==
</data>
</dict>
<key>HS10</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CgAAAA==
</data>
</dict>
<key>HS11</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CwAAAA==
</data>
</dict>
<key>HS12</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DAAAAA==
</data>
</dict>
<key>HS13</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DQAAAA==
</data>
</dict>
<key>HS14</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DgAAAA==
</data>
</dict>
<key>SSP1</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EAAAAA==
</data>
</dict>
<key>SSP2</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EQAAAA==
</data>
</dict>
<key>SSP3</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EgAAAA==
</data>
</dict>
<key>SSP4</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EwAAAA==
</data>
</dict>
<key>SSP5</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FAAAAA==
</data>
</dict>
<key>SSP6</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FQAAAA==
</data>
</dict>
</dict>
</dict>
<key>8086_9cb1</key>
<dict>
<key>port-count</key>
<data>
DwAAAA==
</data>
<key>ports</key>
<dict>
<key>HS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AQAAAA==
</data>
</dict>
<key>HS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AgAAAA==
</data>
</dict>
<key>HS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AwAAAA==
</data>
</dict>
<key>HS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BAAAAA==
</data>
</dict>
<key>HS05</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BQAAAA==
</data>
</dict>
<key>HS06</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BgAAAA==
</data>
</dict>
<key>HS07</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BwAAAA==
</data>
</dict>
<key>HS08</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CAAAAA==
</data>
</dict>
<key>HS09</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CQAAAA==
</data>
</dict>
<key>HS10</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CgAAAA==
</data>
</dict>
<key>HS11</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CwAAAA==
</data>
</dict>
<key>SSP1</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DAAAAA==
</data>
</dict>
<key>SSP2</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DQAAAA==
</data>
</dict>
<key>SSP3</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DgAAAA==
</data>
</dict>
<key>SSP4</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DwAAAA==
</data>
</dict>
</dict>
</dict>
<key>8086_9d2f</key>
<dict>
<key>port-count</key>
<data>
EgAAAA==
</data>
<key>ports</key>
<dict>
<key>HS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AQAAAA==
</data>
</dict>
<key>HS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AgAAAA==
</data>
</dict>
<key>HS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AwAAAA==
</data>
</dict>
<key>HS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BAAAAA==
</data>
</dict>
<key>HS05</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BQAAAA==
</data>
</dict>
<key>HS06</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BgAAAA==
</data>
</dict>
<key>HS07</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BwAAAA==
</data>
</dict>
<key>HS08</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CAAAAA==
</data>
</dict>
<key>HS09</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CQAAAA==
</data>
</dict>
<key>HS10</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CgAAAA==
</data>
</dict>
<key>SS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DQAAAA==
</data>
</dict>
<key>SS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DgAAAA==
</data>
</dict>
<key>SS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DwAAAA==
</data>
</dict>
<key>SS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EAAAAA==
</data>
</dict>
<key>SS05</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EQAAAA==
</data>
</dict>
<key>SS06</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EgAAAA==
</data>
</dict>
<key>USR1</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CwAAAA==
</data>
</dict>
<key>USR2</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DAAAAA==
</data>
</dict>
</dict>
</dict>
<key>8086_9xxx</key>
<dict>
<key>port-count</key>
<data>
DQAAAA==
</data>
<key>ports</key>
<dict>
<key>HS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AQAAAA==
</data>
</dict>
<key>HS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AgAAAA==
</data>
</dict>
<key>HS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AwAAAA==
</data>
</dict>
<key>HS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BAAAAA==
</data>
</dict>
<key>HS05</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BQAAAA==
</data>
</dict>
<key>HS06</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BgAAAA==
</data>
</dict>
<key>HS07</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BwAAAA==
</data>
</dict>
<key>HS08</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CAAAAA==
</data>
</dict>
<key>HS09</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CQAAAA==
</data>
</dict>
<key>SSP1</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CgAAAA==
</data>
</dict>
<key>SSP2</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CwAAAA==
</data>
</dict>
<key>SSP3</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DAAAAA==
</data>
</dict>
<key>SSP4</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DQAAAA==
</data>
</dict>
</dict>
</dict>
<key>8086_a12f</key>
<dict>
<key>port-count</key>
<data>
GgAAAA==
</data>
<key>ports</key>
<dict>
<key>HS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AQAAAA==
</data>
</dict>
<key>HS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AgAAAA==
</data>
</dict>
<key>HS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AwAAAA==
</data>
</dict>
<key>HS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BAAAAA==
</data>
</dict>
<key>HS05</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BQAAAA==
</data>
</dict>
<key>HS06</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BgAAAA==
</data>
</dict>
<key>HS07</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BwAAAA==
</data>
</dict>
<key>HS08</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CAAAAA==
</data>
</dict>
<key>HS09</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CQAAAA==
</data>
</dict>
<key>HS10</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CgAAAA==
</data>
</dict>
<key>HS11</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CwAAAA==
</data>
</dict>
<key>HS12</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DAAAAA==
</data>
</dict>
<key>HS13</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DQAAAA==
</data>
</dict>
<key>HS14</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DgAAAA==
</data>
</dict>
<key>SS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EQAAAA==
</data>
</dict>
<key>SS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EgAAAA==
</data>
</dict>
<key>SS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EwAAAA==
</data>
</dict>
<key>SS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FAAAAA==
</data>
</dict>
<key>SS05</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FQAAAA==
</data>
</dict>
<key>SS06</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FgAAAA==
</data>
</dict>
<key>SS07</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FwAAAA==
</data>
</dict>
<key>SS08</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
GAAAAA==
</data>
</dict>
<key>SS09</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
GQAAAA==
</data>
</dict>
<key>SS10</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
GgAAAA==
</data>
</dict>
<key>USR1</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DwAAAA==
</data>
</dict>
<key>USR2</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EAAAAA==
</data>
</dict>
</dict>
</dict>
<key>8086_a2af</key>
<dict>
<key>port-count</key>
<data>
GgAAAA==
</data>
<key>ports</key>
<dict>
<key>HS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AQAAAA==
</data>
</dict>
<key>HS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AgAAAA==
</data>
</dict>
<key>HS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
AwAAAA==
</data>
</dict>
<key>HS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BAAAAA==
</data>
</dict>
<key>HS05</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BQAAAA==
</data>
</dict>
<key>HS06</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BgAAAA==
</data>
</dict>
<key>HS07</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
BwAAAA==
</data>
</dict>
<key>HS08</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CAAAAA==
</data>
</dict>
<key>HS09</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CQAAAA==
</data>
</dict>
<key>HS10</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CgAAAA==
</data>
</dict>
<key>HS11</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
CwAAAA==
</data>
</dict>
<key>HS12</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DAAAAA==
</data>
</dict>
<key>HS13</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DQAAAA==
</data>
</dict>
<key>HS14</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DgAAAA==
</data>
</dict>
<key>SS01</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EQAAAA==
</data>
</dict>
<key>SS02</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EgAAAA==
</data>
</dict>
<key>SS03</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EwAAAA==
</data>
</dict>
<key>SS04</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FAAAAA==
</data>
</dict>
<key>SS05</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FQAAAA==
</data>
</dict>
<key>SS06</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FgAAAA==
</data>
</dict>
<key>SS07</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
FwAAAA==
</data>
</dict>
<key>SS08</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
GAAAAA==
</data>
</dict>
<key>SS09</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
GQAAAA==
</data>
</dict>
<key>SS10</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
GgAAAA==
</data>
</dict>
<key>USR1</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
DwAAAA==
</data>
</dict>
<key>USR2</key>
<dict>
<key>UsbConnector</key>
<integer>3</integer>
<key>port</key>
<data>
EAAAAA==
</data>
</dict>
</dict>
</dict>
<key>EH01</key>
<dict>
<key>port-count</key>
<data>
CAAAAA==
</data>
<key>ports</key>
<dict>
<key>PR11</key>
<dict>
<key>UsbConnector</key>
<integer>255</integer>
<key>port</key>
<data>
AQAAAA==
</data>
</dict>
<key>PR12</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
AgAAAA==
</data>
</dict>
<key>PR13</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
AwAAAA==
</data>
</dict>
<key>PR14</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
BAAAAA==
</data>
</dict>
<key>PR15</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
BQAAAA==
</data>
</dict>
<key>PR16</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
BgAAAA==
</data>
</dict>
<key>PR17</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
BwAAAA==
</data>
</dict>
<key>PR18</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
CAAAAA==
</data>
</dict>
</dict>
</dict>
<key>EH02</key>
<dict>
<key>port-count</key>
<data>
BgAAAA==
</data>
<key>ports</key>
<dict>
<key>PR21</key>
<dict>
<key>UsbConnector</key>
<integer>255</integer>
<key>port</key>
<data>
AQAAAA==
</data>
</dict>
<key>PR22</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
AgAAAA==
</data>
</dict>
<key>PR23</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
AwAAAA==
</data>
</dict>
<key>PR24</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
BAAAAA==
</data>
</dict>
<key>PR25</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
BQAAAA==
</data>
</dict>
<key>PR26</key>
<dict>
<key>UsbConnector</key>
<integer>0</integer>
<key>port</key>
<data>
BgAAAA==
</data>
</dict>
</dict>
</dict>
<key>HUB1</key>
<dict>
<key>port-count</key>
<data>
CAAAAA==
</data>
<key>ports</key>
<dict>
<key>HP11</key>
<dict>
<key>port</key>
<data>
AQAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP12</key>
<dict>
<key>port</key>
<data>
AgAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP13</key>
<dict>
<key>port</key>
<data>
AwAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP14</key>
<dict>
<key>port</key>
<data>
BAAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP15</key>
<dict>
<key>port</key>
<data>
BQAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP16</key>
<dict>
<key>port</key>
<data>
BgAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP17</key>
<dict>
<key>port</key>
<data>
BwAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP18</key>
<dict>
<key>port</key>
<data>
CAAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
</dict>
</dict>
<key>HUB2</key>
<dict>
<key>port-count</key>
<data>
CAAAAA==
</data>
<key>ports</key>
<dict>
<key>HP21</key>
<dict>
<key>port</key>
<data>
AQAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP22</key>
<dict>
<key>port</key>
<data>
AgAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP23</key>
<dict>
<key>port</key>
<data>
AwAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP24</key>
<dict>
<key>port</key>
<data>
BAAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP25</key>
<dict>
<key>port</key>
<data>
BQAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP26</key>
<dict>
<key>port</key>
<data>
BgAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP27</key>
<dict>
<key>port</key>
<data>
BwAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
<key>HP28</key>
<dict>
<key>port</key>
<data>
CAAAAA==
</data>
<key>portType</key>
<integer>2</integer>
</dict>
</dict>
</dict>
</dict>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll_config</string>
<key>IOMatchCategory</key>
<string>org_rehabman_USBInjectAll_config</string>
<key>IOProviderClass</key>
<string>IOResources</string>
</dict>
<key>MacBook8,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBook8,1</string>
</dict>
<key>MacBook8,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBook8,1</string>
</dict>
<key>MacBook8,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBook8,1</string>
</dict>
<key>MacBook8,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBook8,1</string>
</dict>
<key>MacBook8,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBook8,1</string>
</dict>
<key>MacBook8,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBook8,1</string>
</dict>
<key>MacBook9,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBook9,1</string>
</dict>
<key>MacBook9,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBook9,1</string>
</dict>
<key>MacBook9,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBook9,1</string>
</dict>
<key>MacBook9,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBook9,1</string>
</dict>
<key>MacBook9,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBook9,1</string>
</dict>
<key>MacBook9,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBook9,1</string>
</dict>
<key>MacBookAir4,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookAir4,1</string>
</dict>
<key>MacBookAir4,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookAir4,1</string>
</dict>
<key>MacBookAir4,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookAir4,1</string>
</dict>
<key>MacBookAir4,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookAir4,1</string>
</dict>
<key>MacBookAir4,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookAir4,1</string>
</dict>
<key>MacBookAir4,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookAir4,1</string>
</dict>
<key>MacBookAir4,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookAir4,2</string>
</dict>
<key>MacBookAir4,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookAir4,2</string>
</dict>
<key>MacBookAir4,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookAir4,2</string>
</dict>
<key>MacBookAir4,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookAir4,2</string>
</dict>
<key>MacBookAir4,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookAir4,2</string>
</dict>
<key>MacBookAir4,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookAir4,2</string>
</dict>
<key>MacBookAir5,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookAir5,1</string>
</dict>
<key>MacBookAir5,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookAir5,1</string>
</dict>
<key>MacBookAir5,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookAir5,1</string>
</dict>
<key>MacBookAir5,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookAir5,1</string>
</dict>
<key>MacBookAir5,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookAir5,1</string>
</dict>
<key>MacBookAir5,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookAir5,1</string>
</dict>
<key>MacBookAir5,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookAir5,2</string>
</dict>
<key>MacBookAir5,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookAir5,2</string>
</dict>
<key>MacBookAir5,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookAir5,2</string>
</dict>
<key>MacBookAir5,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookAir5,2</string>
</dict>
<key>MacBookAir5,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookAir5,2</string>
</dict>
<key>MacBookAir5,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookAir5,2</string>
</dict>
<key>MacBookAir6,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookAir6,1</string>
</dict>
<key>MacBookAir6,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookAir6,1</string>
</dict>
<key>MacBookAir6,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookAir6,1</string>
</dict>
<key>MacBookAir6,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookAir6,1</string>
</dict>
<key>MacBookAir6,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookAir6,1</string>
</dict>
<key>MacBookAir6,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookAir6,1</string>
</dict>
<key>MacBookAir6,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookAir6,2</string>
</dict>
<key>MacBookAir6,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookAir6,2</string>
</dict>
<key>MacBookAir6,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookAir6,2</string>
</dict>
<key>MacBookAir6,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookAir6,2</string>
</dict>
<key>MacBookAir6,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookAir6,2</string>
</dict>
<key>MacBookAir6,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookAir6,2</string>
</dict>
<key>MacBookAir7,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookAir7,1</string>
</dict>
<key>MacBookAir7,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookAir7,1</string>
</dict>
<key>MacBookAir7,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookAir7,1</string>
</dict>
<key>MacBookAir7,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookAir7,1</string>
</dict>
<key>MacBookAir7,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookAir7,1</string>
</dict>
<key>MacBookAir7,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookAir7,1</string>
</dict>
<key>MacBookAir7,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookAir7,2</string>
</dict>
<key>MacBookAir7,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookAir7,2</string>
</dict>
<key>MacBookAir7,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookAir7,2</string>
</dict>
<key>MacBookAir7,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookAir7,2</string>
</dict>
<key>MacBookAir7,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookAir7,2</string>
</dict>
<key>MacBookAir7,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookAir7,2</string>
</dict>
<key>MacBookPro10,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro10,1</string>
</dict>
<key>MacBookPro10,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro10,1</string>
</dict>
<key>MacBookPro10,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro10,1</string>
</dict>
<key>MacBookPro10,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro10,1</string>
</dict>
<key>MacBookPro10,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro10,1</string>
</dict>
<key>MacBookPro10,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro10,1</string>
</dict>
<key>MacBookPro11,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro11,1</string>
</dict>
<key>MacBookPro11,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro11,1</string>
</dict>
<key>MacBookPro11,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro11,1</string>
</dict>
<key>MacBookPro11,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro11,1</string>
</dict>
<key>MacBookPro11,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro11,1</string>
</dict>
<key>MacBookPro11,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro11,1</string>
</dict>
<key>MacBookPro11,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro11,2</string>
</dict>
<key>MacBookPro11,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro11,2</string>
</dict>
<key>MacBookPro11,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro11,2</string>
</dict>
<key>MacBookPro11,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro11,2</string>
</dict>
<key>MacBookPro11,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro11,2</string>
</dict>
<key>MacBookPro11,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro11,2</string>
</dict>
<key>MacBookPro11,3-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro11,3</string>
</dict>
<key>MacBookPro11,3-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro11,3</string>
</dict>
<key>MacBookPro11,3-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro11,3</string>
</dict>
<key>MacBookPro11,3-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro11,3</string>
</dict>
<key>MacBookPro11,3-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro11,3</string>
</dict>
<key>MacBookPro11,3-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro11,3</string>
</dict>
<key>MacBookPro11,4-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro11,4</string>
</dict>
<key>MacBookPro11,4-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro11,4</string>
</dict>
<key>MacBookPro11,4-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro11,4</string>
</dict>
<key>MacBookPro11,4-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro11,4</string>
</dict>
<key>MacBookPro11,4-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro11,4</string>
</dict>
<key>MacBookPro11,4-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro11,4</string>
</dict>
<key>MacBookPro11,5-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro11,5</string>
</dict>
<key>MacBookPro11,5-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro11,5</string>
</dict>
<key>MacBookPro11,5-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro11,5</string>
</dict>
<key>MacBookPro11,5-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro11,5</string>
</dict>
<key>MacBookPro11,5-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro11,5</string>
</dict>
<key>MacBookPro11,5-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro11,5</string>
</dict>
<key>MacBookPro12,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro12,1</string>
</dict>
<key>MacBookPro12,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro12,1</string>
</dict>
<key>MacBookPro12,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro12,1</string>
</dict>
<key>MacBookPro12,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro12,1</string>
</dict>
<key>MacBookPro12,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro12,1</string>
</dict>
<key>MacBookPro12,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro12,1</string>
</dict>
<key>MacBookPro12,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro12,2</string>
</dict>
<key>MacBookPro12,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro12,2</string>
</dict>
<key>MacBookPro12,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro12,2</string>
</dict>
<key>MacBookPro12,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro12,2</string>
</dict>
<key>MacBookPro12,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro12,2</string>
</dict>
<key>MacBookPro12,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro12,2</string>
</dict>
<key>MacBookPro13,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro13,1</string>
</dict>
<key>MacBookPro13,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro13,1</string>
</dict>
<key>MacBookPro13,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro13,1</string>
</dict>
<key>MacBookPro13,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro13,1</string>
</dict>
<key>MacBookPro13,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro13,1</string>
</dict>
<key>MacBookPro13,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro13,1</string>
</dict>
<key>MacBookPro13,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro13,2</string>
</dict>
<key>MacBookPro13,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro13,2</string>
</dict>
<key>MacBookPro13,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro13,2</string>
</dict>
<key>MacBookPro13,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro13,2</string>
</dict>
<key>MacBookPro13,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro13,2</string>
</dict>
<key>MacBookPro13,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro13,2</string>
</dict>
<key>MacBookPro13,3-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro13,3</string>
</dict>
<key>MacBookPro13,3-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro13,3</string>
</dict>
<key>MacBookPro13,3-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro13,3</string>
</dict>
<key>MacBookPro13,3-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro13,3</string>
</dict>
<key>MacBookPro13,3-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro13,3</string>
</dict>
<key>MacBookPro13,3-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro13,3</string>
</dict>
<key>MacBookPro6,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro6,1</string>
</dict>
<key>MacBookPro6,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro6,1</string>
</dict>
<key>MacBookPro6,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro6,1</string>
</dict>
<key>MacBookPro6,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro6,1</string>
</dict>
<key>MacBookPro6,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro6,1</string>
</dict>
<key>MacBookPro6,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro6,1</string>
</dict>
<key>MacBookPro6,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro6,2</string>
</dict>
<key>MacBookPro6,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro6,2</string>
</dict>
<key>MacBookPro6,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro6,2</string>
</dict>
<key>MacBookPro6,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro6,2</string>
</dict>
<key>MacBookPro6,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro6,2</string>
</dict>
<key>MacBookPro6,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro6,2</string>
</dict>
<key>MacBookPro7,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro7,1</string>
</dict>
<key>MacBookPro7,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro7,1</string>
</dict>
<key>MacBookPro7,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro7,1</string>
</dict>
<key>MacBookPro7,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro7,1</string>
</dict>
<key>MacBookPro7,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro7,1</string>
</dict>
<key>MacBookPro7,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro7,1</string>
</dict>
<key>MacBookPro8,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro8,1</string>
</dict>
<key>MacBookPro8,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro8,1</string>
</dict>
<key>MacBookPro8,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro8,1</string>
</dict>
<key>MacBookPro8,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro8,1</string>
</dict>
<key>MacBookPro8,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro8,1</string>
</dict>
<key>MacBookPro8,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro8,1</string>
</dict>
<key>MacBookPro8,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro8,2</string>
</dict>
<key>MacBookPro8,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro8,2</string>
</dict>
<key>MacBookPro8,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro8,2</string>
</dict>
<key>MacBookPro8,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro8,2</string>
</dict>
<key>MacBookPro8,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro8,2</string>
</dict>
<key>MacBookPro8,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro8,2</string>
</dict>
<key>MacBookPro8,3-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro8,3</string>
</dict>
<key>MacBookPro8,3-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro8,3</string>
</dict>
<key>MacBookPro8,3-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro8,3</string>
</dict>
<key>MacBookPro8,3-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro8,3</string>
</dict>
<key>MacBookPro8,3-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro8,3</string>
</dict>
<key>MacBookPro8,3-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro8,3</string>
</dict>
<key>MacBookPro9,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro9,1</string>
</dict>
<key>MacBookPro9,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro9,1</string>
</dict>
<key>MacBookPro9,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro9,1</string>
</dict>
<key>MacBookPro9,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro9,1</string>
</dict>
<key>MacBookPro9,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro9,1</string>
</dict>
<key>MacBookPro9,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro9,1</string>
</dict>
<key>MacBookPro9,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookPro9,2</string>
</dict>
<key>MacBookPro9,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookPro9,2</string>
</dict>
<key>MacBookPro9,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookPro9,2</string>
</dict>
<key>MacBookPro9,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookPro9,2</string>
</dict>
<key>MacBookPro9,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookPro9,2</string>
</dict>
<key>MacBookPro9,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookPro9,2</string>
</dict>
<key>MacBookpro10,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacBookpro10,2</string>
</dict>
<key>MacBookpro10,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacBookpro10,2</string>
</dict>
<key>MacBookpro10,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacBookpro10,2</string>
</dict>
<key>MacBookpro10,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacBookpro10,2</string>
</dict>
<key>MacBookpro10,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacBookpro10,2</string>
</dict>
<key>MacBookpro10,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacBookpro10,2</string>
</dict>
<key>MacPro3,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacPro3,1</string>
</dict>
<key>MacPro3,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacPro3,1</string>
</dict>
<key>MacPro3,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacPro3,1</string>
</dict>
<key>MacPro3,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacPro3,1</string>
</dict>
<key>MacPro3,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacPro3,1</string>
</dict>
<key>MacPro3,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacPro3,1</string>
</dict>
<key>MacPro4,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacPro4,1</string>
</dict>
<key>MacPro4,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacPro4,1</string>
</dict>
<key>MacPro4,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacPro4,1</string>
</dict>
<key>MacPro4,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacPro4,1</string>
</dict>
<key>MacPro4,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacPro4,1</string>
</dict>
<key>MacPro4,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacPro4,1</string>
</dict>
<key>MacPro5,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacPro5,1</string>
</dict>
<key>MacPro5,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacPro5,1</string>
</dict>
<key>MacPro5,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacPro5,1</string>
</dict>
<key>MacPro5,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacPro5,1</string>
</dict>
<key>MacPro5,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacPro5,1</string>
</dict>
<key>MacPro5,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacPro5,1</string>
</dict>
<key>MacPro6,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>MacPro6,1</string>
</dict>
<key>MacPro6,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>MacPro6,1</string>
</dict>
<key>MacPro6,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>MacPro6,1</string>
</dict>
<key>MacPro6,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>MacPro6,1</string>
</dict>
<key>MacPro6,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>MacPro6,1</string>
</dict>
<key>MacPro6,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>MacPro6,1</string>
</dict>
<key>Macmini5,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>Macmini5,1</string>
</dict>
<key>Macmini5,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>Macmini5,1</string>
</dict>
<key>Macmini5,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>Macmini5,1</string>
</dict>
<key>Macmini5,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>Macmini5,1</string>
</dict>
<key>Macmini5,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>Macmini5,1</string>
</dict>
<key>Macmini5,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>Macmini5,1</string>
</dict>
<key>Macmini5,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>Macmini5,2</string>
</dict>
<key>Macmini5,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>Macmini5,2</string>
</dict>
<key>Macmini5,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>Macmini5,2</string>
</dict>
<key>Macmini5,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>Macmini5,2</string>
</dict>
<key>Macmini5,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>Macmini5,2</string>
</dict>
<key>Macmini5,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>Macmini5,2</string>
</dict>
<key>Macmini5,3-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>Macmini5,3</string>
</dict>
<key>Macmini5,3-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>Macmini5,3</string>
</dict>
<key>Macmini5,3-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>Macmini5,3</string>
</dict>
<key>Macmini5,3-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>Macmini5,3</string>
</dict>
<key>Macmini5,3-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>Macmini5,3</string>
</dict>
<key>Macmini5,3-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>Macmini5,3</string>
</dict>
<key>Macmini6,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>Macmini6,1</string>
</dict>
<key>Macmini6,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>Macmini6,1</string>
</dict>
<key>Macmini6,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>Macmini6,1</string>
</dict>
<key>Macmini6,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>Macmini6,1</string>
</dict>
<key>Macmini6,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>Macmini6,1</string>
</dict>
<key>Macmini6,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>Macmini6,1</string>
</dict>
<key>Macmini6,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>Macmini6,2</string>
</dict>
<key>Macmini6,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>Macmini6,2</string>
</dict>
<key>Macmini6,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>Macmini6,2</string>
</dict>
<key>Macmini6,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>Macmini6,2</string>
</dict>
<key>Macmini6,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>Macmini6,2</string>
</dict>
<key>Macmini6,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>Macmini6,2</string>
</dict>
<key>Macmini7,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>Macmini7,1</string>
</dict>
<key>Macmini7,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>Macmini7,1</string>
</dict>
<key>Macmini7,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>Macmini7,1</string>
</dict>
<key>Macmini7,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>Macmini7,1</string>
</dict>
<key>Macmini7,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>Macmini7,1</string>
</dict>
<key>Macmini7,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>Macmini7,1</string>
</dict>
<key>iMac10,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac10,1</string>
</dict>
<key>iMac10,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac10,1</string>
</dict>
<key>iMac10,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac10,1</string>
</dict>
<key>iMac10,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac10,1</string>
</dict>
<key>iMac10,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac10,1</string>
</dict>
<key>iMac10,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac10,1</string>
</dict>
<key>iMac11,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac11,1</string>
</dict>
<key>iMac11,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac11,1</string>
</dict>
<key>iMac11,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac11,1</string>
</dict>
<key>iMac11,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac11,1</string>
</dict>
<key>iMac11,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac11,1</string>
</dict>
<key>iMac11,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac11,1</string>
</dict>
<key>iMac11,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac11,2</string>
</dict>
<key>iMac11,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac11,2</string>
</dict>
<key>iMac11,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac11,2</string>
</dict>
<key>iMac11,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac11,2</string>
</dict>
<key>iMac11,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac11,2</string>
</dict>
<key>iMac11,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac11,2</string>
</dict>
<key>iMac11,3-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac11,3</string>
</dict>
<key>iMac11,3-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac11,3</string>
</dict>
<key>iMac11,3-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac11,3</string>
</dict>
<key>iMac11,3-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac11,3</string>
</dict>
<key>iMac11,3-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac11,3</string>
</dict>
<key>iMac11,3-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac11,3</string>
</dict>
<key>iMac12,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac12,1</string>
</dict>
<key>iMac12,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac12,1</string>
</dict>
<key>iMac12,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac12,1</string>
</dict>
<key>iMac12,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac12,1</string>
</dict>
<key>iMac12,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac12,1</string>
</dict>
<key>iMac12,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac12,1</string>
</dict>
<key>iMac12,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac12,2</string>
</dict>
<key>iMac12,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac12,2</string>
</dict>
<key>iMac12,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac12,2</string>
</dict>
<key>iMac12,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac12,2</string>
</dict>
<key>iMac12,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac12,2</string>
</dict>
<key>iMac12,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac12,2</string>
</dict>
<key>iMac13,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac13,1</string>
</dict>
<key>iMac13,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac13,1</string>
</dict>
<key>iMac13,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac13,1</string>
</dict>
<key>iMac13,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac13,1</string>
</dict>
<key>iMac13,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac13,1</string>
</dict>
<key>iMac13,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac13,1</string>
</dict>
<key>iMac13,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac13,2</string>
</dict>
<key>iMac13,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac13,2</string>
</dict>
<key>iMac13,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac13,2</string>
</dict>
<key>iMac13,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac13,2</string>
</dict>
<key>iMac13,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac13,2</string>
</dict>
<key>iMac13,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac13,2</string>
</dict>
<key>iMac14,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac14,1</string>
</dict>
<key>iMac14,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac14,1</string>
</dict>
<key>iMac14,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac14,1</string>
</dict>
<key>iMac14,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac14,1</string>
</dict>
<key>iMac14,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac14,1</string>
</dict>
<key>iMac14,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac14,1</string>
</dict>
<key>iMac14,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac14,2</string>
</dict>
<key>iMac14,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac14,2</string>
</dict>
<key>iMac14,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac14,2</string>
</dict>
<key>iMac14,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac14,2</string>
</dict>
<key>iMac14,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac14,2</string>
</dict>
<key>iMac14,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac14,2</string>
</dict>
<key>iMac14,3-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac14,3</string>
</dict>
<key>iMac14,3-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac14,3</string>
</dict>
<key>iMac14,3-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac14,3</string>
</dict>
<key>iMac14,3-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac14,3</string>
</dict>
<key>iMac14,3-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac14,3</string>
</dict>
<key>iMac14,3-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac14,3</string>
</dict>
<key>iMac15,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac15,1</string>
</dict>
<key>iMac15,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac15,1</string>
</dict>
<key>iMac15,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac15,1</string>
</dict>
<key>iMac15,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac15,1</string>
</dict>
<key>iMac15,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac15,1</string>
</dict>
<key>iMac15,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac15,1</string>
</dict>
<key>iMac16,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac16,1</string>
</dict>
<key>iMac16,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac16,1</string>
</dict>
<key>iMac16,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac16,1</string>
</dict>
<key>iMac16,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac16,1</string>
</dict>
<key>iMac16,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac16,1</string>
</dict>
<key>iMac16,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac16,1</string>
</dict>
<key>iMac16,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac16,2</string>
</dict>
<key>iMac16,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac16,2</string>
</dict>
<key>iMac16,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac16,2</string>
</dict>
<key>iMac16,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac16,2</string>
</dict>
<key>iMac16,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac16,2</string>
</dict>
<key>iMac16,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac16,2</string>
</dict>
<key>iMac17,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac17,1</string>
</dict>
<key>iMac17,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac17,1</string>
</dict>
<key>iMac17,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac17,1</string>
</dict>
<key>iMac17,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac17,1</string>
</dict>
<key>iMac17,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac17,1</string>
</dict>
<key>iMac17,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac17,1</string>
</dict>
<key>iMac4,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac4,1</string>
</dict>
<key>iMac4,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac4,1</string>
</dict>
<key>iMac4,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac4,1</string>
</dict>
<key>iMac4,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac4,1</string>
</dict>
<key>iMac4,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac4,1</string>
</dict>
<key>iMac4,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac4,1</string>
</dict>
<key>iMac4,2-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac4,2</string>
</dict>
<key>iMac4,2-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac4,2</string>
</dict>
<key>iMac4,2-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac4,2</string>
</dict>
<key>iMac4,2-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac4,2</string>
</dict>
<key>iMac4,2-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac4,2</string>
</dict>
<key>iMac4,2-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac4,2</string>
</dict>
<key>iMac5,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac5,1</string>
</dict>
<key>iMac5,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac5,1</string>
</dict>
<key>iMac5,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac5,1</string>
</dict>
<key>iMac5,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac5,1</string>
</dict>
<key>iMac5,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac5,1</string>
</dict>
<key>iMac5,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac5,1</string>
</dict>
<key>iMac6,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac6,1</string>
</dict>
<key>iMac6,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac6,1</string>
</dict>
<key>iMac6,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac6,1</string>
</dict>
<key>iMac6,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac6,1</string>
</dict>
<key>iMac6,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac6,1</string>
</dict>
<key>iMac6,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac6,1</string>
</dict>
<key>iMac7,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac7,1</string>
</dict>
<key>iMac7,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac7,1</string>
</dict>
<key>iMac7,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac7,1</string>
</dict>
<key>iMac7,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac7,1</string>
</dict>
<key>iMac7,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac7,1</string>
</dict>
<key>iMac7,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac7,1</string>
</dict>
<key>iMac8,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac8,1</string>
</dict>
<key>iMac8,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac8,1</string>
</dict>
<key>iMac8,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac8,1</string>
</dict>
<key>iMac8,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac8,1</string>
</dict>
<key>iMac8,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac8,1</string>
</dict>
<key>iMac8,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac8,1</string>
</dict>
<key>iMac9,1-AppeBusPowerControllerUSB</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProviderClass</key>
<string>AppleBusPowerControllerUSB</string>
<key>kConfigurationName</key>
<string>AppleBusPowerControllerUSB</string>
<key>model</key>
<string>iMac9,1</string>
</dict>
<key>iMac9,1-EH01</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH01</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH01</string>
<key>model</key>
<string>iMac9,1</string>
</dict>
<key>iMac9,1-EH01-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB1</string>
<key>locationID</key>
<integer>487587840</integer>
<key>model</key>
<string>iMac9,1</string>
</dict>
<key>iMac9,1-EH02</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>EH02</string>
<key>IOProviderClass</key>
<string>AppleUSBEHCIPCI</string>
<key>kConfigurationName</key>
<string>EH02</string>
<key>model</key>
<string>iMac9,1</string>
</dict>
<key>iMac9,1-EH02-internal-hub</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IOProbeScore</key>
<integer>5000</integer>
<key>IOProviderClass</key>
<string>AppleUSB20InternalHub</string>
<key>kConfigurationName</key>
<string>HUB2</string>
<key>locationID</key>
<integer>437256192</integer>
<key>model</key>
<string>iMac9,1</string>
</dict>
<key>iMac9,1-XHC</key>
<dict>
<key>CFBundleIdentifier</key>
<string>com.rehabman.driver.USBInjectAll</string>
<key>IOClass</key>
<string>org_rehabman_USBInjectAll</string>
<key>IONameMatch</key>
<string>XHC</string>
<key>IOProviderClass</key>
<string>AppleUSBXHCIPCI</string>
<key>kConfigurationName</key>
<string>XHC</string>
<key>kIsXHC</key>
<true/>
<key>model</key>
<string>iMac9,1</string>
</dict>
</dict>
<key>OSBundleLibraries</key>
<dict>
<key>com.apple.iokit.IOACPIFamily</key>
<string>1.0d1</string>
<key>com.apple.iokit.IOPCIFamily</key>
<string>1.0.0b1</string>
<key>com.apple.kpi.iokit</key>
<string>9.0.0</string>
<key>com.apple.kpi.libkern</key>
<string>9.0.0</string>
</dict>
<key>OSBundleRequired</key>
<string>Root</string>
<key>Source Code</key>
<string>path_to_url
</dict>
</plist>
``` | /content/code_sandbox/Clover-Configs/XiaoMi/13.3-without-fingerprint/CLOVER/kexts/Other/USBInjectAll.kext/Contents/Info.plist | xml | 2016-11-05T04:22:54 | 2024-08-12T19:25:53 | Hackintosh-Installer-University | huangyz0918/Hackintosh-Installer-University | 3,937 | 74,249 |
```xml
import * as PAK from './pak.js';
import * as MLVL from './mlvl.js';
import * as MREA from './mrea.js';
import { MaterialSet } from './mrea.js';
import { ResourceGame, ResourceSystem } from './resource.js';
import { CMDLData, CMDLRenderer, ModelCache, MREARenderer } from './render.js';
import * as Viewer from '../viewer.js';
import * as UI from '../ui.js';
import { GroupLayerPanel } from './ui.js';
import { assert, assertExists } from '../util.js';
import { GfxDevice } from '../gfx/platform/GfxPlatform.js';
import { makeBackbufferDescSimple, opaqueBlackFullClearRenderPassDescriptor } from '../gfx/helpers/RenderGraphHelpers.js';
import { mat4 } from 'gl-matrix';
import { fillSceneParamsDataOnTemplate, GXRenderHelperGfx, GXTextureHolder } from '../gx/gx_render.js';
import { SceneContext } from '../SceneBase.js';
import { CameraController } from '../Camera.js';
import BitMap, { bitMapDeserialize, bitMapGetSerializedByteLength, bitMapSerialize } from '../BitMap.js';
import { CMDL } from './cmdl.js';
import { colorNewCopy, OpaqueBlack } from '../Color.js';
import { GfxrAttachmentSlot } from '../gfx/render/GfxRenderGraph.js';
import { GfxRenderInstList } from '../gfx/render/GfxRenderInstManager.js';
import { Vec3One } from '../MathHelpers.js';
import { parseMP1Tweaks, parseMP2Tweaks } from './tweaks.js';
import { GeneratorMaterialHelpers } from './particles/base_generator.js';
import { GfxRenderCache } from '../gfx/render/GfxRenderCache.js';
import { TXTR } from './txtr.js';
function layerVisibilitySyncToBitMap(layers: UI.Layer[], b: BitMap): void {
for (let i = 0; i < layers.length; i++)
b.setBit(i, layers[i].visible);
}
function layerVisibilitySyncFromBitMap(layers: UI.Layer[], b: BitMap): void {
assert(b.numBits === layers.length);
for (let i = 0; i < layers.length; i++)
layers[i].setVisible(b.getBit(i));
}
export class RetroSceneRenderer implements Viewer.SceneGfx {
public renderHelper: GXRenderHelperGfx;
private renderInstListSky = new GfxRenderInstList();
private renderInstListMain = new GfxRenderInstList();
public renderCache: GfxRenderCache;
public modelCache = new ModelCache();
public textureHolder = new GXTextureHolder<TXTR>();
public generatorMaterialHelpers = new GeneratorMaterialHelpers();
public areaRenderers: MREARenderer[] = [];
public defaultSkyRenderer: CMDLRenderer | null = null;
public worldAmbientColor = colorNewCopy(OpaqueBlack);
public showAllActors: boolean = false;
private showAllActorsCheckbox: UI.Checkbox;
public enableAnimations: boolean = true;
private enableAnimationsCheckbox: UI.Checkbox;
public enableParticles: boolean = true;
private enableParticlesCheckbox: UI.Checkbox;
public suitModel: number = 0;
private suitModelButtons: UI.RadioButtons;
private groupLayerPanel: GroupLayerPanel;
public onstatechanged!: () => void;
constructor(public device: GfxDevice, public mlvl: MLVL.MLVL, public game: ResourceGame) {
this.renderHelper = new GXRenderHelperGfx(device);
this.renderCache = this.renderHelper.renderCache;
}
public adjustCameraController(c: CameraController) {
c.setSceneMoveSpeedMult(0.01);
}
private prepareToRender(viewerInput: Viewer.ViewerRenderInput): void {
const template = this.renderHelper.pushTemplateRenderInst();
viewerInput.camera.setClipPlanes(0.2);
fillSceneParamsDataOnTemplate(template, viewerInput, 0);
this.renderHelper.renderInstManager.setCurrentRenderInstList(this.renderInstListMain);
for (let i = 0; i < this.areaRenderers.length; i++)
this.areaRenderers[i].prepareToRender(this, viewerInput);
this.prepareToRenderSkybox(viewerInput);
this.renderHelper.prepareToRender();
this.renderHelper.renderInstManager.popTemplateRenderInst();
}
private prepareToRenderSkybox(viewerInput: Viewer.ViewerRenderInput): void {
// Pick an active skybox and render it...
let skybox: CMDLRenderer | null = null;
for (let i = 0; i < this.areaRenderers.length; i++) {
if (this.areaRenderers[i].visible && this.areaRenderers[i].needSky) {
if (this.areaRenderers[i].overrideSky !== null)
skybox = this.areaRenderers[i].overrideSky;
else
skybox = this.defaultSkyRenderer;
break;
}
}
if (skybox !== null) {
this.renderHelper.renderInstManager.setCurrentRenderInstList(this.renderInstListSky);
skybox.prepareToRender(this, viewerInput);
}
}
public render(device: GfxDevice, viewerInput: Viewer.ViewerRenderInput) {
assert(device === this.device);
const renderInstManager = this.renderHelper.renderInstManager;
const builder = this.renderHelper.renderGraph.newGraphBuilder();
const mainColorDesc = makeBackbufferDescSimple(GfxrAttachmentSlot.Color0, viewerInput, opaqueBlackFullClearRenderPassDescriptor);
const mainDepthDesc = makeBackbufferDescSimple(GfxrAttachmentSlot.DepthStencil, viewerInput, opaqueBlackFullClearRenderPassDescriptor);
const mainColorTargetID = builder.createRenderTargetID(mainColorDesc, 'Main Color');
builder.pushPass((pass) => {
pass.setDebugName('Skybox');
pass.attachRenderTargetID(GfxrAttachmentSlot.Color0, mainColorTargetID);
const skyboxDepthTargetID = builder.createRenderTargetID(mainDepthDesc, 'Skybox Depth');
pass.attachRenderTargetID(GfxrAttachmentSlot.DepthStencil, skyboxDepthTargetID);
pass.exec((passRenderer) => {
this.renderInstListSky.drawOnPassRenderer(this.renderCache, passRenderer);
});
});
const mainDepthTargetID = builder.createRenderTargetID(mainDepthDesc, 'Main Depth');
builder.pushPass((pass) => {
pass.setDebugName('Main');
pass.attachRenderTargetID(GfxrAttachmentSlot.Color0, mainColorTargetID);
pass.attachRenderTargetID(GfxrAttachmentSlot.DepthStencil, mainDepthTargetID);
pass.exec((passRenderer) => {
this.renderInstListMain.drawOnPassRenderer(this.renderCache, passRenderer);
});
});
this.renderHelper.antialiasingSupport.pushPasses(builder, viewerInput, mainColorTargetID);
builder.resolveRenderTargetToExternalTexture(mainColorTargetID, viewerInput.onscreenTexture);
this.prepareToRender(viewerInput);
this.renderHelper.renderGraph.execute(builder);
this.renderInstListSky.reset();
this.renderInstListMain.reset();
}
public destroy(device: GfxDevice): void {
this.textureHolder.destroy(device);
this.renderHelper.destroy();
this.modelCache.destroy(device);
for (let i = 0; i < this.areaRenderers.length; i++)
this.areaRenderers[i].destroy(device);
}
public setShowAllActors(enabled: boolean) {
this.showAllActors = enabled;
this.onstatechanged();
}
public setEnableAnimations(enabled: boolean) {
this.enableAnimations = enabled;
this.onstatechanged();
}
public setEnableParticles(enabled: boolean) {
this.enableParticles = enabled;
this.onstatechanged();
}
private _setSuitModel(index: number) {
this.suitModel = index;
for (let i = 0; i < this.areaRenderers.length; i++)
this.areaRenderers[i].setSuitModel(index);
}
public setSuitModel(index: number) {
this._setSuitModel(index);
this.onstatechanged();
}
private createRenderHacksPanel(): UI.Panel {
const renderHacksPanel = new UI.Panel();
renderHacksPanel.customHeaderBackgroundColor = UI.COOL_BLUE_COLOR;
renderHacksPanel.setTitle(UI.RENDER_HACKS_ICON, 'Render Hacks');
this.showAllActorsCheckbox = new UI.Checkbox('Show All Actors');
this.showAllActorsCheckbox.onchanged = () => {
this.setShowAllActors(this.showAllActorsCheckbox.checked);
};
renderHacksPanel.contents.appendChild(this.showAllActorsCheckbox.elem);
this.enableAnimationsCheckbox = new UI.Checkbox('Enable Animations');
this.enableAnimationsCheckbox.onchanged = () => {
this.setEnableAnimations(this.enableAnimationsCheckbox.checked);
};
renderHacksPanel.contents.appendChild(this.enableAnimationsCheckbox.elem);
this.enableParticlesCheckbox = new UI.Checkbox('Enable Particles');
this.enableParticlesCheckbox.onchanged = () => {
this.setEnableParticles(this.enableParticlesCheckbox.checked);
};
renderHacksPanel.contents.appendChild(this.enableParticlesCheckbox.elem);
if (this.game === ResourceGame.MP1 || this.game === ResourceGame.MP2) {
this.suitModelButtons = new UI.RadioButtons('Suit Model',
this.game === ResourceGame.MP2 ? ['Varia', 'Dark', 'Light'] : ['Power', 'Gravity', 'Varia', 'Phazon']);
this.suitModelButtons.onselectedchange = () => {
this.setSuitModel(this.suitModelButtons.selectedIndex);
};
renderHacksPanel.contents.appendChild(this.suitModelButtons.elem);
}
return renderHacksPanel;
}
public createPanels(): UI.Panel[] {
this.groupLayerPanel = new GroupLayerPanel(this.areaRenderers);
this.groupLayerPanel.layerPanel.onlayertoggled = () => {
this.onstatechanged();
};
return [this.groupLayerPanel, this.createRenderHacksPanel()];
}
public serializeSaveState(dst: ArrayBuffer, offs: number): number {
const view = new DataView(dst);
const b = new BitMap(this.areaRenderers.length);
layerVisibilitySyncToBitMap(this.areaRenderers, b);
offs = bitMapSerialize(view, offs, b);
view.setUint8(offs, this.showAllActors ? 1 : 0);
offs += 1;
view.setUint8(offs, this.suitModel);
offs += 1;
view.setUint8(offs, this.enableAnimations ? 1 : 0);
offs += 1;
view.setUint8(offs, this.enableParticles ? 1 : 0);
offs += 1;
return offs;
}
public deserializeSaveState(src: ArrayBuffer, offs: number, byteLength: number): number {
const view = new DataView(src);
const numBytes = bitMapGetSerializedByteLength(this.areaRenderers.length);
if (offs + numBytes <= byteLength) {
const b = new BitMap(this.areaRenderers.length);
offs = bitMapDeserialize(view, offs, b);
layerVisibilitySyncFromBitMap(this.areaRenderers, b);
this.groupLayerPanel.layerPanel.syncLayerVisibility();
}
if (offs + 1 <= byteLength) {
this.showAllActors = view.getUint8(offs) !== 0;
offs += 1;
}
this.showAllActorsCheckbox.setChecked(this.showAllActors);
if (this.game === ResourceGame.MP1 || this.game === ResourceGame.MP2) {
if (offs + 1 <= byteLength) {
this._setSuitModel(view.getUint8(offs));
offs += 1;
} else {
this._setSuitModel(this.game === ResourceGame.MP1 ? 2 : 0);
}
this.suitModelButtons.setSelectedIndex(this.suitModel);
}
if (offs + 1 <= byteLength) {
this.enableAnimations = view.getUint8(offs) !== 0;
offs += 1;
}
this.enableAnimationsCheckbox.setChecked(this.enableAnimations);
if (offs + 1 <= byteLength) {
this.enableParticles = view.getUint8(offs) !== 0;
offs += 1;
}
this.enableParticlesCheckbox.setChecked(this.enableParticles);
return offs;
}
public getCMDLData(cmdl: CMDL): CMDLData {
return this.modelCache.getCMDLData(this, cmdl);
}
public addTextures(textures: TXTR[]): void {
this.textureHolder.addTextures(this.device, textures);
}
public addMaterialSetTextures(materialSet: MaterialSet): void {
this.addTextures(materialSet.textures);
}
}
const pathBase = `MetroidPrime`;
class RetroSceneDesc implements Viewer.SceneDesc {
public id: string;
constructor(public filename: string, public game: ResourceGame, public gameCompressionMethod: PAK.CompressionMethod,
public name: string, public worldName: string = '') {
this.id = worldName ? worldName : filename;
}
public async createScene(device: GfxDevice, context: SceneContext): Promise<Viewer.SceneGfx> {
const dataFetcher = context.dataFetcher;
const levelPak = PAK.parse(await dataFetcher.fetchData(`${pathBase}/${this.filename}`), this.gameCompressionMethod);
const paks = [levelPak];
if (this.game === ResourceGame.MP1) {
paks.push(PAK.parse(await dataFetcher.fetchData(`${pathBase}/mp1/Tweaks.pak`), this.gameCompressionMethod));
paks.push(PAK.parse(await dataFetcher.fetchData(`${pathBase}/mp1/TestAnim.pak`), this.gameCompressionMethod));
} else if (this.game === ResourceGame.MP2) {
paks.push(PAK.parse(await dataFetcher.fetchData(`${pathBase}/mp2/TestAnim.pak`), this.gameCompressionMethod));
}
const resourceSystem = new ResourceSystem(this.game, paks);
let tweaks = null;
if (this.game === ResourceGame.MP1)
tweaks = parseMP1Tweaks(resourceSystem);
else if (this.game === ResourceGame.MP2)
tweaks = parseMP2Tweaks(resourceSystem);
for (const mlvlEntry of levelPak.namedResourceTable.values()) {
assert(mlvlEntry.fourCC === 'MLVL');
if (this.worldName !== '' && this.worldName !== mlvlEntry.name) {
continue;
}
const mlvl: MLVL.MLVL = assertExists(resourceSystem.loadAssetByID<MLVL.MLVL>(mlvlEntry.fileID, mlvlEntry.fourCC));
const renderer = new RetroSceneRenderer(device, mlvl, this.game);
const areas = mlvl.areaTable;
const defaultSkyboxCMDL = resourceSystem.loadAssetByID<CMDL>(mlvl.defaultSkyboxID, 'CMDL');
if (defaultSkyboxCMDL) {
const defaultSkyboxName = resourceSystem.findResourceNameByID(mlvl.defaultSkyboxID);
const defaultSkyboxCMDLData = renderer.getCMDLData(defaultSkyboxCMDL);
const modelMatrix = mat4.create();
const defaultSkyboxRenderer = new CMDLRenderer(renderer, null, defaultSkyboxName, modelMatrix, modelMatrix, Vec3One, defaultSkyboxCMDLData, null);
defaultSkyboxRenderer.isSkybox = true;
renderer.defaultSkyRenderer = defaultSkyboxRenderer;
}
for (let i = 0; i < areas.length; i++) {
const mreaEntry = areas[i];
const mrea = resourceSystem.loadAssetByID<MREA.MREA>(mreaEntry.areaMREAID, 'MREA');
if (mrea !== null && mreaEntry.areaName.indexOf('worldarea') === -1) {
const areaRenderer = new MREARenderer(renderer, mreaEntry.areaName, mrea, resourceSystem, tweaks);
renderer.areaRenderers.push(areaRenderer);
// By default, set only the first area renderer is visible, so as to not "crash my browser please".
areaRenderer.visible = (renderer.areaRenderers.length === 1);
}
}
return renderer;
}
throw 'whoops';
}
}
const idMP1 = 'mp1';
const nameMP1 = 'Metroid Prime';
const compressionMP1 = PAK.CompressionMethod.ZLIB;
const sceneDescsMP1: Viewer.SceneDesc[] = [
new RetroSceneDesc(`mp1/Metroid1.pak`, ResourceGame.MP1, compressionMP1, 'Space Pirate Frigate'),
new RetroSceneDesc(`mp1/Metroid2.pak`, ResourceGame.MP1, compressionMP1, 'Chozo Ruins'),
new RetroSceneDesc(`mp1/Metroid3.pak`, ResourceGame.MP1, compressionMP1, 'Phendrana Drifts'),
new RetroSceneDesc(`mp1/Metroid4.pak`, ResourceGame.MP1, compressionMP1, 'Tallon Overworld'),
new RetroSceneDesc(`mp1/Metroid5.pak`, ResourceGame.MP1, compressionMP1, 'Phazon Mines'),
new RetroSceneDesc(`mp1/Metroid6.pak`, ResourceGame.MP1, compressionMP1, 'Magmoor Caverns'),
new RetroSceneDesc(`mp1/Metroid7.pak`, ResourceGame.MP1, compressionMP1, 'Impact Crater'),
];
export const sceneGroupMP1: Viewer.SceneGroup = { id: idMP1, name: nameMP1, sceneDescs: sceneDescsMP1 };
const idMP2 = 'mp2';
const nameMP2 = 'Metroid Prime 2: Echoes';
const compressionMP2 = PAK.CompressionMethod.LZO;
const sceneDescsMP2: Viewer.SceneDesc[] = [
new RetroSceneDesc(`mp2/Metroid1.pak`, ResourceGame.MP2, compressionMP2, 'Temple Grounds'),
new RetroSceneDesc(`mp2/Metroid2.pak`, ResourceGame.MP2, compressionMP2, 'Great Temple'),
new RetroSceneDesc(`mp2/Metroid3.pak`, ResourceGame.MP2, compressionMP2, 'Agon Wastes'),
new RetroSceneDesc(`mp2/Metroid4.pak`, ResourceGame.MP2, compressionMP2, 'Torvus Bog'),
new RetroSceneDesc(`mp2/Metroid5.pak`, ResourceGame.MP2, compressionMP2, 'Sanctuary Fortress'),
new RetroSceneDesc(`mp2/Metroid6.pak`, ResourceGame.MP2, compressionMP2, 'Multiplayer - Sidehopper Station', 'M01_SidehopperStation'),
new RetroSceneDesc(`mp2/Metroid6.pak`, ResourceGame.MP2, compressionMP2, 'Multiplayer - Spires', 'M02_Spires'),
new RetroSceneDesc(`mp2/Metroid6.pak`, ResourceGame.MP2, compressionMP2, 'Multiplayer - Crossfire Chaos', 'M03_CrossfireChaos'),
new RetroSceneDesc(`mp2/Metroid6.pak`, ResourceGame.MP2, compressionMP2, 'Multiplayer - Pipeline', 'M04_Pipeline'),
new RetroSceneDesc(`mp2/Metroid6.pak`, ResourceGame.MP2, compressionMP2, 'Multiplayer - Spider Complex', 'M05_SpiderComplex'),
new RetroSceneDesc(`mp2/Metroid6.pak`, ResourceGame.MP2, compressionMP2, 'Multiplayer - Shooting Gallery', 'M06_ShootingGallery'),
];
export const sceneGroupMP2: Viewer.SceneGroup = { id: idMP2, name: nameMP2, sceneDescs: sceneDescsMP2 };
const idMP3 = 'mp3';
const nameMP3 = 'Metroid Prime 3: Corruption';
const compressionMP3 = PAK.CompressionMethod.CMPD_LZO;
const sceneDescsMP3: Viewer.SceneDesc[] = [
new RetroSceneDesc(`mp3/Metroid1.pak`, ResourceGame.MP3, compressionMP3, 'G.F.S. Olympus', '01a_GFShip_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid1.pak`, ResourceGame.MP3, compressionMP3, 'Norion', '01b_GFPlanet_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid1.pak`, ResourceGame.MP3, compressionMP3, 'G.F.S. Valhalla', '01c_Abandoned_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid3.pak`, ResourceGame.MP3, compressionMP3, 'Bryyo Cliffside', '03a_Bryyo_Reptilicus_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid3.pak`, ResourceGame.MP3, compressionMP3, 'Bryyo Fire', '03b_Bryyo_Fire_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid3.pak`, ResourceGame.MP3, compressionMP3, 'Bryyo Ice', '03c_Bryyo_Ice_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid4.pak`, ResourceGame.MP3, compressionMP3, 'SkyTown, Elysia', '04a_Skytown_Main_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid4.pak`, ResourceGame.MP3, compressionMP3, 'Eastern SkyTown, Elysia', '04b_Skytown_Pod_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid5.pak`, ResourceGame.MP3, compressionMP3, 'Pirate Research', '05a_Pirate_Research_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid5.pak`, ResourceGame.MP3, compressionMP3, 'Pirate Command', '05b_Pirate_Command_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid5.pak`, ResourceGame.MP3, compressionMP3, 'Pirate Mines', '05c_Pirate_Mines_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid6.pak`, ResourceGame.MP3, compressionMP3, 'Phaaze', '06_Phaaze_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid7.pak`, ResourceGame.MP3, compressionMP3, 'Bryyo Seed', '03d_Bryyo_Seed_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid7.pak`, ResourceGame.MP3, compressionMP3, 'Elysia Seed', '04c_Skytown_Seed_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid7.pak`, ResourceGame.MP3, compressionMP3, 'Pirate Homeworld Seed', '05d_Pirate_Seed_#SERIAL#'),
new RetroSceneDesc(`mp3/Metroid8.pak`, ResourceGame.MP3, compressionMP3, 'Space', '08_Space_#SERIAL#')
];
export const sceneGroupMP3: Viewer.SceneGroup = { id: idMP3, name: nameMP3, sceneDescs: sceneDescsMP3 };
``` | /content/code_sandbox/src/MetroidPrime/scenes.ts | xml | 2016-10-06T21:43:45 | 2024-08-16T17:03:52 | noclip.website | magcius/noclip.website | 3,206 | 5,093 |
```xml
import {ExportsRemoteState} from 'common/types';
import createRemoteStateHook from 'hooks/use-remote-state';
const useConversion = createRemoteStateHook<ExportsRemoteState>('exports');
export type UseConversion = ReturnType<typeof useConversion>;
export type UseConversionState = UseConversion['state'];
export default useConversion;
``` | /content/code_sandbox/renderer/hooks/editor/use-conversion.tsx | xml | 2016-08-10T19:37:08 | 2024-08-16T07:01:58 | Kap | wulkano/Kap | 17,864 | 66 |
```xml
<?xml version="1.0" encoding="utf-8"?>
<!--
~
~
~ path_to_url
~
~ Unless required by applicable law or agreed to in writing, software
~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-->
<resources>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
primary. -->
<attr name="colorOnPrimary" format="color"/>
<!-- The inverse color of colorPrimary. -->
<attr name="colorPrimaryInverse" format="color"/>
<!-- A tonal variation of the primary color suitable for background color of container views. -->
<attr name="colorPrimaryContainer" format="color"/>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
the primary container color. -->
<attr name="colorOnPrimaryContainer" format="color"/>
<!-- A primary branding color for the app, which stays the same between light and dark themes. -->
<attr name="colorPrimaryFixed" format="color"/>
<!-- A stronger, more emphasized variant of the fixed primary branding color. -->
<attr name="colorPrimaryFixedDim" format="color"/>
<!-- The color text/iconography when drawn on top of the fixed primary branding color. -->
<attr name="colorOnPrimaryFixed" format="color"/>
<!-- A lower-emphasized variant of the color on the fixed primary branding color. -->
<attr name="colorOnPrimaryFixedVariant" format="color"/>
<!-- The secondary branding color for the app, usually a bright complement to the primary
branding color. -->
<attr name="colorSecondary" format="color"/>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
secondary. -->
<attr name="colorOnSecondary" format="color"/>
<!-- A tonal variation of the secondary color suitable for background color of container views. -->
<attr name="colorSecondaryContainer" format="color"/>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
the secondary container color. -->
<attr name="colorOnSecondaryContainer" format="color"/>
<!-- A secondary branding color for the app, which stays the same between light and dark themes. -->
<attr name="colorSecondaryFixed" format="color"/>
<!-- A stronger, more emphasized variant of the fixed secondary branding color. -->
<attr name="colorSecondaryFixedDim" format="color"/>
<!-- The color text/iconography when drawn on top of the fixed secondary branding color. -->
<attr name="colorOnSecondaryFixed" format="color"/>
<!-- A lower-emphasized variant of the color on the fixed secondary branding color. -->
<attr name="colorOnSecondaryFixedVariant" format="color"/>
<!-- The tertiary branding color for the app, usually a bright complement to the primary
branding color. -->
<attr name="colorTertiary" format="color"/>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
tertiary. -->
<attr name="colorOnTertiary" format="color"/>
<!-- A tonal variation of the tertiary color suitable for background color of container views. -->
<attr name="colorTertiaryContainer" format="color"/>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
the tertiary container color. -->
<attr name="colorOnTertiaryContainer" format="color"/>
<!-- A tertiary branding color for the app, which stays the same between light and dark themes. -->
<attr name="colorTertiaryFixed" format="color"/>
<!-- A stronger, more emphasized variant of the fixed tertiary branding color. -->
<attr name="colorTertiaryFixedDim" format="color"/>
<!-- The color text/iconography when drawn on top of the fixed tertiary branding color. -->
<attr name="colorOnTertiaryFixed" format="color"/>
<!-- A lower-emphasized variant of the color on the fixed tertiary branding color. -->
<attr name="colorOnTertiaryFixedVariant" format="color"/>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
background. -->
<attr name="colorOnBackground"/>
<!-- The color of surfaces such as cards, sheets, menus. -->
<attr name="colorSurface" format="color"/>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
surface. -->
<attr name="colorOnSurface" format="color"/>
<!-- A tonal variation of the surface color. -->
<attr name="colorSurfaceVariant" format="color"/>
<!-- A tonal variation of the on surface color that passes accessibility guidelines for
text/iconography when drawn on top of surface variant. -->
<attr name="colorOnSurfaceVariant" format="color"/>
<!-- The surface inverse color, useful for inverted backgrounds. -->
<attr name="colorSurfaceInverse" format="color"/>
<!-- The "on surface" inverse color, useful for inverted backgrounds. -->
<attr name="colorOnSurfaceInverse" format="color"/>
<!-- Tonal surface color roles. -->
<!-- The surface color which always stay the brightest in either dark or light theme. -->
<attr name="colorSurfaceBright" format="color"/>
<!-- The surface color which always stay the dimmest in either dark or light theme. -->
<attr name="colorSurfaceDim" format="color"/>
<!-- The container color of surface, which replaces the previous surface at elevation level 2. -->
<attr name="colorSurfaceContainer" format="color"/>
<!-- The container color of surface slightly elevated, which replaces the previous surface at elevation level 3. -->
<attr name="colorSurfaceContainerHigh" format="color"/>
<!-- The container color of surface the most elevated, which replaces the previous surface variant. -->
<attr name="colorSurfaceContainerHighest" format="color"/>
<!-- The container color of surface slightly lowered, which replaces the previous surface at elevation level 1. -->
<attr name="colorSurfaceContainerLow" format="color"/>
<!-- The container color of surface the most lowered. -->
<attr name="colorSurfaceContainerLowest" format="color"/>
<!-- A color meant to be used in element outlines. -->
<attr name="colorOutline" format="color"/>
<!-- A color meant to be used in element outlines on the surface-variant color. -->
<attr name="colorOutlineVariant" format="color"/>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
error. -->
<attr name="colorOnError" format="color"/>
<!-- A tonal variation of the error color suitable for background color of container views. -->
<attr name="colorErrorContainer" format="color"/>
<!-- A tonal variation of the on error color that passes accessibility guidelines for
text/iconography when drawn on top of error container. -->
<attr name="colorOnErrorContainer" format="color"/>
<!-- A color that corresponds to colorPrimary in light themes and colorSurface in dark
themes. -->
<attr name="colorPrimarySurface" format="color"/>
<!-- A color that passes accessibility guidelines for text/iconography when drawn on top of
colorPrimarySurface. -->
<attr name="colorOnPrimarySurface" format="color"/>
<!-- Container colors. -->
<!-- These container colors are only meant to be used in component-level
styles and resources as a means of indirection. They enable remapping
to other attrs like primary, secondary, surface, etc. -->
<!-- Color to use for background container. -->
<attr name="colorContainer" format="color"/>
<!-- Color to use for checkable background container in checked state. -->
<attr name="colorContainerChecked" format="color"/>
<!-- Color to use for checkable background container in unchecked state. -->
<attr name="colorContainerUnchecked" format="color"/>
<!-- Color to use for foreground elements on top of colorContainer. -->
<attr name="colorOnContainer" format="color"/>
<!-- Color to use for checkable foreground elements in checked state on top of colorContainer. -->
<attr name="colorOnContainerChecked" format="color"/>
<!-- Color to use for checkable foreground elements in unchecked state on top of colorContainer. -->
<attr name="colorOnContainerUnchecked" format="color"/>
<!-- The scrim background that appears below modals and expanded navigation menus.
The background can either be a color or a bitmap drawable with tileMode set to repeat. -->
<attr name="scrimBackground" format="color|reference"/>
<!-- Internal flag used to denote that a theme is a Theme.MaterialComponents theme or a
Theme.MaterialComponents.Bridge theme. -->
<attr name="isMaterialTheme" format="boolean"/>
<!-- Internal flag used to denote that a theme is a Theme.Material3 theme. -->
<attr name="isMaterial3Theme" format="boolean"/>
<!-- Internal flag used to denote that dynamic colors have been applied to Theme.Material3 theme. -->
<attr name="isMaterial3DynamicColorApplied" format="boolean"/>
<!-- When set to true, the material selection controls will tint themselves according to
Material Theme colors. When set to false, Material Theme colors will
be ignored. This value should be set to false when using custom drawables
that should not be tinted. This value is ignored if a buttonTint is set.
Set this attribute on your styles for each selection control.-->
<attr name="useMaterialThemeColors" format="boolean"/>
<!-- The default dynamic color theme overlay to use when applying dynamic colors. -->
<attr name="dynamicColorThemeOverlay" format="reference"/>
<!-- Deprecated. -->
<!-- A tonal variation of the primary color. -->
<attr name="colorPrimaryVariant" format="color"/>
<!-- A tonal variation of the secondary color. -->
<attr name="colorSecondaryVariant" format="color"/>
</resources>
``` | /content/code_sandbox/lib/java/com/google/android/material/color/res/values/attrs.xml | xml | 2016-12-05T16:11:29 | 2024-08-16T17:51:42 | material-components-android | material-components/material-components-android | 16,176 | 2,141 |
```xml
import { ArchiveFormat, VALID_ARCHIVE_FORMATS } from '@vercel/client';
const validArchiveFormats = new Set<string>(VALID_ARCHIVE_FORMATS);
export function isValidArchive(archive: string): archive is ArchiveFormat {
return validArchiveFormats.has(archive);
}
``` | /content/code_sandbox/packages/cli/src/util/deploy/validate-archive-format.ts | xml | 2016-09-09T01:12:08 | 2024-08-16T17:39:45 | vercel | vercel/vercel | 12,545 | 55 |
```xml
<ResourceDictionary xmlns="path_to_url"
xmlns:x="path_to_url"
xmlns:controls="clr-namespace:Xamarin.Forms.Platform.WPF.Controls">
<Style TargetType="controls:FormsPathIcon">
<Setter Property="HorizontalAlignment" Value="Stretch"/>
<Setter Property="VerticalAlignment" Value="Stretch"/>
<Setter Property="FocusVisualStyle" Value="{x:Null}"/>
<Setter Property="Height" Value="24"/>
<Setter Property="Width" Value="24"/>
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="controls:FormsPathIcon">
<Viewbox>
<Path Data="{Binding Data, RelativeSource={RelativeSource Mode=TemplatedParent}}"
Fill="{TemplateBinding Foreground}"
Stretch="Fill" />
</Viewbox>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style>
</ResourceDictionary>
``` | /content/code_sandbox/Xamarin.Forms.Platform.WPF/Themes/FormsPathIcon.xaml | xml | 2016-03-18T15:52:03 | 2024-08-16T16:25:43 | Xamarin.Forms | xamarin/Xamarin.Forms | 5,637 | 197 |
```xml
import { Button, Panel } from '@mycrypto/ui';
import styled from 'styled-components';
import backArrowIcon from '@assets/images/icn-back-arrow.svg';
import { translateRaw } from '@translations';
import Stepper from './Stepper';
interface ContentPanelWrapperProps {
centered: boolean | undefined;
width?: string;
}
const ContentPanelWrapper = styled.div`
text-align: ${(props: ContentPanelWrapperProps) => (props.centered ? 'center' : 'left')};
width: ${(props: ContentPanelWrapperProps) => (props.width ? props.width : 'auto')};
@media (min-width: 700px) {
max-width: 100%;
width: ${(props: ContentPanelWrapperProps) => (props.width ? props.width : '560px')};
}
@media (max-width: 700px) {
max-width: 100%;
}
`;
const BackButton = styled(Button)`
color: #007a99;
font-weight: bold;
display: flex;
align-items: center;
font-size: 20px;
img {
margin-right: 13px;
}
`;
interface ContentPanelHeadingProps {
centered: boolean | undefined;
}
const ContentPanelHeading = styled.div<ContentPanelHeadingProps>`
font-size: 36px;
width: 100%;
display: flex;
justify-content: ${(props) => (props.centered ? 'center' : 'space-between')};
font-weight: bold;
line-height: normal;
margin-top: 0;
margin-bottom: 15px;
color: ${(props) => props.theme.headline};
`;
const ContentPanelHeadingIcon = styled.img`
width: 45px;
height: 45px;
`;
const ContentPanelDescription = styled.p`
font-size: 18px;
line-height: 1.5;
font-weight: normal;
color: ${(props) => props.theme.text};
white-space: pre-line;
strong {
font-weight: 900;
}
@media (max-width: 700px) {
padding: 0 8px;
}
`;
const ImgIcon = styled.img`
width: 125px;
height: auto;
margin-bottom: 28px;
`;
interface ContentPanelTopProps {
stepperOnly: boolean;
}
const ContentPanelTop = styled.div<ContentPanelTopProps>`
display: flex;
align-items: center;
justify-content: ${(props) => (props.stepperOnly ? 'flex-end' : 'space-between')};
margin-bottom: 10px;
`;
const StyledPanel = styled(Panel)`
padding: 42px 70px;
@media (max-width: 700px) {
padding-left: 15px;
padding-right: 15px;
}
`;
export interface ExtendedControlPanelProps {
children: any;
className?: string;
heading?: string | JSX.Element;
icon?: string;
image?: string;
showImageOnTop?: boolean;
description?: string | JSX.Element;
stepper?: {
current: number;
total: number;
};
centered?: boolean;
width?: string;
backBtnText?: string;
onBack?(): void;
}
export default function ExtendedContentPanel({
onBack,
stepper,
heading,
icon,
image,
showImageOnTop,
description,
centered,
children,
className = '',
width,
backBtnText,
...rest
}: ExtendedControlPanelProps) {
return (
<ContentPanelWrapper centered={centered} width={width}>
{(onBack || stepper) && (
<ContentPanelTop stepperOnly={stepper !== undefined && !onBack}>
{onBack && (
<BackButton basic={true} onClick={onBack}>
<img src={backArrowIcon} alt="Back arrow" />{' '}
{backBtnText
? translateRaw('BACK_WITH_APPEND', { $append: `: ${backBtnText}` })
: translateRaw('BACK')}
</BackButton>
)}
{stepper && <Stepper current={stepper.current} total={stepper.total} />}
</ContentPanelTop>
)}
<StyledPanel className={className} {...rest}>
{image && showImageOnTop && <ImgIcon src={image} alt="Image" />}
{heading && (
<ContentPanelHeading centered={centered}>
{heading}
{icon && <ContentPanelHeadingIcon src={icon} alt="Icon" />}
</ContentPanelHeading>
)}
{description && <ContentPanelDescription>{description}</ContentPanelDescription>}
{image && !showImageOnTop && <ImgIcon src={image} alt="Image" />}
{children}
</StyledPanel>
</ContentPanelWrapper>
);
}
``` | /content/code_sandbox/src/components/ExtendedContentPanel.tsx | xml | 2016-12-04T01:35:27 | 2024-08-14T21:41:58 | MyCrypto | MyCryptoHQ/MyCrypto | 1,347 | 1,047 |
```xml
import message from '@commitlint/message';
import {SyncRule} from '@commitlint/types';
export const subjectFullStop: SyncRule<string> = (
parsed,
when = 'always',
value = '.'
) => {
const colonIndex = parsed.header?.indexOf(':') || 0;
if (colonIndex > 0 && colonIndex === parsed.header!.length - 1) {
return [true];
}
const input = parsed.header;
const negated = when === 'never';
let hasStop = input?.[input.length - 1] === value;
if (input?.slice(-3) === '...') {
hasStop = false;
}
return [
negated ? !hasStop : hasStop,
message(['subject', negated ? 'may not' : 'must', 'end with full stop']),
];
};
``` | /content/code_sandbox/@commitlint/rules/src/subject-full-stop.ts | xml | 2016-02-12T08:37:56 | 2024-08-16T13:28:33 | commitlint | conventional-changelog/commitlint | 16,499 | 179 |
```xml
function def() {
console.log("foo")
}
def();
``` | /content/code_sandbox/tests/runtime-trace-tests/cases/reserved_words_decl.ts | xml | 2016-01-24T19:35:52 | 2024-08-16T16:39:39 | pxt | microsoft/pxt | 2,069 | 14 |
```xml
/// <reference path="../BasicElement.ts"/>
/// <reference path="../control-elements/ControlElements.ts"/>
/// <reference path="../../logic/FlowManager.ts"/>
/// <reference path="../../logic/MicrophoneBridge.ts"/>
/// <reference path="../../interfaces/IUserInputElement.ts"/>
/// <reference path="UserInputElement.ts"/>
// namespace
namespace cf {
// interface
export interface UserInputSubmitButtonOptions{
eventTarget: EventDispatcher;
}
export const UserInputSubmitButtonEvents = {
CHANGE: "userinput-submit-button-change-value"
}
// class
export class UserInputSubmitButton {
private onClickCallback: () => void;
private eventTarget: EventDispatcher;
private mic: MicrophoneBridge;
private _active: boolean = true;
private onMicrophoneTerminalErrorCallback: () => void;
public el: HTMLElement;
public set typing(value: boolean){
if(value){
this.el.classList.add("typing");
this.loading = false;
if(this.mic){
this.mic.cancel();
}
}else{
this.el.classList.remove("typing");
if(this.mic){
this.mic.callInput();
}
}
}
public get typing(): boolean{
return this.el.classList.contains("typing");
}
public set active(value: boolean){
this._active = value;
if(this.mic){
this.mic.active = value;
}
}
public get active(): boolean{
return this._active;
}
public set loading(value: boolean){
if(value)
this.el.classList.add("loading");
else
this.el.classList.remove("loading");
}
public get loading(): boolean{
return this.el.classList.contains("loading");
}
constructor(options: UserInputSubmitButtonOptions){
this.eventTarget = options.eventTarget;
var template: HTMLTemplateElement = document.createElement('template');
template.innerHTML = this.getTemplate();
this.el = <HTMLElement> template.firstChild || <HTMLElement>template.content.firstChild;
this.onClickCallback = this.onClick.bind(this);
this.el.addEventListener("click", this.onClickCallback, false);
this.onMicrophoneTerminalErrorCallback = this.onMicrophoneTerminalError.bind(this);
this.eventTarget.addEventListener(MicrophoneBridgeEvent.TERMNIAL_ERROR, this.onMicrophoneTerminalErrorCallback, false);
}
public addMicrophone (microphoneObj: IUserInput) {
this.el.classList.add("microphone-interface");
var template: HTMLTemplateElement = document.createElement('template');
template.innerHTML = `<div class="cf-input-icons cf-microphone">
<div class="cf-icon-audio"></div>
<cf-icon-audio-eq></cf-icon-audio-eq>
</div>`;
const mic: HTMLElement = <HTMLElement> template.firstChild || <HTMLElement>template.content.firstChild;
this.mic = new MicrophoneBridge({
el: mic,
button: this,
eventTarget: this.eventTarget,
microphoneObj: microphoneObj
});
this.el.appendChild(mic);
// this.mic = null;
// this.el.appendChild(this.mic.el);
}
public reset(){
if(this.mic && !this.typing){
// if microphone and not typing
this.mic.callInput();
}
}
public getTemplate () : string {
return `<cf-input-button class="cf-input-button">
<div class="cf-input-icons">
<div class="cf-icon-progress"></div>
<div class="cf-icon-attachment"></div>
</div>
</cf-input-button>`;
}
protected onMicrophoneTerminalError(event: CustomEvent){
if(this.mic){
this.mic.dealloc();
this.mic = null;
this.el.removeChild(this.el.getElementsByClassName("cf-microphone")[0]);
this.el.classList.remove("microphone-interface");
this.loading = false;
this.eventTarget.dispatchEvent(new CustomEvent(FlowEvents.USER_INPUT_INVALID, {
detail: <FlowDTO>{
errorText: event.detail
} //UserTextInput value
}));
}
}
private onClick(event: MouseEvent){
const isMicVisible: boolean = this.mic && !this.typing;
if(isMicVisible){
this.mic.callInput();
}else{
this.eventTarget.dispatchEvent(new CustomEvent(UserInputSubmitButtonEvents.CHANGE));
}
}
/**
* @name click
* force click on button
*/
public click(): void {
this.el.click();
}
/**
* @name dealloc
* remove instance
*/
public dealloc(): void {
this.eventTarget.removeEventListener(MicrophoneBridgeEvent.TERMNIAL_ERROR, this.onMicrophoneTerminalErrorCallback, false);
this.onMicrophoneTerminalErrorCallback = null;
if(this.mic){
this.mic.dealloc();
}
this.mic = null;
this.el.removeEventListener("click", this.onClickCallback, false);
this.onClickCallback = null;
this.el = null;
this.eventTarget = null;
}
}
}
``` | /content/code_sandbox/src/scripts/cf/ui/inputs/UserInputSubmitButton.ts | xml | 2016-10-14T12:54:59 | 2024-08-16T12:03:40 | conversational-form | space10-community/conversational-form | 3,795 | 1,117 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.