From e74c2a80d24dc0e4122ef529f7b052b9f2803bff Mon Sep 17 00:00:00 2001 From: Chris Hanson Date: Tue, 21 Mar 2000 04:16:22 +0000 Subject: [PATCH] Initial registration with CVS. --- v7/src/compiler/improvements/comcon.scm | 70 +++++++++++ v7/src/compiler/improvements/gasn.scm | 161 ++++++++++++++++++++++++ v7/src/compiler/improvements/rewsub.scm | 37 ++++++ v7/src/microcode/os2utl/bch.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/coffee.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/conses.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/edwin.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/envir1.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/graphics.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/lambda.ico | Bin 0 -> 1958 bytes v7/src/microcode/os2utl/lambda2.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/liar1.ico | Bin 0 -> 1580 bytes v7/src/microcode/os2utl/liar2.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/liar3.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/mincer.ico | Bin 0 -> 1010 bytes v7/src/microcode/os2utl/shield1.ico | Bin 0 -> 1958 bytes v7/src/microcode/os2utl/shield2.ico | Bin 0 -> 1958 bytes v7/src/microcode/os2utl/shield3.ico | Bin 0 -> 1958 bytes v7/src/microcode/os2utl/shield4.ico | Bin 0 -> 1958 bytes 19 files changed, 268 insertions(+) create mode 100644 v7/src/compiler/improvements/comcon.scm create mode 100644 v7/src/compiler/improvements/gasn.scm create mode 100644 v7/src/compiler/improvements/rewsub.scm create mode 100644 v7/src/microcode/os2utl/bch.ico create mode 100644 v7/src/microcode/os2utl/coffee.ico create mode 100644 v7/src/microcode/os2utl/conses.ico create mode 100644 v7/src/microcode/os2utl/edwin.ico create mode 100644 v7/src/microcode/os2utl/envir1.ico create mode 100644 v7/src/microcode/os2utl/graphics.ico create mode 100644 v7/src/microcode/os2utl/lambda.ico create mode 100644 v7/src/microcode/os2utl/lambda2.ico create mode 100644 v7/src/microcode/os2utl/liar1.ico create mode 100644 v7/src/microcode/os2utl/liar2.ico create mode 100644 v7/src/microcode/os2utl/liar3.ico create mode 100644 v7/src/microcode/os2utl/mincer.ico create mode 100644 v7/src/microcode/os2utl/shield1.ico create mode 100644 v7/src/microcode/os2utl/shield2.ico create mode 100644 v7/src/microcode/os2utl/shield3.ico create mode 100644 v7/src/microcode/os2utl/shield4.ico diff --git a/v7/src/compiler/improvements/comcon.scm b/v7/src/compiler/improvements/comcon.scm new file mode 100644 index 000000000..723b2f47a --- /dev/null +++ b/v7/src/compiler/improvements/comcon.scm @@ -0,0 +1,70 @@ +;;; This alternative version of `combination/constant!' attempts to +;;; keep the data structures more consistent. It doesn't seem to be +;;; needed yet. + +(define (combination/constant! combination rvalue) + (let ((continuation (combination/continuation combination))) + (for-each (lambda (continuation) + (set-continuation/combinations! + continuation + (delq! combination (continuation/combinations continuation))) + (set-continuation/returns! + continuation + (cons combination (continuation/returns continuation)))) + (rvalue-values continuation)) + (for-each (lambda (operator) + (if (rvalue/procedure? operator) + (delete-procedure-application! operator combination))) + (rvalue-values (combination/operator combination))) + (maybe-kill-application-procedure! combination) + (set-application-type! combination 'RETURN) + (set-application-operator! combination continuation) + (set-application-operands! combination (list rvalue)) + (let ((push (combination/continuation-push combination))) + (if (and push (rvalue-known-value continuation)) + (set-virtual-continuation/type! (virtual-return-operator push) + continuation-type/effect))))) + +(define (maybe-kill-application-procedure! application) + (let ((operator (rvalue-known-value (application-operator application)))) + (if (and operator + (rvalue/procedure? operator) + (procedure-always-known-operator? operator) + (null? (procedure-applications operator))) + (kill-procedure! operator)))) + +(define (kill-procedure! procedure) + (set! *procedures* (delq! procedure *procedures*)) + (let ((block (procedure-block procedure))) + (set! *blocks* (delq! block *blocks*)) + (let ((parent (block-parent block))) + (set-block-children! parent (delq! block (block-children parent)))) + ;; This should probably be accomplished by a codewalk, but for + ;; current purposes it's adequate. + (for-each kill-application! (block-applications block)))) + +(define (kill-application! application) + (set! *applications* (delq! application *applications*)) + (for-each (lambda (operator) + (if (rvalue/procedure? operator) + (delete-procedure-application! operator application))) + (rvalue-values (application-operator application))) + (if (application/combination? application) + (for-each (lambda (continuation) + (delete-continuation/combination! continuation application)) + (rvalue-values (combination/continuation application)))) + (maybe-kill-application-procedure! application)) + +(define (delete-procedure-application! procedure combination) + (let ((applications (delq! combination (procedure-applications procedure)))) + (set-procedure-applications! procedure applications) + (if (null? applications) + (set-procedure-always-known-operator?! procedure false)))) + +(define (delete-continuation/combination! continuation combination) + (let ((combinations + (delq! combination (continuation/combinations continuation)))) + (set-continuation/combinations! continuation combinations) + (if (and (null? combinations) + (null? (continuation/returns continuation))) + (set-procedure-always-known-operator?! continuation false)))) \ No newline at end of file diff --git a/v7/src/compiler/improvements/gasn.scm b/v7/src/compiler/improvements/gasn.scm new file mode 100644 index 000000000..0d70beadf --- /dev/null +++ b/v7/src/compiler/improvements/gasn.scm @@ -0,0 +1,161 @@ +;;; This alternative version of the assignment generation code (for +;;; "fgopt/reuse") attempts to pop things off the stack as soon as +;;; possible. + +(define (generate-assignments nodes rest) + (define (make-assignments nodes pushed registers) + (if (null? nodes) + (begin + (if (not (and (null? pushed) (null? registers))) + (error "unprocessed pending assignments" pushed registers)) + rest) + (let ((last-dependent (find-last-dependent (car nodes) (cdr nodes)))) + (if last-dependent + (let ((entry (cons last-dependent (car nodes))) + (continue + (lambda (continuation-type pushed registers) + (linearize-subproblem! + continuation-type + (node-value (car nodes)) + (deallocate-registers nodes pushed registers))))) + (if (nodes-simple? (cdr nodes)) + (continue continuation-type/register + pushed + (cons entry registers)) + (continue continuation-type/push + (cons entry pushed) + registers))) + (trivial-assignment + (car nodes) + (deallocate-registers nodes pushed registers)))))) + + (define (deallocate-registers nodes pushed registers) + (with-values + (lambda () + (discriminate-items registers + (lambda (register) + (eq? (car register) (car nodes))))) + (lambda (deallocated-registers allocated-registers) + (let loop ((registers registers)) + (if (null? registers) + (deallocate-pushed nodes pushed allocated-registers) + (let ((node (cdar registers))) + (overwrite node + (subproblem-continuation (node-value node)) + (loop (cdr registers))))))))) + + (define (deallocate-pushed nodes pushed registers) + (let loop ((pushed pushed)) + (let ((continue + (lambda () (make-assignments (cdr nodes) pushed registers)))) + (cond ((null? pushed) + (continue)) + ((not (car pushed)) + (let skip-empty ((pushed (cdr pushed)) (offset 1)) + (if (or (null? pushed) + (car pushed)) + (scfg*node->node! (make-stack-adjustment offset) + (loop pushed)) + (skip-empty (cdr pushed) (1+ offset))))) + ((eq? (car nodes) (caar pushed)) + (overwrite (cdar pushed) 0 (loop (cdr pushed)))) + (else + (let loop ((pushed* (cdr pushed)) (index 1)) + (if (null? pushed*) + (continue) + (let ((rest (lambda () (loop (cdr pushed*) (1+ index))))) + (if (and (car pushed*) (eq? (car nodes) (caar pushed*))) + (let ((node (cdar pushed*))) + (set-car! pushed* false) + (overwrite node index (rest))) + (rest)))))))))) + + (make-assignments nodes '() '())) + +(define (find-last-dependent node nodes) + (let ((target (node-target node))) + (let loop ((nodes nodes) (dependent false)) + (if (null? nodes) + dependent + (loop (cdr nodes) + (let ((node (car nodes))) + (if (memq target (node-original-dependencies node)) + node + dependent))))))) + +(define (nodes-simple? nodes) + (for-all? (cdr nodes) + (lambda (node) (subproblem-simple? (node-value node))))) + +(define (trivial-assignment node rest) + (if (node/noop? node) + rest + (let ((subproblem (node-value node))) + (linearize-subproblem! continuation-type/register + subproblem + (overwrite node + (subproblem-continuation subproblem) + rest))))) + +(define (overwrite node source rest) + (scfg*node->node! + (make-stack-overwrite (subproblem-context (node-value node)) + (node-target node) + source) + rest)) + +;;; base/ctypes + +(define-snode stack-adjustment + offset) + +(define (make-stack-adjustment offset) + (snode->scfg (make-snode stack-adjustment-tag offset))) + +(define-integrable (node/stack-adjustment? node) + (eq? (tagged-vector/tag node) stack-adjustment-tag)) + +(define-snode stack-overwrite + context + target + source) + +(define (make-stack-overwrite block target source) + (snode->scfg (make-snode stack-overwrite-tag block target source))) + +(define-integrable (node/stack-overwrite? node) + (eq? (tagged-vector/tag node) stack-overwrite-tag)) + +;;; base/subprb + +(define (continuation*? object) + (or (virtual-continuation? object) + (continuation? object))) + +;;; rtlgen/rgstmt + +(define (generate/stack-overwrite stack-overwrite) + (let ((target + (stack-overwrite-locative (stack-overwrite-context stack-overwrite) + (stack-overwrite-target stack-overwrite))) + (source (stack-overwrite-source stack-overwrite))) + (cond ((continuation*? source) + (rtl:make-assignment + target + (rtl:make-fetch (continuation*/register continuation)))) + ((exact-nonnegative-integer? source) + (if (zero? source) + (rtl:make-pop target) + (rtl:make-assignment + target + (rtl:make-fetch + (stack-locative-offset (rtl:make-fetch stack-pointer) + source))))) + (else + (error "Illegal stack-overwrite source" source))))) + +(define (generate/stack-adjustment stack-adjustment) + (rtl:make-assignment + register:stack-pointer + (rtl:make-address + (stack-locative-offset (rtl:make-fetch stack-pointer) offset)))) \ No newline at end of file diff --git a/v7/src/compiler/improvements/rewsub.scm b/v7/src/compiler/improvements/rewsub.scm new file mode 100644 index 000000000..307452188 --- /dev/null +++ b/v7/src/compiler/improvements/rewsub.scm @@ -0,0 +1,37 @@ +;;; This code should be incorporated in a separate pass. It finds +;;; subproblems that contain combinations that have been rewritten as +;;; returns (e.g. constant folding), and rewrites them so that they +;;; reflect the new code. + +;;; This is a partial solution which works provided that "fgopt/order" +;;; uses `new-subproblem-rvalue' instead of `subproblem-rvalue'. A +;;; better solution is to rewrite the subproblems and replace them in +;;; the parallel, then update the application's operator/operand slots +;;; to reflect the new rvalues. Then everything will be consistent. + +(define (rewrite-parallel-subproblems parallel) + (let ((application (parallel-application parallel)) + (subproblems (parallel-subproblems parallel))) + (if (application/combination? application) + (begin + (set-application-operator! application + (new-subproblem-rvalue (car subproblems))) + (set-application-operands! + application + (cons (car (application-operands application)) + (map new-subproblem-rvalue (cdr subproblems)))))))) + +(define (new-subproblem-rvalue subproblem) + (if (subproblem-simplified? subproblem) + (return/operand + (car (continuation/returns (subproblem-continuation subproblem)))) + (subproblem-rvalue subproblem))) + +(define (subproblem-simplified? subproblem) + (and (subproblem-canonical? subproblem) + (let ((continuation (subproblem-continuation subproblem))) + (and (continuation/always-known-operator? continuation) + (let ((returns (continuation/returns continuation))) + (and (not (null? returns)) + (null? (cdr returns)) + (return/continuation-push (car returns)))))))) \ No newline at end of file diff --git a/v7/src/microcode/os2utl/bch.ico b/v7/src/microcode/os2utl/bch.ico new file mode 100644 index 0000000000000000000000000000000000000000..f49a34cc8c8acbbe95369ffc9eeff6a99c37587f GIT binary patch literal 1010 zcmc(eF>ljA6vzKItrGj%+G1d~JoXbH76MExC`&ew`VqP?G1wE$n6=G-)zL$^5yguI zYa+U2sw{a%k!7(GIR5YK00R<847|H{@BQxGyXQOW9zS}HpYr7CGeXGrnRY~tdh5WU zN9j!me;$o7_+?jSkC+to>fnGL#qG@Bk14>8H0=yWy3`b9Su$X32dmSgvdNST|5=Rr zHZbjd=W7b=_$^lN)Yt_rcK5Wk=F1qSI){0ChBsFl!NC}V;W=K15#H054`!%O-#PV* zPlNX5S<>ESN!!#({c4od50QKTHFc7UIxrVJ^hfGmet-NpjsfrTawg%(jq^N@z4?4@ zC$3M4d9LO~QOE*I-DM>W-_#QysoOsGN1y5P}1XafzmxQsudaidK3j8goekDup$+-*6!Un>R4l@;Q6^d vtS#X2K<=IkH{!DiuYRz9%{;l{O!8Sh=k?2_?wMPOWR_VCz96lL@IT0RYD44M literal 0 HcmV?d00001 diff --git a/v7/src/microcode/os2utl/coffee.ico b/v7/src/microcode/os2utl/coffee.ico new file mode 100644 index 0000000000000000000000000000000000000000..500d8207465481574f35e0e7b18d472c93ddda01 GIT binary patch literal 1010 zcmc&xJ5s|i5Pbq>?9Mqt?vMjGKt;m|atL>B)mfddKdOuIGeMtGY6(mRO(0wJcf6X%3fdxP&NmccZ!>;2 zJ2`RnADbr;uAM=>rDHqx8}*vJ!kXRF=$ok3Gf#+LVptRW@iZcbKcU4zXp`yzyVJ(t JU2k;uGVeijXnX(w literal 0 HcmV?d00001 diff --git a/v7/src/microcode/os2utl/conses.ico b/v7/src/microcode/os2utl/conses.ico new file mode 100644 index 0000000000000000000000000000000000000000..9e6919ea4062944ee7455de79428cf0401ad5e37 GIT binary patch literal 1010 zcmc&xyHNu%5Zz-)_{@kBT#A8+gbL^dl|ZUUxm$2@1vsDq&rpF!CR6lytCfVf88Afb z-D>yU{@$(bZlB~+?jIfrZuq>@uBoePCzT!fBH*m7=GC}!J zk~52B32jp@9S&~{XIyQ!mzzz;am0Z#V&;E|kM)cGK&GGOG1ds#f1<{Ne)4A z%NOLrHOY&H8Oj=#gqZgG*FRt^@)uZ}4*mQ5IxbdyH=EIS1`BCG`{a$Ear+mwP hUB>lp*Kr)N?zdx<{KyNle8U`ISi9<)%=T+-&IgOqS8)IU literal 0 HcmV?d00001 diff --git a/v7/src/microcode/os2utl/edwin.ico b/v7/src/microcode/os2utl/edwin.ico new file mode 100644 index 0000000000000000000000000000000000000000..5e9a5e468dd3ff97e50b76755c6c31669c6c5c05 GIT binary patch literal 1010 zcmd^-Jr2S!424~U#8{5dqZH`E0vF&AZ0*)=>9KmG2qD21KBtxXX9;#*;@Ix9oy6(! zaFY?I^95(mc%XA68+0NG78q3Td|yKdGO0>-PEs~VB3mr5>DBLRBf^xX=@ly`(n!~J z5Ft)scPxaVpLF?ilnc}}Wr9~daWG%^dB1i`e;Kd7NUFo9 zHdWrt*Yo-)o&dW(i34n2EA;=1$wTV}?fv!iUN4wxgpsdo4A35}d9o<)wK-tLS8XxE WwXS*>AzYtP3g_I6Z=G8_cliNZe0p^N literal 0 HcmV?d00001 diff --git a/v7/src/microcode/os2utl/envir1.ico b/v7/src/microcode/os2utl/envir1.ico new file mode 100644 index 0000000000000000000000000000000000000000..8c5c3f6a3fffae589561352cf02bd947d64129ef GIT binary patch literal 1010 zcmc(dK~lpo3`G@&8QfJlLXT2l#il3V9&L8s#XUiyRj!gFG3>fBPqq_M0|UE$N7Db2 zB~P3@KfTEpUS1D~N7e^%kL^lqq=A7FviRG_7-cn;?mbPrVvXFxz+Ddi_g;iYyw3p- z#k@?@L?Na}I30$uEM@M-@SJ~3bKx34>2=O{rM-}w;X|78dvchE8RRES9!gHfQXH%77v-NFMlxeoChz zb?|@~*vz@MOWO><&WZ2i+;jcR<;5NCadmwIa*FRAaRe)49MAw65JMopd*>V-tcuwq zOe&)d=mZ&%gz$IY5MfZ$gaD5e*3fFTg5dlh?2ZhEk4x{3B<)fr@10AQL99Knux&;^L zC83!Y+j2qt3cTi-q*`8S%5T45&XGccl&a_C_CyR=LH^77xPLn4{L4l~Rb8!V0Ae<8M94Xvgag9&c z(D4dqMWVJsb48@(`@CM;xF9(cDPw;-Gdn-K_Uz8_n{yGl9%2B!Jw3xX!E+5B0$$Ar zGJpiCnO1Hel~UcThz=3t)fmVK66ip)yN`(oUP%(oFhT?p$@3frRlS1MApv+e#o>Vo zd#LEQQa`sx>ifo@?x0 z7b#JG)Yz&bCDy9gtkq_7r8b39Dc9q|ax1M`4~mYgR@D^QQY3RS44fAybK<`4$Z~<{ zIenH6tdhl$;<+PEtaWQ4nH4V@T_B1@CvAs}PJI|j;kC0a;&G?8-F=!?`8<&{oMG=M{QQGlQn_758dhD?vwC8e5-4V;h}HtW06-+ z%cCDJ?8$rL^qc)Xx|q6A1f0y=C;(IPl!aU=(5wuoI1`AO@I; z8_XmKo=M<}L|l)*OP?I`}Ac3G*m=Qarylm$5GB)QLhj!>u%(linxmO_p=k>ldg-z zNy+YHzuyCl{t4Zw*erXptn~;T4uSLpa1ea5}V_CLHMk&KwihW02rr5_&TrR2jqktpgT2 zWlrLEzXsZ&&ru x!)N-xp$vnRnd{BHXWg(&XYSyjf!lC>e~yt4d@@BlpgiPe#1Lo|+seaq~AP-1W&vB24# z5M^QzE=Hz%5soX$DbJPCx#wEL|H_pP;zWu<{!M-`ALT0V^ZVufcp+qu2( zL&xG_`FNw56tXYqz#AbNshNugzR*HS(KwED9JvX37nfa}(*;!H^Bw1Jt}vh1-<2rR z&Roaul8268j)vZ>5dNEvU!DxJmcgtw{6hr4?jh;_k{jE#oVUMgxufH|*5D$1FNmDzhH?J^pyX;H3{`ui#X zCq$CsN|O*Q%R)!=33jJNaM+eD|11kuQ3zawJ;a*0=2_1L%jygvQ1C|km3YbV%rV>d z%;&KUTSUi(`i8f+2k46UOKb}5oXo@)4%M_@h#! zw3}fcQ~VHV(XDQO;ZlmY&XQcY>FzdCzn` Ny3hS&s)c?tJ^+ek=6wJF literal 0 HcmV?d00001 diff --git a/v7/src/microcode/os2utl/liar3.ico b/v7/src/microcode/os2utl/liar3.ico new file mode 100644 index 0000000000000000000000000000000000000000..7bb96c4007fff9bd8d6649ee7ef135e8d6a3fa5c GIT binary patch literal 1010 zcmc(cF>b>!3`MD=K!Ggj5e$!=3TV`lv{RR!poh^}I(pUU#W&~`(i;SsIuu}^EZLSd zG}%h~ll&$>Wz)~ccUkP^^$qgCbs-)=lcNzshUJjRb+4*YOhtV_)MOaBBf~Z+-0r;y zw|Jido)mZ)hJk{Pw{SWc;EIo;`)AWL?{NadpD@(7`n^{@gBX8ujQj+KPt`Ai81;Z( za|K)K_qQ#;&X%_2dh4tUwzrAf01pmK-1TA2V?VO24=7@N(%X^aCViUkCSIK{o3?FJ zYw}&!eUyAxajAG+uk@53%Xv{<@?F=Ir^%|guFP+4pT+{8ZO3JWH4kp$fqLx8ypNoH Z*Zs>p7Z*S4d-huPqho^ literal 0 HcmV?d00001 diff --git a/v7/src/microcode/os2utl/mincer.ico b/v7/src/microcode/os2utl/mincer.ico new file mode 100644 index 0000000000000000000000000000000000000000..c2af5035f210b2d07b165beec86507582bfb5bc6 GIT binary patch literal 1010 zcmc(azfJ-{5XR@k$D*8 zN+Kb#u(2c7c;k1waPHDz=j?qm^PAb7-8($EpkF&WJp&Z6z7T6rWf3j1kiix~!Ftck zq)o-?8V*$!vS^I&Vh*rtKI!8TY}R%Vlxi5(Ynfe=b`xy8S1EMSO49 zrKu75$BDs?e_fF8=b1X^wN2iN98a1y785iga@b^Vg*#l&egFrZHS94P7p!u2w^dT< xFh9yiNK2)nEDVVxtG??K4b(>ICGW&p#r3E0Kx3k5Oa^CLRWj&~+&itN^AEMayt@DZ literal 0 HcmV?d00001 diff --git a/v7/src/microcode/os2utl/shield1.ico b/v7/src/microcode/os2utl/shield1.ico new file mode 100644 index 0000000000000000000000000000000000000000..8aab3182418d59129c3515745b905be0da1779e4 GIT binary patch literal 1958 zcmc&#y-veG40cE%-O{yF`T#saMMIfbcmihTZd3@7+Zg)@yg(l!5+ehz5D5v^s7o`1 zn$P#sOI1-Qt*8^9@ALVb#P&JE^J^lSg&05=msc1&xMq+kxMyWR0cId84ET9u=B8Kd zPO+(HIiMD1pd%xGKPn>Jq?8dDF$F8i^BfDTZ^F|t1LG2v3lf6&5ZPVyp?@16nRy z1GfsP4Mr0#t&QLqpuDw48fQ$89y5=)?R;PZu-h&U5!sR^ZhcNLEhX`WD#3m`SNiRi z?(l|q_&l@L5Q4osjT_qy_SXM`@y$A1h>biCLS{OY4#C2x*T_T%b(2@ zi~Bk8(_`+Y6u0#+!C0mjy Youy}F2-$I&k&HC6A<@T2<5UuT0SCev(EtDd literal 0 HcmV?d00001 diff --git a/v7/src/microcode/os2utl/shield2.ico b/v7/src/microcode/os2utl/shield2.ico new file mode 100644 index 0000000000000000000000000000000000000000..2f78db8980d4cb8bc6890f7b51340fa9379d5645 GIT binary patch literal 1958 zcmc&#J#Q015S_z@b+>NQU>7M;=t0hvpTBQC5nl4X{Gde_>M6@I46we0 zUq=s$M@-WEXW@B|xiHMrh}n~y6K&0idIgaUL}p6V63vinQC}*pBCV;(db6#<&H4K; zcc*xed#L21z z(-XFNZj50340k}Dha?dPVDVswabRRN5E$77NKPHWvKWz22!=Zcc*DQY)d?;{0t1KK z$$VX(V$gvD>j#m{7Ygv{TSo_z%4v+Ka#Wg~MM&_+x;QbgS%f4Q%)kcxigOBxA+d=i zonJE_^CM;~LbHvgDqNjwBuM3_de&y5k)HU?3#Fww@oBp`n=uB@=ESGx8`k~;t4Dts zDZ^dH&f*iEalY6mHXFZxG%5^+>CICP>YYe;l0fA?(OL7^OtL1ZeCw|f3G|E z@NHx8;?u_P;^$YBAs@J*-*m&B^wDJZ!S-bR>Erp)fn%PD-hcCPeCzG&^u}mCy)(En z7Tb0&4C0n=V=JhXJE!b7{}mnD$6ktI?pIpx91pyVNR8|L*rB_oVeNvZW{sDj#9U!r zRrJ2bT`l)C@@}Tp{p{)YBGuD7S274ssg_hqtMm>PLUqc@?4(kWx)M?a>1+1k`U6K6 B&}jew literal 0 HcmV?d00001 diff --git a/v7/src/microcode/os2utl/shield3.ico b/v7/src/microcode/os2utl/shield3.ico new file mode 100644 index 0000000000000000000000000000000000000000..a5be9644fe4a234b3666c595cacde5873fe41616 GIT binary patch literal 1958 zcmdT_y^9k;6o2bPH!#Jey~a&(#T8dQ@?22QA16U;TWki13k8zCwv6R8dhBa9H;d zMn?;ZADg)N$6}X}we!&0GO$)rx+L0O5JhvMwHZ-ZdKCo`YoNTkb4IM4GuPj3Vt?lXNWf1aa3+C$#Z(Ifmyl^@xW+_Pv)AjWFU-`G9K`( z7>gKvb0HYtHDm;n>p12B49gKl!mo7*tYe2Y!dS#_q;%o${9E#%G=8ZYFU4nH!&-Y*_m(R)zK|@}JyX zQC7FM_**xZ-`^1I(Tpfv5Z(|H_DF^HZLwzeuLke$KU{xv`QrNX8@=I+51YdWuQo@g zUq70T>_IwGTj^*wyFJ~%wKLtgcV~HYkXpN7z4`Rz@y^fAqp7$e+ABi^Db<^f!=cx(#BVSe0h zFeD1hA4J@rDZuAH9}nEh*O+Hvt+EMLgq27MsDvr7LRi3H1{TcE7$aeR=cSTp^W(ML zT>JTiL9iE$QL)wRbwJp)*7&j>`5V7=F8I3}U-r7YnW6E|-1zcr$J$?F)v#BQ|K#RI zb#rU0zjbr@{f)t%PKok4;SHh4o$A=Vsn*@mP4Vu*qvZAVYsvFlYVhLy=HTJ0&EbW^ z$CIHu&WCy{A0Cu?2 zf|qb|g5CXBtkGMXr3~(VqwUGjz^e%7xIK?+v=?`*3N$TiwhATsGVAY(f3NXY^E-`w rkL&Jj{w_7YyZ+7P9YiE&i!i literal 0 HcmV?d00001 -- 2.25.1