I call it the ruliad. Think of it as the entangled limit of everything that is computationally possible: the result of following all possible computational rules in all possible ways. It’s yet another surprising construct that’s arisen from our Physics Project. And it’s one that I think has extremely deep implications—both in science and beyond.
In many ways, the ruliad is a strange and profoundly abstract thing. But it’s something very universal—a kind of ultimate limit of all abstraction and generalization. And it encapsulates not only all formal possibilities but also everything about our physical universe—and everything we experience can be thought of as sampling that part of the ruliad that corresponds to our particular way of perceiving and interpreting the universe.
We’re going to be able to say many things about the ruliad without engaging in all its technical details. (And—it should be said at the outset—we’re still only at the very beginning of nailing down those technical details and setting up the difficult mathematics and formalism they involve.) But to ground things here, let’s start with a slightly technical discussion of what the ruliad is.
In the language of our Physics Project, it’s the ultimate limit of all rulial multiway systems. And as such, it traces out the entangled consequences of progressively applying all possible computational rules.
Here is an example of an ordinary multiway system based on the string replacement rules {A → AB, BB → A} (indicated respectively by blueish and reddish edges):
✕

At each step, the rules are applied in all possible ways to each state. Often this generates multiple new states, leading to branching in the graph. But, importantly, there can also be merging—from multiple states being transformed to the same state.
The idea of a rulial multiway system is not just to apply particular rules in all possible ways, but to apply all possible rules of a given form. For example, if we consider “1 → 2, 2 → 1 A, B string rules”, the possible rules are
✕

and the resulting multiway graph is (where now we’re using purple to indicate that there are edges for every possible rule):
✕

Continuing a little longer, and with a different layout, we get:
✕

This may already look a little complicated. But the ruliad is something in a sense infinitely more complicated. Its concept is to use not just all rules of a given form, but all possible rules. And to apply these rules to all possible initial conditions. And to run the rules for an infinite number of steps.
The pictures above can be thought of as coarse finite approximations to the ruliad. The full ruliad involves taking the infinite limits of all possible rules, all possible initial conditions and all possible steps. Needless to say, this is a complicated thing to do, and there are many subtleties yet to work out about how to do it.
Perhaps the most obviously difficult issue is how conceivably to enumerate “all possible rules”. But here we can use the Principle of Computational Equivalence to tell us that whatever “basis” we use, what comes out will eventually be effectively equivalent. Above we used string substitution systems. But here, for example, is a rulial multiway system made with 2state 2color Turing machines:
✕

And here is a rulial multiway system made from hypergraph rewriting of the kind used in our Physics Project, using all rules with signature:
✕

As another example, consider a multiway system based on numbers, in which the rules multiply by each possible integer:
✕

Here’s what happens starting with 1 (and truncating the graph whenever the value exceeds 100):
✕

Even with this simple setup, the results are surprisingly complicated (though it’s possible to give quite a bit of analysis in this particular case, as described in the Appendix at the end of this piece).
The beginning of the multiway graph is nevertheless simple: from 1 we connect to each successive integer. But then things get more complicated. To see what’s going on, let’s look at a fragment of the graph:
✕

In a sense, everything would be simple if every path in the graph were separate:
✕

✕

But the basic concept of multiway systems is that equivalent states should be merged—so here the “two ways to get 6” (i.e. 1 × 2 × 3 and 1 × 3 × 2) are combined, and what appears in the multiway graph is:
✕

For integers, the obvious notion of equivalence is numerical equality. For hypergraphs, it’s isomorphism. But the important point is that equivalence is what makes the multiway graph nontrivial. We can think about what it does as being to entangle paths. Without equivalence, different paths in the multiway system—corresponding to different possible histories—would all be separate. But equivalence entangles them.
The full ruliad is in effect a representation of all possible computations. And what gives it structure is the equivalences that exist between states generated by different computations. In a sense, there are two forces at work: the “forward” effect of the progress of computation, and the “sideways” effect of equivalences that entangle different computations. (Mathematically this can be thought of as being like decomposing the ruliad structure in terms of fibrations and foliations.)
In thinking about finding a fundamental theory of physics, one thing always bothered me. Imagine we successfully identify a rule that describes everything about our universe. Then the obvious next question will be: “Why this rule, and not another?” Well, how about if actually the universe in effect just runs every possible rule? What would this mean? It means that in a sense the “full story” of the universe is just the ruliad.
But the ruliad contains everything that is computationally possible. So why then do we have the perception that the universe has specific laws, and that definite things happen in it?
It all has to do with the fact that we are bounded observers, embedded within the ruliad. We never get to see the full ruliad; we just sample tiny parts of it, parsing them according to our particular methods of perception and analysis. And the crucial point is that for coherent observers like us, there are certain robust features that we will inevitably see in the ruliad. And these features turn out to include fundamental laws of our physics, in particular general relativity and quantum mechanics.
One can imagine an observer very different from us (say some kind of alien intelligence) who would sample different aspects of the ruliad, and deduce different laws. But one of the surprising core discoveries of our Physics Project is that even an observer with quite basic features like us will experience laws of physics that precisely correspond to ones we know.
An analogy (that’s actually ultimately the result of the same underlying phenomenon) may help to illustrate what’s going on. Consider molecules in a gas. The molecules bounce around in a complicated pattern that depends on their detailed properties. But an observer like us doesn’t trace this whole pattern. Instead we only observe certain “coarsegrained” features. And the point is that these features are largely independent of the detailed properties of the molecules—and robustly correspond to our standard laws of physics, like the Second Law of thermodynamics. But a different kind of observer, sampling and “parsing” the system differently, could in principle identify different features, corresponding to different laws of physics.
One of the conceptual difficulties in thinking about how we perceive the ruliad is that it’s a story of “selfobservation”. Essentially by the very definition of the ruliad, we ourselves are part of it. We never get to “see the whole ruliad from the outside”. We only get to “experience it from the inside”.
In some ways it’s a bit like our efforts to construct the ruliad. In the end, the ruliad involves infinite rules, infinite initial conditions, and infinite time. But any way of assembling the ruliad from pieces effectively involves making particular choices about how we take those infinite limits. And that’s pretty much like the fact that as entities embedded within the ruliad, we have to make particular choices about how to sample it.
One of the remarkable aspects of the ruliad is that it’s in some sense the unique ultimately inevitable and necessary formal object. If one sets up some particular computational system or mathematical theory, there are choices to be made. But in the ruliad there are no choices. Because everything is there. And in a sense every aspect of the structure of the ruliad is just something formally necessary. It requires no outside input; it is just a formal consequence of the meaning of terms, like the abstract fact .
But while the ruliad is unique, the description of it is not. In constructing it, one can imagine using Turing machines or hypergraph rewriting systems or indeed any other kind of computational system. Each will ultimately lead to the same limiting object that is the ruliad, but each of them can be thought of as defining a different coordinate system for describing the ruliad.
The very generality of the ruliad makes it unsurprising that there is vast diversity in how it can be described. And in a sense each possible description is like a possible way of experiencing the ruliad. In analogy to the (deeply related) situation with spacetime in general relativity, we might say that there are many reference frames in which to experience the ruliad—but it’s always the same ruliad underneath.
It’s important to understand that the “ruliad from the outside” could seem very different from any “internal” experience of it by an observer like us. As an example, consider a simple finite approximation to the ruliad, built from string substitution systems. In what we did above, we always started from a specific initial condition. But the full ruliad involves starting from all possible initial conditions. (Of course, one could always just say one starts from a “null” initial condition, then have rules of the form null → everything.) So now let’s consider starting from all possible strings, say of length 4. If we use all possible 2elementto2element rules, the finite approximation to the ruliad that we’ll get will be:
✕

At some level this is a simple structure, and—as is inevitable for any finite approximation to the ruliad—its transitive closure is just the complete graph:
✕

So why doesn’t this mean that the ruliad is somehow trivial? A key part of the story is that we never get to “see the ruliad from the outside” like this. We are always part of it, sampling it according to some procedure, or, somewhat equivalently, thinking about constructing it according to some procedure.
As an analogy, consider the real numbers. The whole continuum of all real numbers is “from the outside” in many ways a simple construct. But if we imagine actually trying to construct real numbers, say digit by digit, according to some definite procedure, then we’re dealing precisely with what Turing machines were originally invented to model, and the whole structure of computation is involved. (As we’ll see, our way of thinking about “observers like us” is ultimately quite related to “Turing machines with bounded descriptions”.)
In a sense, at an outside “holistic” level, the ruliad has a certain simple perfection. But as soon as you try to look at “what’s in the ruliad”, you have to parametrize or coordinatize it, and then you’re inevitably exposed to its intricate internal structure.
One could imagine very different ways in which entities embedded within the ruliad could “experience” it. But what’s most relevant for us is how “observers like us” do it—and how we manage to synthesize from what’s going on in the ruliad our perception of reality, and our view of how our physical universe works.
Let’s start by talking not about the full ruliad but rather about models in our Physics Project based on specific underlying rules. At the lowest level, we have a “machinecode” description of the universe is which everything just consists of a network of “atoms of space” that is continually being updated—and which we can think of as carrying out a giant, if incoherent, computation, full of computational irreducibility. But the remarkable fact is that somehow we, as observers of this, manage to pick out of it a certain slice that ends up showing coherent, computationally reducible features—that for example seem to reproduce our known laws of physics.
How does this work? Partly it has to do with features of us as observers, partly with features of how the universe fundamentally works, and partly with an interplay between these.
The first crucial feature of us as observers is that we’re computationally bounded: the way we “parse” the universe involves doing an amount of computation that’s absolutely tiny compared to all the computation going on in the universe. We sample only a tiny part of what’s “really going on underneath”, and we aggregate many details to get the summary that represents our perception of the universe.
But why should that summary have any coherence? Basically it’s because we impose coherence through our definition of how observers like us work. One part of the universe will be affected by others. But to consider part of the universe as an “observer”, there has to be a certain coherence to it. The behavior of the universe somehow has to imprint itself on a “medium” that has a certain coherence and consistency.
Down at the level of atoms of space, everything is always changing. But we can still identify emergent features that have a certain persistence. And it’s out of those features that what we call observers are built. Given only the atoms of space with all their computationally irreducible behavior, it’s not at the outset obvious that any real persistence could exist or be identified. But in our models we expect that there will, for example, be essentially topological features that correspond to particles that persistently maintain their identity.
And the point is that we can expect to “aggregate up” much further and be able to identify something like a human observer—that we can consider to persistently maintain its identity to the point where phenomena from the universe can be “systematically imprinted” on it.
Down at the level of atoms of space, there’s a whole multiway graph of possible sequences of updates that can occur—with each path in effect corresponding to a different “thread of time” for the universe. But it’s a crucial fact about us as observers of the universe that we don’t perceive all those branching and merging threads of time. Instead, we imagine that we have a single, definite thread of experience—in which everything is sequentialized in time.
I’ve argued elsewhere that this sequentialization in time is a defining characteristic of “humanlike consciousness”. And it turns out that one of its consequences is that it implies that the particular perception we will have of the universe must be one in which there are laws of physics that correspond to ones we know.
It’s not obvious, by the way, that if we sequentialize time we can form any consistent view of the universe. But the phenomenon of causal invariance—which seems ultimately to be guaranteed by the fundamental structure of the ruliad—turns out to imply that we can expect a certain generalized relativistic invariance that will inevitably lead to eventual consistency.
The notion of sequentialization in time is closely related to the idea that—even though our individual atoms of space are continually changing—we can view ourselves as having a coherent existence through time. And there’s a similar phenomenon for space. At the outset, it’s not obvious that there can be “pure motion”, in which something can move in space without “fundamentally changing”. But it turns out again to be consistent to view this as how things work for us: that even though we’re “made of different atoms of space” when we’re in different places, we can still imagine that in some sense we maintain the “same identity”.
Down at the level of individual atoms of space, there really isn’t any coherent notion of space. And the fact that we form such a notion seems to be intimately connected to what we might think of as details of us. Most important is that we’re in a sense “intermediate in size” in the universe. We’re large relative to the effective distance between atoms of space (which might bem), yet we’re small compared to the size of the whole universe (m). And the result is that we tend to aggregate the effects of many atoms of space, but still perceive different features of space (say, different gravitational fields) in different parts of the universe.
The fact that we “naturally form a notion of space” also seems to depend on another issue of scale—that for us the speed of light “seems fast”. It takes our brains perhaps milliseconds to process anything we see. But the point is that this is very long compared to the time it takes light to get to us from objects in our typical local environment. And the result is that we tend to perceive there as being an instantaneous configuration of the world laid out in space, that “separately” changes in time. But if, for example, our brains ran much faster, or we were much bigger than we are, then the speed of light would “seem slower” to us, and we wouldn’t tend to form the notion of an “instantaneous state of space”.
OK, so what about quantum mechanics? The most fundamental feature of quantum mechanics is that it implies that things in the universe follow not just one but many possible paths of history—which we only get to make certain kinds of measurements on. And in our Physics Project this is something natural, and in fact inevitable. Given any particular configuration of the universe, there are many possible updates that can occur. And when we trace out all the possibilities, we get a multiway system, in which different threads of history continually branch and merge.
So how do observers like us fit into this? Being part of the universe, we inevitably branch and merge, just like the rest of the universe. So to understand our experience, what we need to ask is how a “branching brain” will perceive a “branching universe”. And the story is remarkably similar to what we discussed above for our experience of space and time: it all has to do with imagining ourselves to have a certain definite persistence.
In other words, even if when “viewed from the outside” our brain might be following many different paths of history, “from the inside” we can still potentially assume that everything is conflated into a single thread of history. But will this ultimately be a consistent thing to do? Once again, causal invariance implies that it will. There are specific “quantum effects” where we can tell that there are multiple branches of history being followed, but in the end it’ll be consistent to imagine an “objective reality” about “what happened”.
In our Physics Project we imagine that there are abstract relations between atoms of space, and in the end the pattern of these relations defines the structure of physical space. But what about different branches of history in the multiway graph? Can we think of these as related? The answer is yes. For example, we can say that at a particular time, states on two branches are “adjacent” if they share an immediate ancestor in the multiway graph. And tracing through such connections we can develop a notion of “branchial space”—a kind of space in which states on different branches of history are laid out:
✕

One can think of branchial space as being defined by the pattern of entanglements between different branches of history. And in our Physics Project it turns out that the fundamental laws of quantum mechanics seem to just be a direct translation of the fundamental laws of spacetime into branchial space. And just like the speed of light governs the maximum rate at which effects can propagate in physical space, so similarly in our models there’s a “maximum entanglement speed” at which effects can propagate in branchial space.
So what are we like as observers in branchial space? Just like in physical space, we can presumably be thought of as having a certain size in branchial space. We don’t yet know quite how to measure this size, but it’s surely related to the effective number of quantum degrees of freedom we involve.
In our everyday experience of things like gases, we’re sufficiently large compared to individual molecules that we normally just perceive the gas as some kind of continuum fluid—and in normal circumstances we can’t even tell that it’s made of molecules. Well, it’s presumably the same kind of thing for physical space—where we’re even much larger compared to the atoms of space, and it’s a major challenge to figure out how to detect their presence. What about for branchial space? As the underlying rules for the system get applied, different branches of history will in effect “move around” in branchial space in complex and computationally irreducible ways. And just like when we observe molecules in a gas, we’ll mostly just observe overall aggregate effects analogous to fluid mechanics—and only in special circumstances will we notice “quantum effects” that reveal the presence of multiple independent threads of history.
We’ve discussed how “observers like us” perceive models of physics of the type that arise in our Physics Project. But how will we perceive the whole ruliad? It begins with a generalization of the story for branchial space. Because now as well as having different branches associated with different updatings according to a particular rule, we have different branches associated with updatings according to different rules.
And just as we can slice an ordinary multiway system at a particular time to get an instantaneous version of branchial space, so now we can slice a rulial multiway system to get an instantaneous version of what we can call rulial space—a space in which different branches can correspond not just to different histories, but to different rules for history.
It’s a fairly complicated setup, with “pure branchial space” inevitably being deeply interwoven with rulial space. But as a first approximation, we can think of rulial space as being somewhat separate, and laid out so that different places in it correspond to the results of applying different rules—with nearby places effectively being associated with “nearby” rules.
And just as we can think of effects propagating in branchial space, so also we can think of them propagating in rulial space. In branchial space we can talk about entanglement cones as the analog of light cones, and a maximum entanglement speed as the analog of the speed of light. In rulial space we can instead talk about “emulation cones”—and a “maximum emulation speed”.
In our rough approximation of rulial space, each point is in effect associated with a particular rule. So how do we “move” from one point to another? Effectively we have to be emulating the behavior of one rule by another. But why should it even be possible to do this? The answer is the Principle of Computational Equivalence, which states that, in effect, most rules will be equivalent in their computational capabilities—and in particular they will be capable of universal computation, so that any given rule can always “run a program” that will make it emulate any other rule.
One can think of the program as an interpreter or translator that goes from one rule to another. The Principle of Computational Equivalence tells one that such a translator must essentially always exist. But how fast will the translator run? Effectively that’s what distance in rulial space measures. Because to “do a certain translation”, branches in the rulial multiway system have to reach from one rule to another. But they can only do that at the maximum emulation speed.
What does the maximum emulation speed measure? Effectively it corresponds to the raw computational processing speed of the universe. We can think of representing computations in some language—say the Wolfram Language. Then the processing speed will be measured in “Wolfram Language tokens processed per second” (“WLT/s”). In some sense, of course, giving a value for this speed is just a way of relating our human units of time (say, seconds) to the “intrinsic unit of time” associated with the computational processing that’s going on in the universe. Or, in other words, it’s a kind of ultimate definition of a second relative to purely formal constructs.
OK, but how does this relate to us as observers embedded within the ruliad? Well, just as we imagine that—along with the rest of the universe—we’re continually branching and merging in branchial space, so also this will be what happens in rulial space. In other words—like the rest of the universe—our brains aren’t following a particular rule; they’re following branching and merging paths that represent all possible rules.
But “from inside” we can still potentially imagine that we have a single thread of experience—effectively conflating what happens on all those different branches. And once again we can ask whether doing this will be consistent. And the answer seems to be that, yes, it can be. And what guarantees this is again a kind of “rulial relativity” that’s a consequence of causal invariance. There are many details here, which we’ll address to some extent later. But the broad outline is that causal invariance can be thought of as being associated with paths of history that diverge, eventually converging again. But since the ruliad contains paths corresponding to all possible rules, it’s basically inevitable that it will contain what’s needed to “undo” whatever divergence occurs.
So what does this mean? Basically it’s saying that even though the universe is in some sense intrinsically “following all possible rules”—as represented by paths in the ruliad—we as observers of the universe can still “take the point of view” that the universe follows a particular rule. Well, actually, it’s not quite a particular rule. Because just as we’re in some sense “quite big” in physical and presumably branchial space, so also we’re potentially “quite big” in rulial space.
And being extended in rulial space is basically saying that we consider not just one, but a range of possible rules to be what describe the universe. How can it work this way? Well, as observers of the universe, we can try to deduce what the “true rule for the universe” is. But inevitably we have to do this by performing physical experiments, and then using inductive inference to try to figure out what the “rule for the universe is”. But the issue is that as entities embedded within the universe, we can only ever do a finite number of experiments—and with these we’ll never be able to precisely nail down the “true rule”; there’ll always be some uncertainty.
When we think of ourselves as observers of the universe, there’s in a sense lots of “arbitrariness” in the way we’re set up. For example, we exist at a particular location in physical space—in our particular solar system and so on. Presumably we also exist at a particular location in branchial space, though it’s less clear how to “name” that. And in addition we exist at a particular location in rulial space.
What determines that location? Essentially it’s determined by how we operate as observers: the particular sensory system we have, and the particular means of description that we’ve developed in our language and in the history of knowledge in our civilization. In principle we could imagine sensing or describing our universe differently. But the way we do it defines the particular place in rulial space at which we find ourselves.
But what does all this mean in terms of the ruliad? The ruliad is the unique limiting structure formed by following all possible rules in all possible ways. But when we “observe the ruliad” we’re effectively “paying attention to” only particular aspects of it. Some of that “paying attention” we can conveniently describe in terms of our particular “location in the ruliad”. But some is more naturally described by thinking about equivalence classes in the ruliad.
Given two states that exist in the ruliad, we have to ask whether as observers we want to consider them distinct, or whether we want to conflate them, and consider them “the same”. When we discussed the construction of the ruliad, we already had many versions of this issue. Indeed, whenever we said that two paths in the ruliad “merge”, that’s really just saying that we treat the outcomes as equivalent.
“Viewed from the outside”, one could imagine that absolutely nothing is equivalent. Two hypergraphs produced in two different ways (and thus, perhaps, with differently labeled nodes) are “from the outside” in some sense different. But “viewed from the inside”, they pretty much have to be viewed as “the same”, in essence because all their effects will be the same. But at some level, even such conflation of differently labeled hypergraphs can be thought of as an “act of the observer”; something that one can only see works that way if one’s “observing it from inside the system”.
But all the way through our description of the observer, it’s very much the same story: it’s a question of what should be considered equivalent to what. In sequentializing time, we’re effectively saying that “all of space” (or “all of branchial space”, or rulial space) should be considered “equivalent”. There are many subtle issues of equivalence that also arise in the construction of states in the ruliad from underlying tokens, in defining what rules and initial conditions should be considered the same, and in many other places.
The ruliad is in some sense the most complicated constructible object. But if we as computationally bounded observers are going to perceive things about it, we have to find some way to “cut it down to size”. And we do that by defining equivalence classes, and then paying attention only to those whole classes, not all the details of what’s going on inside them. But a key point is that as computationally bounded observers who imagine a certain coherence in their experience, there are strong constraints on what kinds of equivalence classes we can use.
If we return again to the situation of molecules in a gas, we can say that we form equivalence classes in which we look only coarsely at the positions of molecules, in “buckets” defined by simple, bounded computations—and we don’t look at their finer details, with all the computational irreducibility they involve. And it’s because of this way of looking at the system that we conclude that it follows the Second Law of thermodynamics, exhibits fluid behavior, etc.
And it’s very much the same story with the ruliad—and with the laws of physics. If we constrain the kind of way that we observe—or “parse”—the ruliad, then it becomes inevitable that the effective laws we’ll see will have certain features, which turns out apparently to be exactly what’s needed to reproduce known laws of physics. The full ruliad is in a sense very wild; but as observers with certain characteristics, we see a much tamer version of it, and in fact what we see is capable of being described in terms of laws that we can largely write just in terms of existing mathematical constructs.
At the outset, we might have imagined that the ruliad would basically just serve as a kind of dictionary of possible universes—a “universe of all possible universes” in which each possible universe has different laws. But the ruliad is in a sense a much more complicated object. Rather than being a “dictionary” of possible separate universes, it is something that entangles together all possible universes. The Principle of Computational Equivalence implies a certain homogeneity to this entangled structure. But the crucial point is that we don’t “look at this structure from the outside”: we are instead observers embedded within the structure. And what we observe then depends on our characteristics. And it turns out that even very basic features of our consciousness and sensory apparatus in a sense inevitably lead to known laws of physics—and in a sense do so generically, independent of details of just where in rulial space we are, or exactly what slice of the ruliad we take.
So far we’ve primarily talked about the ruliad in terms of physics and the fundamental structure of our physical universe. But the ruliad is actually something still more general than that. Because ultimately it is just created from the abstract concept of following all possible computational rules. And, yes, we can interpret these rules as representing things going on in our universe. But we can also interpret them as representing things going on in some other, less immediately physically realizable system. Or, for that matter, representing something purely formal, and, say, mathematical.
This way of talking about the ruliad might make one think that it should be “considered a possible model” for our universe, or for other things. But the bizarre and surprising point is that it is more than that. It’s not just a possible model that might be one of many. Rather, it is the unique ultimate representation of all possible models, entangled together. As we’ve discussed, there are many subtle choices about how we observe the ruliad. But the ultimate ruliad itself is a unique thing, with no choice about what it is.
As I’ve discussed at more length elsewhere, the ruliad is in a sense a representation all possible necessary truths—a formal object whose structure is an inevitable consequence of the very notion of formalization. So how does this relate to the idea that the ruliad also at an ultimate level represents our physical universe? What I’ve argued elsewhere is that it means that the ultimate structure of our universe is a formal necessity. In other words, it’s a matter of formal necessity that the universe must exist, and have an ultimate ruliad structure. The fact that we perceive the universe to operate in a certain way—with our standard laws of physics, for example—is then a consequence of the particular way observers like us perceive it, which in turn depends on things like where in rulial space we happen to find ourselves.
But beyond physics, what else might the ruliad represent? The ruliad is an ultimate example of multicomputation, and of what I’ve characterized as the fourth major paradigm for theoretical science. Often in multicomputation, what’s of interest is multiway systems with specific underlying rules. And already at this level, much of the apparatus that we’ve described in connection with the ruliad also applies—and in a sense “trickles down” to give various universal results.
But there are also definitely cases of multicomputation (other than physics) where the full notion of applying all possible rules is relevant. The global structures of metamathematics, economics, linguistics and evolutionary biology seem likely to provide examples—and in each case we can expect that at the core is the ruliad, with its unique structure. Of course, this doesn’t mean that what we observe must always be the same, because what we observe depends on our characteristics as an observer—and the characteristics of “being an observer” in metamathematics, for example, are surely different from those for economics or evolutionary biology, or, for that matter, physics.
For sure, the “sensory apparatus” that we effectively use is different in different cases. But there are certain similar humanbased features that still seem to apply. Whatever the domain, we always act as computationally bounded observers. And it seems that we also always have a certain coherence, consistently maintaining our “observerhood” through time or across some form of space. And it seems likely that these “humaninduced” characteristics alone are sufficient to yield some very global implications for observed behavior.
How should we think about the ruliad mathematically? In many ways, the ruliad is more an object of metamathematics than of mathematics itself. For in talking about the effects of all possible rules, it in a sense transcends individual mathematical theories—to describe a kind of metatheory of all possible theories.
Given a particular mathematical axiom system, it’s rather easy to see correspondence with a multiway system. There are a variety of ways to set it up, but one approach is to think of states in the multiway system as being expressions in the language used for the axiom system, and then to think of rules in the multiway system as applying transformations on these expressions that implement axioms in the axiom system.
For example, with the (Abelian semigroup) axioms
✕

here’s a multiway system generated from the expression by applying the (twoway) transformations defined by the axioms in all possible ways to each expression:
✕

But now from this graph we can read off the “theorem”:
✕

A proof of this theorem
✕

is just a path in the multiway graph:
✕

A significantly less direct but still perfectly valid proof would correspond to the 13step path:
✕

It’s a slightly technical point, but perhaps worth mentioning that there are alternative ways to set up the correspondence between axiomatic mathematical systems and multiway systems. One such way is to take the states in the multiway system to be not expressions (like ) but whole propositions (like ). Axioms then show up as states, and the rules for the multiway system are “rules of inference” or “rules of entailment” that define how, say, pairs of propositions “entail” (or “imply”) other ones. (And, yes, this requires a generalized multiway system with not just 1 state → many states, but for example 2 states → 1 state.) Typical automated theorem provers (like FindEquationalProof) operate in this kind of setup, attempting to find paths that lead from initial propositions and axioms to some final state that corresponds to an “obviously true” proposition, like .
But whatever the detailed setup, the basic picture is that an axiomatic mathematical system has an associated multiway graph, in which paths correspond to proofs. Given the rules for the multiway system, there is in general no way to guarantee that the path (if it exists) corresponding to the proof of some particular result will be of bounded length, leading to the possibility of undecidability. But even when a path exists, it may require an irreducibly large amount of computation to find it. Still, finding such paths is what automated theorem provers do. For example, we know (as I discovered in 2000) that ((b · c) · a) · (b · ((b · a) · b)) = a is the minimal axiom system for Boolean algebra, because FindEquationalProof finds a path that proves it.
But this path—and the corresponding proof—is a very “nonhuman” construct (and, for example, in 21 years essentially no progress has been made in finding a “humanunderstandable narrative” for it). And we can make an analogy here to the situation in physics. The individual rule applications in the multiway graph (or the proof) are like individual updating events applied to the atoms of space—and they show all kinds of complexity and computational irreducibility. But in physics, human observers work at a higher level. And the same, one suspects, is true in mathematics.
Rather than looking at every detail of the multiway graph, human “mathematical observers” (i.e. pure mathematicians) in effect define all sorts of equivalences that conflate together different parts of the graph. If the individual updates in the multiway graph are like molecular dynamics, human pure mathematics seems to operate much more at the “fluid dynamics level”, concentrating on “broad mathematical constructs”, not the “machine code” of specific lowlevel axiomatic representations. (Of course, there are some situations, for example related to undecidability, where the “molecular dynamics” effectively “breaks through”.)
We’ve outlined above (and discussed at length elsewhere) how physical observers like us “parse” the lowlevel structure of the physical universe (and the ruliad). How might mathematical observers do it? A large part has to do with the identification of equivalences. And the key idea is that things which are considered equivalent should be assumed to be “the same”, and therefore “conflated for mathematical purposes”.
The most elementary example of something like this is the statement (already present in Euclid) that if and , then . The extensionality axiom of set theory is a more sophisticated example. And the univalence axiom of homotopy type theory is perhaps the most sophisticated current version.
There’s a very operational version of this that appears in automated theorem proving. Imagine that you’ve proved that and . Then (by the assumed properties of equality) it follows that . One way we could use this result is just to merge the nodes for and . But a “bigger” thing we can do is to add the “completion” as a general rule for generating the multiway system.
Consider, for example, the string substitution multiway system A ↔ AB:
✕

But notice here that both ABA ↔ ABBA and ABA ↔ ABAB. So now add the “completion” ABBA ↔ ABAB. Here’s the resulting multiway graph:
✕

Adding the completion has generated lots of new “direct equivalences”. But we can also think of it as having done something else: not only has it defined equivalences between states; it’s also defined equivalences between paths—or in effect between proofs. (Or, put another way, it’s implementing homotopic equivalence between proofs. By the way, it’s an important feature of human mathematics that progress is typically measured in theorems proved; different proofs of the same theorem are normally implicitly considered equivalent in terms of the progress of mathematics.)
In a category theory interpretation, transformations between states in the original multiway graph are like ordinary morphisms (1morphisms). But when we’re making transformations between “proof paths”, this is like 2morphisms. And just as we can add transformations between proofs, we can also add transformations between proofsbetweenproofs, and so on. The result is that we can build up a whole hierarchy of higher and higher categories, eventually ending with an ∞category.
But now we can begin to see the connection with the ruliad. The ruliad is in a sense the result of taking the limit of adding more and more possible rules. Above we did this quite explicitly in terms of the original underlying rules, for example by enumerating possible strings or possible integer multipliers.
But we can view successive completions as doing something very similar. Yes, the rules are enumerated in a different order. But in the end there’ll still be an infinite number of distinct rules being used.
Of course there are many mathematical details missing here. But in broad outline, it seems that one can think of the approach to the ruliad as some kind of limit of successively higher categories. But this limit is something that’s been studied (albeit in the upper reaches of pure mathematics), and it’s an object called the ∞groupoid. (It’s a groupoid because when all the rules are included things inevitably “go both ways”). So, OK, is the ruliad “just” the ∞groupoid? Not quite. Because there are more rules and more initial conditions in the ruliad, even beyond those added by completions. And in the end the ruliad actually seems to be the ∞category of ∞groupoids, or what’s called the (∞,1)category.
But knowing that the ruliad can be thought of as composed of ∞groupoids means that we can apply mathematical ideas about the ∞groupoid to the ruliad.
Probably the most important is Grothendieck’s hypothesis, which asserts that the ∞groupoid inevitably has a topological and (with a few other conditions) ultimately geometric structure. In other words, even though one might have imagined that one constructed the ∞groupoid from “pure logic” (or from pure formal axiomatic structures), the assertion is that the limiting object one obtains inevitably exhibits some kind of geometrical or “spatial” structure.
Viewed in terms of the ruliad—and our explicit finite examples of it—this might not seem surprising. And indeed in our Physics Project, the whole concept of the emergence of space from largescale hypergraphs is closely related. But here from Grothendieck’s hypothesis we’re basically seeing a general claim that the ruliad must have “inevitable geometry”—and we can then view things like the emergence of space in our Physics Project as a kind of “trickle down” from results about the ruliad. (And in general, a big “application” of geometrical structure is the possibility of “pure motion”.)
What does all this mean about the ruliad and mathematics? In a sense the ruliad represents all possible mathematics—the application of all possible rules, corresponding to all possible axiom systems. And from this “ultimate metamathematics”, human “mathematical observers” are sampling pieces that correspond to the pure mathematics they consider of interest.
Perhaps these will align with particular axiom systems of the kind automated theorem provers (or proof assistants) use. But things may be “sloppier” than that, with human mathematical observers effectively being extended in rulial space—and capable of making “fluiddynamicslevel” conclusions, even if not “moleculardynamicslevel” ones.
But a key (and in some ways very surprising) point is that the ruliad can be viewed as the basis of both physics and mathematics. In some sense, physics and mathematics are at their core the same thing. They only “appear different” to us because they way we “observe” them is different.
I plan to discuss the implications for mathematics at greater length elsewhere. But suffice it to say here that the existence of a common underlying core—namely the ruliad—for both physics and mathematics immediately allows one to start importing powerful results from physics into mathematics, and vice versa. It also allows one, as I have done elsewhere, to start comparing the existence of the universe with the (Platonicstyle) concept of the fundamental existence of mathematics.
The ruliad can be thought of as an encapsulation of doing all possible computations in all possible ways. What we might think of as a “single computation” might consist of repeatedly applying the rules for a Turing machine to “deterministically” generate a sequence of computational steps:
✕

But one can also consider a “multicomputational” system, in which rules can generate multiple states, and the whole evolution of the system can be represented by a multiway graph:
✕

In traditional computation theory, one talks about rules like these as “nondeterministic”, because they can have multiple outcomes—though one usually imagines that the final answer one wants from a computation can be found as the result of some particular path. (In what I now call the multicomputational paradigm—that I believe is important for modeling in physics and other places—one instead considers the complete multiway graph of entangled possible histories.)
In constructing the ruliad, one is in a sense going to a more extreme version of multicomputation, in which one uses not just a particular rule with multiple outcomes, but all possible rules. In effect, the concept is to use “maximal nondeterminism”, and at each step to independently “pick whatever rule one wants”, tracing out a rulial multiway system that includes all the different possible paths this generates.
For the kind of Turing machines illustrated above, the rulial multiway graph one gets after one step is:
✕

After 2 steps the result is:
✕

The full ruliad is then some kind of infinite limit of this process. But as before, there’s lots of subtlety in how this limit is taken. But we can at least characterize some ways of approaching it using ideas from computational complexity theory. Increasing the number of steps of evolution is like increasing the time complexity one allows. Increasing the “size of states” (e.g. the width of nonzero Turing machine tape) that one includes is like increasing the space complexity one allows. And increasing the complexity of the rule (as measured in the number of bits needed to specify it) is like increasing the algorithmic complexity one allows. The ruliad is what is obtained by taking all these computational resource measures to infinity.
And a critical claim is that regardless of how this is done, the final ruliad construct one gets will always—at least in some sense—be the same. There will be many ways to coordinatize it, or to sample it, but the claim is that it’s always the same object that one’s dealing with. And ultimately the reason for this is the Principle of Computational Equivalence. Because it implies that whatever “computational parametrization” or “computational description language” one uses for the ruliad, one will almost always get something that can be viewed as “computationally equivalent”.
We’ve talked about building up the ruliad using Turing machines. But what about other models of computation—like cellular automata or register machines or lambda calculus? As soon as there’s computation universality we know that we’ll get results that are at least in principle equivalent, because in a sense there’s only a “finite translation cost” associated with setting up an interpreter from one model of computation to another. Or, put another way, we can always emulate the application of the rule for one system by just a finite number of rule applications for the other system.
But from computation universality alone we have no guarantee that there won’t be “extreme deformations” introduced by this deformation. What the Principle of Computational Equivalence says, however, is that almost always the deformations won’t have to be extreme. And indeed we can expect that particularly when multiple rules are involved, there’ll be rapid convergence almost always to a kind of “uniform equivalence” that ensures that the final structure of the ruliad is always the same.
But the Principle of Computational Equivalence appears to say still more about the ruliad: it says that not only will the ruliad be the same independent of the “computational basis” used to construct it, but also that there’ll be a certain uniformity across the ruliad. Different “regions of the ruliad” might involve different specific rules or different patterns of their application. But the Principle of Computational Equivalence implies that almost always the computations that happen will be equivalent, so that—at least at a certain scale—the structure associated with them will also be equivalent.
Knowing that the ruliad contains so many different computations, one might imagine that it would show no particular uniformity or homogeneity. But the Principle of Computational Equivalence seems to imply that it necessarily does, and moreover that there must be a certain coherence to its structure—that one can interpret (in the style of Grothendieck’s hypothesis) as an inevitable emergent geometry.
An individual computation corresponds to a path in the ruliad, going from its “input state” to its “output state”. In an ordinary deterministic computation, the path is restricted to always use the same rule at each step. In a nondeterministic computation, there can be different rules at different steps. But now we can formulate things like the P vs. NP problem essentially in terms of the geometry of the ruliad.
Here’s a picture of the same finite Turingmachinebased approximation to the ruliad as above—but now with the paths that correspond to deterministic Turing machine computations marked in red:
✕

The P vs. NP problem basically asks roughly whether the deterministic computations (shown here in red) will eventually “fill the ruliad”, or whether the general nondeterministic computations that are part of the ruliad will always “reach further”. Once again, there are many complicated and subtle issues here. But it’s interesting to see how something like the P vs. NP problem might play out in the ruliad.
In physics (and mathematics), we as human observers tend to sample the ruliad in a coarsegrained way, “noticing” only certain aspects of it. So is there an analog of this in computation theory—perhaps associated with certain characteristics of the “computationtheoretic observer”? There’s a potential answer, rather similar to what we’ve already seen in both physics and mathematics.
The basic point is that in computation theory we tend to study classes of computations (say P or NP) rather than individual computations. And in doing this we are in a sense always conflating many different possible inputs and possible outputs—which we assume we do in a computationally bounded way (e.g. through polynomialtime transformations, etc.)
Another thing is that we tend to focus more on the “experience of the end user” than the detailed activities of the “programmer”. In other words, we’re concerned more with what computational results are obtained, with what computational resources, rather than on the details of the program constructed to achieve this. Or, put another way, we tend to think about computation in terms of things like the successive evaluation of functions—and we conflate the different paths by which this is achieved.
Most likely this means that there are “effective laws” that can be derived in this computational view of the ruliad, analogous to laws of physics like general relativity. So what might some other analogies be?
A computation, as we’ve mentioned, corresponds to a path in the ruliad. And whenever there’s a possibility for an infinite path in the ruliad, this is a sign of undecidability: that there may be no finite way to determine whether a computation can reach a particular result. But what about cases when many paths converge to a point at which no further rules apply, or effectively “time stops”? This is the analog of a spacelike singularity—or a black hole—in the ruliad. And in terms of computation theory, it corresponds to something decidable: every computation one does will get to a result in finite time.
One can start asking questions like: What is the density of black holes in rulial space? If we construct the ruliad using Turing machines, this is basically analogous to asking “What’s the density of halting Turing machines (+initial conditions) in rulial space?” And this is essentially given by Chaitin’s Ω.
But so is there some number Ω that we can just compute for the ruliad? Well, actually, no. Because the undecidability of the halting problem makes Ω noncomputable. One can get approximations to it, but—in the language of the ruliad—those will correspond to using particular samplings or particular reference frames. Or in other words, even the perceived density of “decidability black holes” in the ruliad depends on features of the observer.
In our Physics Project we usually talk of the universe “evolving through time” (albeit with many entangled threads of history). But if the ruliad and its structure is a matter of formal necessity, doesn’t that mean that the whole ruliad effectively “already exists”—“outside of time”? Well, in some sense it does. But ultimately that would only be relevant to us if we could “look at the ruliad from the outside”.
And as observers like us within the ruliad, we necessarily have a different perception. Because our consciousness—with its computational boundedness—only gets to sample a certain sequence of pieces of the ruliad. If it were not for computational irreducibility, we might get to “jump around” in time. But computational irreducibility, together with our own computational boundedness, implies that our perception must necessarily just experience the passage of time through an irreducible process of computation.
In other words, while in some sense the ruliad may all “already be there” when viewed from the outside, our own perception of it “from the inside” is necessarily a progressive one, that effectively corresponds to the passage of time.
Could we experience the ruliad differently, even while being computationally bounded? If we think of the ruliad as a graph, then our usual “sequence of configurations of space at successive times” way of experiencing the ruliad is like a breadthfirst traversal. But could we for example instead do a depthfirst traversal, exploring all time before investigating different parts of space? (And, yes, something like this can happen in general relativity near an event horizon, or in connection with timelike singularities.)
Later, we’ll discuss different ways to perceive the ruliad and the universe. But it seems to be a feature of anything we might call a coherent observer that there needs to be some form of progression in the perception. And so while we might not call it the passage of time, there’ll still be some way in which our exploration of the ruliad has a computationally irreducible process underneath.
A very important claim about the ruliad is that it’s unique. Yes, it can be coordinatized and sampled in different ways. But ultimately there’s only one ruliad. And we can trace the argument for this to the Principle of Computational Equivalence. In essence there’s only one ruliad because the Principle of Computational Equivalence says that almost all rules lead to computations that are equivalent. In other words, the Principle of Computational Equivalence tells us that there’s only one ultimate equivalence class for computations.
But what if we just imagine a “hypercomputation” not in that class? For example, imagine a hypercomputation (analogous, for example, to an oracle for a Turing machine) that in a finite number of steps will give us the result from an infinite number of steps of a computationally irreducible process. Such a hypercomputation isn’t part of our usual ruliad. But we could still formally imagine a hyperruliad that includes it—and indeed we could imagine a whole infinite hierarchy of successively larger and more powerful hyperruliads.
But it’s a fundamental claim that we’re making—that can be thought of as a matter of natural science—that in our universe only computation can occur, not hypercomputation.
At a purely formal level, there’s nothing wrong with hyperruliads. They exist as a matter of formal necessity just like the ordinary ruliad does. But the key point is that an observer embedded within the ruliad can never perceive a hyperruliad. As a matter of formal necessity there is, in a sense, a permanent event horizon that prevents anything from any hyperruliad from affecting anything in the ordinary ruliad.
So now we can be a bit more precise about our statement that “hypercomputation doesn’t happen in our universe”. Really we should say that we assert that we as observers operate purely computationally and not hypercomputationally. And this means that we are embedded within the ordinary ruliad, and not the hyperruliad.
Yes, we could imagine some other entity that’s embedded within the hyperruliad, and perceives what it considers to be the universe to operate hypercomputationally. But in a statement that’s in a sense more “about us” than “about the universe”, we assert that that can’t be us, and that we in a sense live purely within the ruliad—which means that for us the Principle of Computational Equivalence holds, and we perceive only computation, not hypercomputation.
What observers can there be embedded in the ruliad, and how should we characterize them? In physical spacetime we’re used to characterizing observers by their locations in physical space and by things like the spacetime reference frames they construct. And it’s very much the same for observers in the ruliad: we can characterize them by where they are in rulial space, and what rulial reference frames they use.
The Principle of Computational Equivalence tells us that it’s almost always possible to “encode” one “model of how the ruliad works” in any other model—effectively just by setting up a program that emulates the rules for one model using the rules for the other model. But we can think of these different models as being associated with different possible observers in the ruliad.
In other words, we can say that observers “at different places in rulial space” (or “using different rulial reference frames”) are using different description languages for what’s happening in the ruliad. And when an observer “moves” in rulial space, they’re effectively doing a translation from one description language to another. (And, yes, there’s a maximum rate of motion ρ in rulial space—which is the rulial analog of the speed of light—and which is effectively determined by the fundamental processing speed of the universe.)
So far this might all seem quite abstract. But there are immediate, everyday examples that effectively correspond to being at different places in rulial space. A simple concrete one is computers with different instruction sets. Another one is different brains with different consciousnesses.
We can think of a single human consciousness as having a certain thread of experience of the universe. Part of that experience is determined by the physical location of the consciousness and by the sensory apparatus with which it samples the world. But part is determined by the “internal description language” that it uses. And inevitably this internal description language depends both on the detailed physiology of the brain in which it is implemented, and on the past history of experiences that have “defined its way of looking at the world”. In the analogy of artificial neural networks, different networks will tend to have different “internal representations” because this depends not only on the network architecture, but also on the particular training data that the network has “experienced”.
Why can’t one human consciousness “get inside” another? It’s not just a matter of separation in physical space. It’s also that the different consciousnesses—in particular by virtue of their different histories—are inevitably at different locations in rulial space. In principle they could be brought together; but this would require not just motion in physical space, but also motion in rulial space.
But why then do different consciousnesses seem to have compatible views about “what happens in the universe”? Essentially this can be seen as a consequence of rulial relativity—which in turn depends on the inevitable causal invariance of the ruliad, which follows from the Principle of Computational Equivalence. There are certainly many issues to be worked out, but basically what seems to be going on is that because of causal invariance, different rulial reference frames will ultimately yield the same rulial multiway causal graphs, and therefore the same “fundamental description of reality”.
We’ve talked about different consciousnesses. But what about just “different ways of thinking”? Well, it’s definitely more than an analogy to say that different ways of thinking correspond to different positions in rulial space. If there’s lots of common history then there’ll be common ancestry in the rulial multiway graph and one will necessarily end up close in rulial space. But without common history, one can end up with different description languages—or different ways of thinking—that are not nearby in rulial space.
In physical space we expect to effectively use momentum to move our location. And it’s potentially a bizarrely similar story in rulial space. In our models of fundamental physics, energy and momentum are essentially related to the density of activity (i.e. elementary updating events) in physical space. And we can similarly define a rulial analog of energy and momentum in terms of activity in rulial space. But it’s exactly this activity that provides connections between different parts of rulial space, or in effect “enables motion” in rulial space.
In other words, if you want to move in rulial space, you can do it by putting in the appropriate computational work to change your conceptual point of view (or, essentially equivalently, your language for describing things). So what about curvature (or the analog of gravity) in rulial space—say generated through an analog of Einstein’s equations from density of activity in rulial space? Presumably this relates to the difficulty—or time it takes—to get from one place in rulial space, and one way of thinking, to another. And conceivably things like “paradigm shifts” between different ways of thinking might be associated with features of rulial space like event horizons.
But let’s say you’re at one place in rulial space, and you want to get to another—or at least “send a signal” there. A typical microscopic change at one point in rulial space will tend to just to “spread out in all directions” and “decay quickly”. But if you want to “coherently communicate”, you need some kind of structure that will persist as it propagates through rulial space. And by analogy with the case of physical space, what this presumably means is that you effectively need a “rulial particle”.
In terms of the ruliad, a rulial particle would presumably be some kind of “topological obstruction” or “topologically stable structure” that is at any moment effectively localized in rulial space and maintains its identity as it propagates across rulial space. But what might a rulial particle be in more everyday terms?
Potentially it’s like what we’d normally consider a concept—or something to which we might assign a word in human language. If we have ways of thinking—or consciousnesses—whose details are different, the issue is what will be robust enough to be able to be transported between them. And what everyday experience seems to suggest is that the answer is concepts. Even though one might have a slightly different way of thinking, what one calls “a fish” (or essentially, the concept of a fish) is something that can still robustly be communicated.
It’s interesting to notice that for an observer like us, there seem to be only a finite set of types of “elementary particles” that exist in physical space. And perhaps that’s not unrelated to the fact that observers like us also seem to imagine that there are in some sense only a finite number of “basic concepts” (associated, say, with distinct words in human languages). There’s lots more detail that exists in rulial space—or in the ruliad—but for observers like us, with our type of way of sampling the ruliad, these might be core coherent structures that we perceive.
The concept of the ruliad arose from our efforts to find a fundamental theory of physics. But now that we know about the ruliad, what does it tell us about a fundamental theory?
At the outset, we might have imagined that the end point of our project would be the identification of some particular rule of which we could say “This is the rule for the universe”. But of course then we’d be faced with the question: “Why that rule, and not another?” And perhaps we would imagine just having to say “That’s something that you have to go beyond science to answer”.
But the ruliad implies a quite different—and in my view ultimately much more satisfying—picture. The ruliad itself is a construct of abstract necessity—that in a sense represents the entangled behavior of all possible rules for the universe. But instead of imagining that some particular rule out of all these possibilities is “picked from outside” as “the choice for our universe”, what we suppose is that—as observers embedded within the ruliad—we’re the ones who are implicitly picking the rule by virtue of how we sample and perceive the ruliad.
At first this might seem like it’s a wimp out. We want to know how our universe works. Yet we seem to be saying “we just pick whatever rule we feel like”. But that’s not really the story at all. Because in fact observers that are even vaguely like us are in effect deeply constrained in what rules they can attribute to the universe. There’s still some freedom, but a fundamental result is that for observers like us it seems to be basically inevitable that any rule we can pick will on a large scale reproduce the central known general laws of physics, in particular general relativity and quantum mechanics.
In other words, for observers generally like us it’s a matter of abstract necessity that we must observe general laws of physics that are the ones we know. But what about more specific things, like the particular spectrum of elementary particles, or the particular distribution of matter in the universe? It’s not clear how far “the general” goes—in other words, what is a matter of abstract necessity purely from the structure of the ruliad and general feature of observers like us.
But inevitably at some point we will run out of “the general”. And then we’ll be down to specifics. So where do those specifics enter? Ultimately they must be determined by the details of how we sample the ruliad. And a prominent part of that is simply: Where in the ruliad are we? We can ask that about our location in physical space. And we can also ask it about our location in rulial space.
What does all this mean? At some level it’s saying that the way we are as observers is what makes us attribute certain rules to our universe. The ruliad is in a sense the only thing that fundamentally exists—and in fact its existence is a matter of abstract necessity. And our universe as we experience it is some “slice of the ruliad”, with what slice it is being determined by what we’re like as observers.
Let’s look at the logical structure of what we’re saying. First, we’re describing the ruliad, which at the outset doesn’t have anything specifically to do with physics: it’s just a formal construct whose structure is a matter of abstract necessity, and which relates as much to mathematics as it does to physics. But what “puts the physics in” is that we in effect “live in the ruliad”, and our perception of everything is based on “experiencing the ruliad”. But that experience—and the effective laws of physics it entails—inevitably depends on “where we are in the ruliad” and how we’re able to sample it.
And this is where our pieces of “falsifiable natural science” come in. The first “assertion of natural science” that we make is that we are embedded only within the ordinary ruliad, and not a hyperruliad—or in other words that our experience encompasses only computation, and not hypercomputation.
This is closely related to a second assertion, which may in fact be considered to subsume this: that we are computationally bounded observers, or, in other words, that our processes of perception involve bounded computation. Relative to the whole ruliad—and all the computation it entails—we’re asserting that we as observers occupy only a tiny part.
There’s one more assertion as well, again related to computational boundedness: that we as observers have a certain coherence or persistence. In general the ruliad contains all sorts of wild and computationally irreducible behavior. But what we’re asserting is that that part of the ruliad that is associated with us as observers has a certain simplicity or computational reducibility: and that as we evolve through time or move in space, we somehow maintain our identity.
These assertions seem very general, and in some ways almost selfevident—at least as they apply to us. But the important and surprising discovery is that they alone seem to lead us inexorably to crucial features of physics as we know it.
Where does this physics “come from”? It comes partly from the formal structure of the ruliad, and formal features of the multicomputational processes it involves. And it comes partly from the nature of us as observers. So if we ask “Why is the physics of our universe the way it is?”, an important part of the answer is “Because we observe the universe the way we do”.
One might imagine that in some sense physics would give us no choice about how we observe the universe. But that’s not the case. Because in the end our “observation” of the universe is about the “abstract conceptual model” we build up for universe. And, yes, that’s certainly informed by the particular sensory apparatus we have, and so on. But it’s something we can certainly imagine being different.
We can think of ourselves as using some particular description language for the universe. The structure of that language is constrained by the assertions we gave above. But within such a description language, the laws of physics necessarily work out the way they do. But if we chose a different description language, we’d end up with different laws of physics.
Much of our perception of the universe is based on our raw biological structure—the way our sensory organs (like our eyes) work, as well as the way our brains integrate the inputs we get. But that’s not all there is to it. There’s also a certain base of knowledge in our civilization that informs how we parse our “raw perception”—and in effect what description language we use. Once we have the idea of periodic behavior, say, we can use it to describe things that we’d previously have to talk about in a less “economical” way.
But what if our knowledge changed? Or we had different sensory capabilities? Or we used technology to integrate our sensory input in different ways? Then we’d be able to perceive and describe the universe in different ways.
One’s first impression might be that the ruliad effectively contains many possible “parallel universes”, and that we have selected ourselves into one of these, perhaps as a result of our particular characteristics. But in fact the ruliad isn’t about about “parallel universes”, it’s about universes that are entangled at the finest possible level. And an important consequence of this is that it means we’re not “stuck in a particular parallel universe”. Instead, we can expect that by somehow “changing our point of view”, we can effectively find ourselves in a “different universe”.
Put another way, a given description of the universe is roughly represented by being at a certain location in rulial space. But it’s possible to move in rulial space—and end up with a different description, and different effective laws for the universe.
But how difficult is motion in rulial space? It could be that some impressive future technology would allow us to “move far enough” to end up with significantly different laws of physics. But it seems more likely that we’d be able to move only comparatively little—and never be able to “escape the box” of things like computational boundedness, and coherence of the observer.
Of course, even changing a little might lead us to different detailed laws of physics—say attributing a different mass to the electron, or a different value of the electromagnetic coupling constant α. But actually, even in traditional physics, this is already something that happens. When viewed at different energy scales—or in a sense with different technology—these quantities have different effective values (as characterized by the renormalization group).
At first it might seem a little strange to say that as our knowledge or technology change, the laws of physics change. But the whole point is that it’s really our perceived laws of physics. At the level of the raw ruliad there aren’t definite laws of physics. It’s only when we “sample our slice” of the ruliad that we perceive definite laws.
What does all this mean operationally for the search for a fundamental theory of physics? At some level we could just point to the ruliad and declare victory. But this certainly wouldn’t give us specific predictions about the particulars of our perceived universe. To get that we have to go further—and we have to be able to say something about what “slice of the ruliad” we’re dealing with. But the good news is that we don’t seem to have to make many assumptions about ourselves as observers to be able to identify many physical laws that observers like us should perceive.
So can we ever expect to nail down a single, specific rule for the universe, say one a particular observer would attribute to it? Given our characteristics as observers, the answer is undoubtedly no. We’re simply not that small in rulial space. But we’re not that big, either. And, importantly, we’re small enough that we can expect to “do science” and consider the universe to “behave in definite ways”. But just as in physical space we’re vastly larger than the scale associated with the atoms of space, so similarly we’re also undoubtedly vastly larger in rulial space than the individual components of the ruliad—so we can’t expect our experience to all be “concentrated in one thread” of the ruliad, following one particular rule.
As we discussed above, by doing experiments we can use scientific inference to attempt to localize ourselves in rulial space. But we won’t be able to do enough to say “from our point of view, the universe is operating according to this one specific rule, and not another”. Instead, there’ll be a whole collection of rules that are “good enough”, in the sense that they’ll be sufficient to predict the results of experiments we can realistically do.
People have often imagined that, try as we might, we’d never be able to “get to the bottom of physics” and find a specific rule for our universe. And in a sense our inability to localize ourselves in rulial space supports this intuition. But what our Physics Project seems to rather dramatically suggest is that we can “get close enough” in rulial space to have vast predictive power about how our universe must work, or at least how observers like us must perceive it to work.
We’ve discussed how “observers like us” will necessarily “parse the ruliad” in ways that make us perceive the universe to follow the laws of physics as we know them. But how different could things get? We have a definite sense of what constitutes a “reasonable observer” based on our 21stcentury human experience—and in particular our biology, our technology and our ways of thinking.
But what other kinds of observers can we imagine? What about, for example, animals other than humans—in particular say ones whose sensory experience emphasizes olfaction or echolocation or fluid motion? We can think of such animals as operating in a different rulial reference frame or at a different place in rulial space. But how far away in rulial space will they be? How similar or not will their “world views” (and perceived laws of physics) be to ours? It’s hard to know. Presumably our basic assertions about computational boundedness and coherence still apply. But just how the specifics of something like sequentialization in time play out, say, for an ant colony, seems quite unclear.
Maybe one day we’ll be able to systematically “think like other animals”. But as of now we haven’t been able to “travel that far” in rulial space. We’ve quite thoroughly explored physical space, say on the surface of our planet, but we haven’t explored very far at all in rulial space. We don’t have a way to translate our thinking into some kind of “thinking differently”—and we don’t, for example, have a common language to get there.
There’s often an assumption (a kind of “human exceptionalism”) that if it wasn’t for details of the human experience—like brains and words—then we’d necessarily be dealing with something fundamentally simpler, that could not, for example, show features that we might identify as intelligence. But the Principle of Computational Equivalence tells us this isn’t correct. Because it says that there’s a certain maximal computational sophistication that’s achieved not just by us humans but also by a vast range of other systems. The restrictions of what we’ve chosen to study (in science and elsewhere) have often made us miss this, but in fact computational sophistication—and the direct generalization of our notion of intelligence that’s associated with it—seems quite ubiquitous across many different kinds of systems.
So can those other kinds of systems act as “observers like us”? To do so, they need not just computational sophistication, but also a certain alignment with the features we have that lead to our coherent thread of “conscious experience”. And even given that, to actually “connect with” such systems, we need to be able to reach far enough in rulial space to sufficiently make a translation.
Imagine the weather (sometimes said to “have a mind of its own”). It’s got plenty of computational sophistication. But is there any sense in which it sequentializes time like we do? Or can one only think of all those different parts of our atmosphere “running in their own time”? To know things like this, we effectively have to have a way to “translate” from the operation of the weather to our (current) way of thinking.
And in some sense we can consider the whole enterprise of natural science as being an effort to find a method of translation—or a common language—between nature and our way of thinking.
We as observers in effect trace out particular trajectories in rulial space; the challenge of natural science is to “reach out” in rulial space and “pull in” more of the ruliad; to be able to define a way to translate more parts of the ruliad to our processes of thinking. Every time we do an experiment, we can think of this as representing a moment of “connection” or “communication” between us and some aspect of nature. The experiment in effect defines a small piece of “common history” between us and nature—which helps “knit together” the parts of rulial space associated with us and with nature.
One of the great mysteries of science has been why—in the vastness of physical space—we’ve never detected something we identify as “alien intelligence”, or an “alien civilization”. We might have thought that it was because we humans have either achieved a unique pinnacle of intelligence or computational ability—or have fundamentally not gotten far enough. But the Principle of Computational Equivalence explodes the idea of this kind of cosmic computational pecking order.
So what could actually be going on? Thinking in terms of the ruliad suggests an answer. Our radio telescopes might be able to detect signals from far away in physical space. But our putative aliens might not only live far away in physical space, but also in rulial space.
Put another way, the “alien civilization” might be sampling aspects of the ruliad—and in effect the universe—that are utterly different from those we’re used to. That different sampling might be happening right down at the level of atoms of space, or it might be that the rulial distance from us to the aliens is small enough that there’s enough “shared description language” that the alien civilization might rise to the level of seeming like some kind of “noise” relative to our view of “what’s important in the universe”.
We might wonder how far apart what we could consider “alien civilizations” would be in physical space. But what we now realize is that we also have to consider how far apart they might be in rulial space. And just like in exploring physical space we can imagine building better spacecraft or better telescopes, so also we can imagine building better ways to reach across rulial space.
We’re so used to physical space that it seems to us very concrete to reach across it. Of course, in our Physics Project, things like motion in physical space end up—like everything else—being pure computational processes. And from this point of view, reaching across rulial space is ultimately no more abstract—even though today we would describe it in terms of “doing (abstract) computations” rather than “moving in space”.
Relative to our own physical size, the universe already seems like a vast place. But the full ruliad is even incredibly more vast. And we are likely much tinier in rulial space relative to the whole universe than we are in physical space. From the Principle of Computational Equivalence we can expect that there’s ultimately no lack of raw computational sophistication out there—but thinking in terms of the ruliad, the issue is whether what’s going on is close enough to us in rulial space that we can successfully see it as an “alien civilization”.
One test of rulial distance might be to ask whether our putative aliens perceive the same laws of physics for the universe that we do. We know that at least the general forms of those laws depend only on what seem to us rather loose conditions. But to get good alignment presumably requires at the very least that we and the aliens are somehow “comparable in size” not only in physical space (and branchial space), but also in rulial space.
It’s humbling how difficult it is to imagine the universe from the point of view of an alien at a different place in rulial space. But for example if the alien is big compared to us in rulial space, we can say that they’ll inevitably have a version of science that seems to us much “vaguer” than ours. Because if they maintain a coherent thread of experience, they’ll have to conflate more distant paths in rulial space, on which the universe will do things that are “more different” than what we’re used to. (And, yes, there should be rulial analogs of quantum phenomena, associated for example with conflated paths that diverge far in rulial space.)
What would it mean operationally for there to be an alien civilization perhaps nearby in physical space but at a distance in rulial space? Basically the alien civilization will be “operating” in features of the universe that our parsing of the universe just doesn’t pick up. As a simple analogy, our view of, for example, a box of gas might be that it’s something with a certain temperature and pressure. But a different “parsing” of that system might identify a whole world of detailed motions of molecules that with respect to that parsing can be viewed as a vast “alien civilization”. Of course, the situation is much more extreme when it comes to the whole ruliad, and all the paths of history and configurations of atoms of space that it represents.
Relative to the whole ruliad, our civilization and our experience have carved out an extremely tiny piece. And what we’re thinking of as “alien civilizations” might also have carved out their own tiny pieces. And while we’re all “living in the same ruliad”, we might no more be able to detect each other or communicate (and likely very much less) than we can across vast distances in physical space.
What of the future? The future of our civilization might well be a story of mapping out more of rulial space. If we continue to invent new technology, explore new ideas and generally broaden our ways of thinking and perceiving, we will gradually—albeit in tiny steps—map out more of rulial space. How far can we get? The ultimate limit is determined by the maximum rulial speed. But if we expect to maintain our character as “observers like us”, we’ll no doubt be limited to something much less.
Among other issues, moving in rulial space involves doing computation. (The ultimate scale is set by the “processing power” of the universe—which defines the maximum rulial speed.) But “density of computation” effectively corresponds to a generalized version of mass—and is for example a source of “generalized gravity”. And it could be that to “move any significant distance” in rulial space, we’d have to “experience enough generalized gravity” that we could never maintain things like the kind of coherence we need to be an “observer like us”.
Put another way: yes, it might in principle be possible to “reach out in rulial space” and “contact the rulial aliens”. But it might be that doing so would require us to be so different from the way we currently are that we wouldn’t recognize anything like consciousness or anything that really makes us “identifiably us”. And if this is so, we are in a sense limited to experiencing the ruliad “on our own” from our particular place in rulial space, forever isolated from “alien civilizations” elsewhere in rulial space.
What does the concept of the ruliad mean for the fundamental way we think about things like science? The typical conception of “what science does” is that it’s about us figuring out—as “objectively” as we can—how the world happens to be. But the concept of the ruliad in a sense turns this on its head.
Because it says that at some ultimate level, everything is a matter of abstract necessity. And it’s just our “parsing” of it that defines the subject matter of what we call science. We might have thought that the science of the universe was just something that’s “out there”. But what we’re realizing is that instead in some fundamental sense, it’s all “on us”.
But does that mean that there’s no “objective truth”, and nothing that can robustly be said about the universe without “passing it through us”? Well, no. Because what we’ve discovered through our Physics Project is that actually there are quite global things that can (“objectively”) be said about our universe and the laws it follows, as perceived by observers like us.
We don’t have to know in detail about us humans and the particular ways we perceive things. All we need are some general features—particularly that we are computationally bounded, and that we have a certain persistence and coherence. And this is all it takes to deduce some quite specific statements about how our universe operates, at least as we perceive it.
So in a sense what this means is that there is a large “zone of objectivity”; a large set of choices for how we could be that will still lead us to the same “objective truth” about our universe. But if we go far enough away in our mechanism for “parsing the ruliad”, this will no longer be the case. From our current vantage point, we’d no doubt then be hardpressed to recognize how we’re “doing the parsing”, but the results we’d get would no longer give us the same laws of physics or general perception of the universe that we’re used to.
This view of things has all sorts of implications for various longdiscussed philosophical issues. But it’s also a view that has precise scientific consequences. And these don’t just relate to physics. Because the ruliad is really a general object that represents the entangled behavior of all possible abstract rules. When we think of ourselves as observers embedded within this object, it means that for us things are actualized, and we have what we call physics. But we can also imagine sampling the ruliad in different ways.
Some of those ways correspond to mathematics (or metamathematics). Some correspond to theoretical computer science. The ruliad is the single object that underlies all of them. And which of them we’re talking about just depends on how we imagine we’re sampling or parsing the ruliad, and how we’re describing what we’re observing.
With this degree of generality and universality, it’s inevitable that ruliad must be a complicated object; in fact, in a sense it must encapsulate all possible achievable complexity. But what’s important is that we now have a definite concept of the ruliad, as something we can study and analyze.
It’s not simple to do this. The ruliad is at some level an object of great and perhaps supremely elegant abstract regularity. But for us to get any concrete handle on it and its structure, we need to break it down into some kind of “digestible slices” which inevitably lose much of its abstract regularity.
And we’re just at the beginning of seeing how best to “unpack” and “pick through” the ruliad. With explicit computations, we can only chip away at the very simplest approximations to the ruliad. In a sense it’s a tribute to the naturalness and inevitability of the ruliad that it’s so closely related to some the most advanced abstract mathematical methods we know so far. But again, even with these methods we’re barely scratching the surface of the ruliad and what it contains.
The theoretical exploration of the ruliad will be a long and difficult journey. But the incredible generality and universality of the ruliad means that every piece of progress is likely to have exceptionally powerful consequences. In some sense the exploration of the ruliad can be seen as the encapsulated expression of everything it means to do theoretical investigation: a kind of ultimately abstract limit of theoretical science and more.
For me, the ruliad in a sense builds on a tower of ideas, that include the computational paradigm in general, the exploration of the computational universe of simple programs, the Principle of Computational Equivalence, our Physics Project and the notion of multicomputation. But even with all of these it’s still a significant further jump in abstraction. And one whose consequences will take considerable time to unfold.
But for now it’s exciting to have at least been able to define this thing I call the ruliad, and to start seeing some of its unprecedentedly broad and deep implications.
As a very simple example of something like the ruliad, we can consider what we might call the “multiplicad”: a rulial multiway system based on integers, in which the rules simply multiply by successive integers:
✕

(Note that this kind of pure multiplication is presumably not computation universal, so the limiting object here will not be a coordinatization of the actual full ruliad.)
Just like with the full ruliad, there are many different “directions” in which to build up the multiplicad. We could allow as many multipliers and steps as we want, but limit the total size of numbers generated, here say to 30:
✕

As an alternative, we can limit the number of multipliers s, say to . Then the multiplicad would build up like this:
✕

In the pictures we’ve drawn so far, we’re effectively always deduplicating different occurrences of the same integer. So, for example, the integer 12 can be generated as 1 × 3 × 4 or 1 × 6 × 2 or 1 × 3 × 2 × 2, etc. And in principle we could show each of these “different 12s” separately. But in our deduplicated graph, only a single 12 appears—with the different possible decompositions of 12 being reflected in the presence of multiple paths that lead to the 12.
Sometimes the structure we get is richer—if much bigger—when we don’t immediately do deduplication. For example, if we allow any number of multipliers (i.e. take ) then after just 1 step we will get all integers—and if we do deduplication, then this will be the end of our graph, because we “already have all the integers”. But if we don’t do deduplication, we’ll get a slightly more complicated picture, that begins like this:
✕

The “topological” structure of this graph is now straightforward, but its “labeling” with numbers is less so—and if we ask, for example, where a particular number appears after t steps, this can be more complicated.
Imagine that we are looking only at the subtrees associated with up to s multipliers at the first step—or, equivalently, that we are looking at the rulial multiway system “truncated” with only s rules. Which numbers will appear after steps? The answer is that it will be precisely those numbers that show up in an s × s multiplication table where we start from :
✕

Clearly no primes appear here, but some numbers can appear multiple times (e.g. 12 appears 4 times). In general, the number of times that the number will show up is the number of proper divisors it has, or DivisorSigma[0, n]–2:
✕

✕

We can continue this, to ask how many times a given number n will occur at a particular step t:
✕

✕

✕

We can think of these results as being determined by the number of times that n appears in an s × s × s… (t times) multiplication array. Alternatively, to know the results for a given number n, we can look at all the ways n can be decomposed into factors. For , for example, we would have:
✕

And from this we can deduce that 12 appears once at (i.e. with 1 factor), 4 times at (i.e. with 2 factors) and 3 times at (i.e. with 3 factors).
The full multiplicad is formed by taking the limits and (as well as what is essentially the limit for an infinite set of possible initial conditions). As we can see, our “finite perception” of the multiplicad will be different depending on how we sample it in s and t.
As an example, let’s consider what happens for given s as a function of t. For , we simply have powers of 2:
✕

For , where can multiply by both 2 and 3, we get:
✕

In studying multiway systems, it is often of interest to ask about the growth rates of the number of states reached over the course of t steps (i.e. the growth rates of volumes of geodesic balls). In the case , the number of states reached by step t is just t. For , it’s the triangular numbers t (t – 1)/2:
✕

Here are some results for larger s:
✕

Each of these sequences is generated by a linear recurrence relation with a kernel given by a sequence of signed binomial coefficients. The values for successive t can be represented by polynomials:
✕

The leading term in the growth of number of states is then determined by the orders of these polynomials, which turn out to be just PrimePi[s]:
✕

✕

For the case , we saw above that the multiway graph essentially forms a simple 2D grid. For larger s, the graph becomes more complicated, though it still approximates a grid—but in dimension PrimePi[s]. (The reason PrimePi[s] appears is that in a sense the combining of primes less than s are the largest “drivers” of structure in the multiway graph.)
In our general analysis of multiway graphs, it is common to consider branchial graphs—or for a rulial multiway system what we can call rulial graphs—obtained by looking at a slice of the multiway graph, effectively for a given t, and asking what states are connected by having a common ancestor. The results for are rather trivial (here shown for , 2, 3):
✕

For we get:
✕

And for we have:
✕

In a sense these pictures show how numbers in the multiplicad can be “laid out in rulial space”. For , the “larget graph” has a very linear form
✕

and the numbers that appear “from left to right” are arranged more or less in numerical order:
✕

For , the result is a 2Dlike structure:
✕

And again the numbers that appear are roughly arranged in a kind of “numerical sequence”:
✕

We can then think of this as suggesting that the multiplicad “generates a rulial space” that can be approximately coordinatized purely by the values of the numbers that appear in it. How all this works in the limit is not clear, though somehow the “1D” sequence of numerical values presumably “snakes through” PrimePi[s]dimensional space as some kind of approximation to a spacefilling curve.
It should be noted that we’ve only considered one particular way of sampling the rulial multiway graph as a function of t. In general there are many different possible foliations that could be used, all of them giving us in effect a different view of the multiplicad, from a different “reference frame”.
As mentioned at the beginning, the multiplicad is presumably not on its own capable of giving us the full ruliad. But if we change the underlying rules—probably even just inserting addition as well as multiplication—we’ll potentially get a system that is capable of universal computation, and which can therefore generate the full ruliad. Needless to say, the particular representation of the ruliad obtained by the kind of “numerical processes” that we’ve used here may be utterly different from any representation that we would recognize from our perception of the physical universe.
Thanks for discussions of various aspects of the ruliad to Xerxes Arsiwalla, James Boyd, Elise Cawley, Hatem Elshatlawy, Jonathan Gorard and Nik Murzin. Thanks also to Ed Pegg and Joseph Stocke for input about the multiplicad. A new paper by Xerxes Arsiwalla and Jonathan Gorard discusses in a more technical way some ideas and results related to the ruliad.
]]>Mathematica 1.0 was launched on June 23, 1988. So (depending a little on how you do the computation) today is its onethirdcentury anniversary. And it’s wonderful to see how the tower of ideas and technology that we’ve worked so hard on for so long has grown in that third of a century—and how tall it’s become and how rapidly it still goes on growing.
In the past few years, I’ve come to have an evergreater appreciation for just how unique what we’ve ended up building is, and just how fortunate our original choices of foundations and principles were. And even after a third of a century, what we have still seems like an artifact from the future—indeed ever more so with each passing year as it continues to grow and develop.
In the long view of intellectual history, this past onethird century will be seen as the time when the computational paradigm first took serious root, and when all its implications for “computational X” began to grow. And personally I feel very fortunate to have lived at the right time in history to have been able to be deeply involved with this and for what we have built to have made such a contribution to it.
Going back just one more third of a century—to 1955—takes us to the dawn of electronic computers, and the time when mass production of computers began. Still another onethird century back takes us to 1921—when ideas from mathematical logic were just beginning to coalesce into what became the concept of computation. And in some ways what we have built owes more to 1921 than to 1955. Yes, Mathematica and everything that has come from it runs on electronic computers; they are what have allowed us to actualize what we have done. But from the beginning, the core of Mathematica—and what is now the Wolfram Language—was based on foundational ideas that transcend the specifics of their implementation.
For me the key question is how to take the concept of computation and use it as a framework for representing and thinking about things. As I have come to understand with greater clarity as the years go by, it’s all about creating a computational language: a language that allows humans to crystallize their thoughts and knowledge in computational form, and then leverage the power of actual computers to work out their consequences. Over the past third of a century, we have come a long way with this, to the point where I feel we can reasonably declare that we have now achieved the goal of creating a fullscale computational language—that transcends the expectations set by its original name Mathematica and that we now increasingly call simply the Wolfram Language.
It has been a wonderful and deeply rewarding journey, that has delivered to the world tools that have enabled countless inventions and discoveries, and helped educate generations of students. But in some ways it has been an increasingly lonely journey—that seems to ascend further and further away from the common expectations of what can be done with computers and computation today.
Back in 1955, there began a trend that has continued to the present day: that we should treat computers as things we “program”, in effect telling them—in its terms—what to do. And this point of view is what has led to the “programming languages” of the past twothirds of a century.
But our goal with computational language has been something different—and something in a sense both more human, and more connected to the world. For our objective is to create not just a language to specifically program computers, but a language to represent everything—including real things in the world—in computational terms. We want to leverage not just the practical details of electronic computers, but the conceptual power of the computational paradigm.
A programming language need in a sense only directly incorporate what is required to represent the raw abilities of practical computers. But to achieve a fullscale computational language, we need to cast into computational terms broad actual knowledge of the world and incorporate it into the language. And even in aspiration, this is far away from the typical expectation of what it means to program a computer.
The development of computers and their use over the past twothirds of a century has been marked by the addition of a series of layers of capability that can be taken for granted. First there were programming languages. Then operating systems. File systems. User interfaces. Networking. Internetbased services. Security. Maybe a few more. But our goal is to put the very important addition of computational intelligence onto this list, made possible by the development of fullscale computational language.
Particularly in recent years, we’ve been working very hard towards this goal, streamlining the deployment of the Wolfram Language, and working through the channels of the computer industry. I consider it one of our great achievements that we’ve been able to build an organization and a business that has been able to continue to focus on the longterm mission of developing and delivering computational intelligence—now for more than a third of a century. I am proud not only of our consistent innovation in technology, but also of the consistency and sustainability of our business practices. But in the end, the core of what we have built is something fundamentally intellectual.
The earliest formal systems—of mathematics and logic—date back to antiquity. But it was four centuries ago that the invention of mathematical notation streamlined mathematics to the point where it could take off and make possible the mathematical sciences. A century ago we saw the beginnings of the development of the formal concept of computation, arising as it did from ideas of logic. And in a sense, our goal with computational language is now to do something like the invention of mathematical notation, but for the much broader and deeper domain of computation—and thereby to enable a dramatic streamline of our ability to think in computational terms, and a framework in which to build all those “computational X” fields.
When I first started to design Mathematica—and its predecessor, SMP—my concept was to do what I might now call metamodeling: to drill down below the formal constructs we know, and find the core of what lies underneath. The essence of what I was doing was, however, a curious mixture of the abstract and the human: I wanted to find abstract computational primitives for the world, but I wanted them to be convenient and comfortable for us humans to deal with. And decades later, I’ve increasingly realized that I was in many ways very fortunate in the particular direction I took in doing this.
My core idea was to represent everything as a symbolic expression, and to represent all operations as transformations on symbolic expressions. After a third of a century of experience with what’s now the Wolfram Language, it might seem obvious that this would be successful. But in retrospect, particularly with what I’ve learned very recently from the formalism of our Physics Project, my decisions in SMP more than 40 years ago come to seem much more fortuitous—or perhaps prescient—than I had imagined.
The nub of the issue is what it takes to “get answers” from computations. One has a symbolic expression, and one has various transformation rules for it. But how should they be applied? What if there are multiple choices? Even 40 years ago, I certainly wondered about such things. But I made the decision to take the simplest approach, and just “do the first transformation that applies”, and keep doing this until nothing changes.
Yes, there were corner cases (like ) where I knew this would fail. But the question was whether the vast majority of computations that we humans would want to do would be successfully done. And now we know the answer: yes, they can. Over the years, we’ve seen how more and more kinds of things can be successfully represented by symbolic expressions—with transformations applied in this way.
In a sense, that this works in practice is an interesting—and ultimately deep—“metascientific” fact about our human view of things. But in recent times, I’ve realized that in the broad sweep of basic science there’s more to think about. Yes, what we have in Mathematica and the Wolfram Language is well optimized for our human view of things—and for applying the computational paradigm. But there’s also a whole multicomputational paradigm that’s possible, and that in fact the Wolfram Language has primed us for.
It’s a fascinating experience building our tower of ideas and technology. At each step it’s an exacting process (now often livestreamed) to reach the clarity needed to create layer after layer of robust and coherent structure. But as the tower grows, there are moments when suddenly we can see much further—and can conceptualize whole new areas that we had not even imagined before.
Technology usually has a certain temporariness, constantly being replaced by the new and the better. But the foundational character of Mathematica and the Wolfram Language gives them a certain timeless permanence—which makes even what we built more than a third of a century ago still seem completely fresh and modern today. It’s certainly satisfying to see all our effort progressively build on itself over the years. And particularly in recent times there’s been an impressive recursive acceleration: with everything we’ve built so far, it becomes faster and faster to build new things.
What does the future hold? Part of it feels to me quite inexorable. With the passage of time what now seem like artifacts from the future will steadily become familiar as artifacts of the present. That’s already happened with some of what seemed like artifacts from the future three decades ago. But even from that time there’s still much more to come. And there’s overwhelmingly more from the years since then.
Then there’s deployment. Over the past third of a century we’ve seen personal computers, GUIs, parallelism, mobile, embedded, web, cloud, and now XR, blockchain and more. And in each case there have been new ideas and opportunities for what one can do with our computational language and its core symbolic framework. And while we don’t know what kinds of deployment the future will bring, I think we can be confident that they will show us still more new ideas and opportunities.
But to me personally, the most exciting part is the conceptual breakthroughs. There are fundamental theoretical reasons to expect that there will always be more to discover and invent in the computational universe. And certainly in the past third of a century, that’s what I’ve experienced. The computational paradigm in general, and our computational language in particular, continually provide us new ways to think about things. It might start as an idea. But soon it becomes a tool. And then a framework. And then we can build on that framework to go yet further.
Some of what we’ve invented or discovered I in some way or another at least imagined, often decades earlier. But much I did not. And instead it’s only with the unique tower of ideas and technology that we’ve built that it’s eventually been possible to get to the new level of understanding or capability that is needed—and to successfully take that next step in intellectual history.
By the standards of modern technology, a third of a century might seem like an eternity. But when it comes to the kind of foundational progress that Mathematica and the Wolfram Language are about, it is but a small span of time. But in that time I am proud of how far we’ve come and how solid what we’ve built is. And now I look forward to the future and to seeing both the inexorable and the surprising developments that it will bring. It’s been a great first third of a century for Mathematica and the Wolfram Language. But it’s just the beginning….
]]>Multicomputation is an important new paradigm, but one that can be quite difficult to understand. Here my goal is to discuss a minimal example: multiway systems based on numbers. Many general multicomputational phenomena will show up here in simple forms (though others will not). And the involvement of numbers will often allow us to make immediate use of traditional mathematical methods.
A multiway system can be described as taking each of its states and repeatedly replacing it according to some rule or rules with a collection of states, merging any states produced that are identical. In our Physics Project, the states are combinations of relations between elements, represented by hypergraphs. We’ve also often considered string substitution systems, in which the states are strings of characters. But here I’ll consider the case in which the states are numbers, and for now just single integers.]]>
Multicomputation is an important new paradigm, but one that can be quite difficult to understand. Here my goal is to discuss a minimal example: multiway systems based on numbers. Many general multicomputational phenomena will show up here in simple forms (though others will not). And the involvement of numbers will often allow us to make immediate use of traditional mathematical methods.
A multiway system can be described as taking each of its states and repeatedly replacing it according to some rule or rules with a collection of states, merging any states produced that are identical. In our Physics Project, the states are combinations of relations between elements, represented by hypergraphs. We’ve also often considered string substitution systems, in which the states are strings of characters. But here I’ll consider the case in which the states are numbers, and for now just single integers.
And in this case multiway systems can be represented in a particularly simple way, with each state s just being repeatedly replaced according to:
s → (s), … , }
For a “binary branching” case the update rule is
✕

and one can represent the evolution of the system by the multiway graph which begins:
✕

and continues (indicating by red and by blue):
✕

With arbitrary “symbolic” this (“free multiway system”) tree is the only structure one can get. But things can get much less trivial when there are forms for , that “evaluate” in some way, because then there can be identities that make branches merge. And indeed most of what we’ll be discussing here is associated with this phenomenon and with the “entanglements” between states to which it leads.
It’s worth noting that the specific setup we’re using here avoids quite a lot of the structural complexity that can exist in multicomputational systems. In the general case, states can contain multiple “tokens”, and updates can also “consume” multiple tokens. In our case here, each state just contains one token—which is a single number—and this is what is “consumed” at each step. (In our Physics Project, a state corresponds to a hyperedge which contains many hyperedge tokens, and the update rule typically consumes multiple hyperedges. In a string substitution system, a state is a character string which contains many character tokens, and the update typically consumes multiple—in this case, adjacent—character tokens.)
With the setup we’re using here there’s one input but multiple outputs (2 in the example above) each time the update rule is applied (with the inputs and outputs each being individual numbers). It’s also perfectly possible to consider cases in which there are multiple inputs as well as multiple outputs. But here we’ll restrict ourselves to the “onetomany” (“traditional multiway”) case. And it’s notable that this case is exceptionally easy to describe in the Wolfram Language:
✕

As our first example, let’s consider multiway systems whose rules just involve addition.
The trivial (“oneinput, oneoutput”) rule
✕

gives a multiway graph corresponding to a “oneway number line”:
✕

The rule
✕

gives a “twoway number line”:
✕

But even
✕

gives a slightly more complicated multiway graph:
✕

What’s going on here? Basically each triangle represents an identity. For example, starting from 1, applying twice gives 3, which is the same result as applying once. Or, writing the rule in the form
✕

the triangles are all the result of the fact that in this case
✕

For the “number line” rule, it’s obvious that we’ll eventually visit every integer—and the +1, +2 rule also visits every integer.
Consider now instead of +1 and +2 the case of +2 and +3:
✕

After a few steps this gives:
✕

Continuing a little longer gives:
✕

It’s a little difficult to see what’s going on here. It helps to show which edges correspond to +2 and +3:
✕

We’ll return to this a little later, but once again we can see that there are cycles in this graph, corresponding to simple “commutativity identities”, such as
✕

and
✕

as well as “LCM identities” such as
✕

(Note that in this case, all integers above 1 are eventually generated.)
Let’s look now at a case with slightly larger integers:
✕

After 6 steps one gets a simple grid
✕

essentially made up of “commutativity identities”. But continuing a little longer one sees that it begins to “wrap around”
✕

eventually forming a kind of “tube” with a spiral grid on the outside:
✕

The “grid” is defined by “commutativity identities”. But the reason it’s a “closed tube” is that there are also “LCM identities”. To understand this, unravel everything into a grid with +4 and +7 directions—then draw lines between the duplicated numbers:
✕

The “tube” is formed by rolling the grid up in such a way as to merge these numbers. But now if we assume that the multiway graph is laid out (in 3D) so that each graph edge has unit length, application of Pythagoras’s theorem in the picture above shows that the effective circumference of the tube is .
In another representation, we can unravel the tube by plotting numbers at {x, y} according to their decomposition in the form :
✕

(From this representation we can see that every value of n can be reached so long as .)
For the rule
✕

the multiway graph forms a tube of circumference which can be visualized in 3D as:
✕

And what’s notable here is that even though we’re just following a simple discrete arithmetic process, we’re somehow “inevitably getting geometry” out of it. It’s a tiny, toy example of a much more general and powerful phenomenon that seems to be ubiquitous in multicomputational systems—and that in our models of physics is basically what leads to the emergence of things like the limiting continuum structure of space.
We’ve seen a few specific example of “multiway addition systems”. What about the more general case?
For
✕

a “tube” is generated with circumference
where = {a, b}/GCD[a, b]
After enough steps, all integers of the form k GCD[a, b] will eventually be produced—which means that all integers are produced if a and b are relatively prime. There’s always a threshold, however, given by FrobeniusNumber[{a, b}]—which for a and b relatively prime is just a b – a – b.
By the way, a particular number n—if it’s going to be generated at all—will first be generated at step
✕

(Note that the fact that the multiway graph approximates a finiteradius tube is a consequence of the commensurability of any integers a and b. If we had a rule like , we’d get an infinite 2D grid.)
For
✕

a tube is again formed, with a circumference effectively determined by the smaller pair (after GCD reduction) of a, b and c. And if GCD[a, b, c] = 1, all numbers above FrobeniusNumber[{a, b, c}] will eventually be generated.
One of the simplest cases of multiway systems are those based on pure multiplication. An example is (now starting from 1 rather than 0):
✕

✕

In general, for
✕

we’ll get a simple 2D grid whenever a and b aren’t both powers of the same number. With d elements in the rule we’ll get a ddimensional grid. For example,
✕

gives a 3D grid:
✕

If the multipliers in the rule are all powers of the same number, the multiway graph degenerates to some kind of ladder. In the case
✕

this is just:
✕

while for
✕

it is
✕

and in general for
✕

it is a “widthm” ladder graph.
Let’s look now at combining multiplication and addition—to form what we might call affine multiway systems. As a first example, consider the case (which I actually already mentioned in A New Kind of Science):
✕

✕

Considering the simplicity of the rule by which it was generated, this result looks surprisingly complex. One immediate result is that after t steps, the total number of distinct numbers reached is Fibonacci[t – 1], which increases exponentially like . Eventually the ensures that every integer is generated. But the often “jumps ahead”, and since the maximum number generated at step t is the “average density” of numbers falls exponentially like .
Continuing the evolution further and using a different rendering we get the very “geometrical” (planar) structure
✕

What can we say about this structure? Apart from the first few steps (rendered at the center), it consists of a spiral of pentagons. Each pentagon (except the one at the center) has the form
✕

reflecting the relation
✕

Going out from the center, each successive layer in the spiral has twice the number of pentagons, with each pentagon at a given layer “spawning” two new pentagons at the next layer.
Removing “incomplete pentagons” this can be rendered as:
✕

What about other rules of the general form:
✕

Here are the corresponding (“complete polygon”) results for through 5:
✕

The multiway graphs in these cases correspond to spirals of ()gons defined by the identity
✕

or equivalently
✕

At successive layers in the spiral, the number of ()gons increases like .
Eventually the evolution of the system generates all possible integers, but at step t the number of distinct integers obtained so far is given by the generalized Fibonacci series obtained from
✕

which for large t is
where is the knacci generalized golden ratio, which approaches for large k.
If we consider
✕

it turns out that one gets the same basic structure (with ()gons) for as for . For example, with
✕

one gets:
✕

For the rule
✕

there are at first no equivalences that cause merging in the multiway graph:
✕

But after 5 steps we get
✕

where now we see that 15 and 31 are connected “across branches”.
After 10 steps this becomes:
✕

At a visual level this seems to consist of two basic components. First, a collection of loops, and second a collection of treelike “loose ends”. Keeping only complete loops and going a few more steps we get:
✕

Unlike in previous cases, the “loops” (AKA “polygons”) are not of constant size. Here are the first few that occur (note these loops “overlap” in the sense that several “start the same way”):
✕

As before, each of these loops in effect corresponds to an identity about compositions of functions—though now it matters what these compositions are applied to. So, for example, the 4^{th} loop above corresponds to (where k stands for the function ):
✕

In explicit form this becomes:
✕

where both sides evaluate to the same number, in this case 26815.
Much as in the Physics Project, we can think of each “loop” as beginning with the creation of a “branch pair”, and ending with the merger of the different paths from each member of the pair. In a later section we’ll discuss the question of whether every branch pair always in the end remerges. But for now we can just enumerate mergers—and we find that the first few occur at:
✕

(Note that a merger can never involve more than two branches, since any given number has at most one “preimage” under and one under .)
Here is a plot of the positions of the mergers—together with a quadratic fit (indicated by the dotted line):
✕

(As we’ll discuss later, the numbers at which these mergers occur are for example always of the form .)
Taking second differences indicates a certain apparent randomness:
✕

What can we say about the overall structure of the multiway graph? One basic question is what numbers ever even occur in the evolution of the system. Here are the first few, for evolution starting from 0:
✕

And here are successive differences
✕

Dividing successive m by the number gives a progressive estimate of the density of numbers:
✕

On a loglog scale this becomes
✕

showing a rough fit to —and suggesting an asymptotic density of 0.
Note, by the way, that while the maximum gap grows on average linearly (roughly like 0.17 m)
✕

the distance between gaps of size 1 shows evidence of remaining bounded:
✕

(A related result from the 1970s states that the original sequence contains infinitelength arithmetic progressions—implying the presence of infinite runs of numbers whose differences are constant.)
Not every rule of the form
✕

leads to a complex multiway graph. For example
✕

just gives a pure binary tree since 2n just adds a 1 at the beginning of the binary digit sequence of n, while adds one at the end:
✕

Meanwhile
✕

gives a simple grid
✕

where at level t the numbers that appear are simply
✕

and the pattern of use of the two cases in the rule makes it clear why the grid structure occurs.
Here are the behaviors of all inequivalent nontrivial rules of the form
✕

with constants up to 3:
✕
Grid[Partition[ ParallelMap[ Function[{a, b, c, d}, Labeled[ Graph[ ResourceFunction["NestGraphTagged"][ n > {a n + b, c n + d}, {0}, 8], ImageSize > {UpTo[80], UpTo[80]}], Text[Style[Row[{a, b, c, d}, " "], 9]]]] @@ # &, Select[Flatten[Array[List, 4 {1, 1, 1, 1}, 0], 3], Function[{a, b, c, d}, GCD[a, b, c, d] == 1 && a <= c && {a, b} =!= {c, d} && c >= a && a > 0 && c > 0 && ! (b == d == 0) && ! (a == 1 && b == 0)] @@ # &]], 8]] 
“Ribbons” are seen only when . “Simple webs” are seen when . “Simple grids” are seen whenever the two cases in the rule commute, i.e.
✕

which occurs whenever
✕

“Simple trees” are seen whenever
✕

In other cases there seems to be irregular merging, as in the case above. And keeping only nontrivial inequivalent cases these are the results after removing loose ends:
✕

Note that adding another element in the rule can make things significantly more complicated. An example is:
✕

After 8 steps this gives
✕

or in another rendering:
✕

After a few more steps, with “loose ends” removed, one gets the stillratherunilluminating result (though one that we will discuss further in the next section):
✕

Will every branching of paths in the multiway graph eventually merge again? If they do, then the system is confluent (which in this case is equivalent to saying that it’s causal invariant—an important property in our Physics Project).
It turns out that all rules of the following forms are confluent:
✕

✕

✕

✕

But among rules of the form
✕

confluence depends on the values of a, b, c and d. When multiway graphs are “simple webs” or “simple grids” there is obvious confluence. And when the graphs are simple trees, there is obviously not confluence.
But what about a case like the rule we discussed above:
✕

We plotted above the “positions” of mergers that occur. But are there “enough” mergers to “rejoin” all branchings?
Here are the first few branchings that occur:
✕

For the pair 3, 4 one can reach a “merged” end state on the following paths:
✕

which are embedded in the whole multiway graph (without loose ends) as:
✕

For the pair 9, 13 both eventually reach 177151, but 9 takes 13 steps to do so:
✕

Here’s a summary of what we know about what happens with the first few branchings:
✕

So what about the total number of branchings and mergings? This is what happens for the first several steps:
✕

The number of branchings at step t approximates
✕

while the number of mergings seems to grow systematically more slowly, perhaps like 1.:
✕

And based on this it seems plausible that the system is not in the end confluent. But how might we show this? And what is the best way to figure out if any particular branch pair (say 21, 31) will ever merge?
One way to look for mergings is just to evolve the multiway graph from each member of the pair, and check if they overlap. But as we can see even for the pair {3, 4} this effectively involves “treeing out” an exponential number of cases:
✕

✕

Is there a way to do this more efficiently, or in effect to prune the trees? A notable feature of the original rule is that the numbers it generates always increase at each step. So one thing to do is just to discard all elements at a particular step in one graph that cannot reach the “minimum frontier” in the other graph. But on its own, this leads to only very minor reduction in the size of graph that has to be considered.
To find what is potentially a much more effective “optimization” let’s look at some examples of mergings:
✕

It’s clear that the final step has to consist of one application of and one of (i.e. one red edge and one blue edge). But these examples suggest that there are also further regularities.
At the merging point it must be true that
✕

for some integers u and v. But for this to be true, the merged value (i.e. or ) must for example be equal to 1 mod 2, 3 and 6.
Using the structure one level back we also have:
✕

or
✕

implying that the merged value must be 3 mod 4, 7 mod 12, 13 mod 18 and 36 mod 31. Additional constraints from going even further back imply in the end that the merged value must have the following pattern of residues:
✕

But now let’s consider the whole system modulo k. Then there are just k possible values, and the multiway graph must be finite. For example, for we get:
✕

Dropping the “transient parts” leaves just:
✕

These graphs can be thought of as reductions of the multiway graph (and, conversely, the multiway graph is a covering of them). The graphs can also be thought of as finite automata that define regular languages whose elements are the “2” and “3” transformations that appear on the edges. Any sequence of “2” and “3” transformations that can occur in the multiway graph must then correspond to a valid word in this regular language. But what we have seen is that for certain values of k, mergers in the multiway graph always occur at particular (“acceptor”) states in the finite automata.
In the case , every merger occurs at the 7 state. But by tracing possible paths in the finite automaton we now can read off what sequences of transformations can lead to a merger:
✕

And what’s notable is that only a certain fraction of all possible sequences of length m can occur; asymptotically, about 28%.
The most stringent analogous constraints come from the graph:
✕

And we see that even for sequences of length 3 fewer are allowed than from the graph:
✕

Asymptotically the number of allowed sequences is about 3% of the possible. And so the conclusion is that if one wants to find mergings in the multiway graph it’s not necessary to tree out all possible sequences of transformations; one only needs at most the 30× smaller number of sequences “accepted by the mod144 finite automaton”. It’s possible to do a little better than this, by looking not just at sequences allowed by the finite automaton for a particular k, but at finite automata for a collection of values of k (say as in the table above).
But while these techniques deliver significant practical speedups they do not seem to significantly alter the asymptotic resources needed. So what will it take to determine whether the pair {21, 31} ever merges?
I don’t know. And for example I don’t know any way to find an upper bound on the number of steps after which we’d be able to say “if it hasn’t merged yet, it never will”. I’m sure that if we look at different branch pairs, there will be tricks for particular cases. But I suspect that the general problem of determining merging will show computational irreducibility, and that for example there will be no fundamentally better way to determine whether a particular branch pair has merged after t steps than by essentially enumerating every possible evolution for that number of steps.
But if this is the case, it means that the general infinitetime question of whether a branch pair will merge is undecidable—and can never be guaranteed to be answerable with a bounded amount of computational effort. It’s a lower bar to ask whether the question can be answered using a finite proof in, say, Peano arithmetic. And I think it’s very likely that the overall question of whether all branch pairs merge—so that the system is confluent—is a statement that can never, for example, be established purely within Peano arithmetic. There are quite a few other candidates for the “simplest ‘numerical’ statement independent of Peano arithmetic”. But it seems at least conceivable that this one might be more accessible to proof than most.
It’s worth mentioning, by the way, that (as we have seen extensively in the Physics Project) the presence of confluence does not imply that a multiway system must show simple overall behavior. Consider for example the rule (also discussed at the end of the previous section):
✕

✕

Running for a few more steps, removing loose ends and rendering in 3D gives:
✕

But despite this complexity, this is a confluent rule. It’s already an indication of this that mergings pretty much “keep up” with branchings in this multiway system:
✕

The first few branchings (now all 3way) are:
✕

All the pairs here merge (often somewhat degenerately) in just a few steps. Here are examples of how they work:
✕

Consider the first few steps of the rule
✕

✕

At each “layer” we can form a branchial graph by joining nodes that have common ancestors on the step before:
✕

Continuing for a few more steps we get:
✕

We can imagine (as we do in our Physics Project) that in an appropriate (if rather subtle) limit such branchial graphs can be thought of as defining a “branchial space” in which each node has a definite position. (One of many subtleties is that the particular branchial graphs we show here are specific to the particular “layering” of the multiway graph that we’ve used; different foliations would give different results.)
But whereas in our Physics Project and many other applications of the multicomputational paradigm the only real way to define “positions” for nodes in the multiway graph is through something like branchial space, there is a much more direct approach that can be taken in multiway systems based on numbers—because every node is labeled by a number which one can imagine directly using as a coordinate.
As an example, let’s take the multiway graph above, and make the horizontal position of each node be determined by its value:
✕

Or, better, by the log of its value:
✕

Continuing for more steps, we get:
✕

Now, for example, we can ask—given the particular choice of layers we have made here—what the distribution of (logarithmic) values reached on successive layers will be, and one finds that the results converge quite quickly:
✕

(By the way, in these results we’ve not included “path weights”, which determine how many different paths lead from the initial number to a particular result. In the example shown, including path weights doesn’t make a difference to the form of the final result.)
So what is the correspondence between the layout of nodes in “branchial space” and in “numerical value space”? Here’s what happens if we lay out a branchial graph using (logarithmic) numerical value as x coordinate:
✕

Perhaps more useful is to plot branchial distance versus (logarithmic) numerical distance for every pair of connected nodes at a particular layer:
✕

And at least in this case, there is perhaps a slight correlation to be seen.
The rules we’ve considered so far all involve only nonnegative numbers. What happens if we include negative numbers? Generally the results are very similar to those with nonnegative numbers. For example:
✕

just gives
✕

in which there is effectively both a “positive” and “negative” “web”.
A rule like
✕

turns out to yield essentially only positive numbers, yielding after removing loose ends
✕

✕

gives a more balanced collection of positive and negative numbers (with positive numbers indicated by dark nodes), but the final graph is still quite similar:
✕

So far we’ve considered only rules based on ordinary arithmetic functions. As a first example of going beyond that, consider the rule:
✕

Running this for 50 steps we get:
✕

A notable feature here is that only one “fresh” node is added at each step—and the whole thing grows like a Fermat spiral. After 250 steps the multiway graph has the form
✕

which we can readily see is essentially a “binary tree superimposed on a spiral”.
Dividing by 3 instead of 2 makes it a ternary tree:
✕

✕

Using Round instead of Floor gives a mixed binary and ternary tree:
✕

✕

What about rules of the form:
✕

Here are the results for a few values of a:
✕

Continuing
✕

for more steps we get:
✕

✕

has far fewer “loose ends”:
✕

What are the “grid patches”? Picking out some of the patches we can see they’re places where a number that can be “halved a lot” appears—and just like in our pure multiplication rules above, and 3n represent commuting operations that form a grid:
✕

Including Floor[] is a bit like having different functions for even and odd n. What happens if we do this more explicitly? Consider for example
✕

The result is essentially identical to the Floor case:
✕

Here are a couple of other cases, at least qualitatively similar to what we’ve seen before:
✕

✕

✕

✕

But now consider as we did at the beginning:
✕

What is the inverse of this? One can think of it as being
✕

or
✕

which gives for example
✕

or continuing for longer:
✕

How about
✕

Now the “inverse” is:
✕

But in this case since most numbers are not reached in the original iteration, most “don’t have inverses”. However, picking an initial number like 4495, which happens to be a merge point, yields:
✕

Note that this “inverse iteration” always monotonically decreases towards 0—reaching it in at most steps.
But now we can compare with the wellknown 3n+1 problem, defined by the “singleway” iteration:
✕

And while in this case the intermediate numbers sometimes increase, all known initial conditions eventually evolve to a simple cycle:
✕

But now we can “invert” the problem, by considering the rule:
✕

equivalent to
✕

which gives after 10 steps:
✕

Continuing this to 25 steps one gets:
✕

Removing loose ends this then becomes:
✕

or after more steps, and rendered in 3D:
✕

The 3n+1 problem now asks whether as the multiway graph is built, it will eventually include every number. But from a multicomputational point of view there are new questions to ask—like whether the “inverse3n+1problem” multiway system is confluent.
The first few branchings in the multiway graph in this case are
✕

and all of these remerge after at most 13 steps. The total number of branchings and mergings on successive steps is given by:
✕

Including more steps one gets
✕

which suggests that there is indeed confluence in this case—though, like for the problem of termination in the original 3n+1 problem, it may be extremely difficult to determine this for sure.
All the rules we’ve used so far are—up to conditionals—fundamentally “linear”. But we can also consider “polynomial” rules. With pure powers, as in
✕

the multiway graph is just the one associated with the addition of exponents:
✕

In a case like
✕

the graph is a pure tree
✕

while in a case like
✕

there is “early merging”, followed by a pure tree:
✕

There are also cases like
✕

which lead to “continued merging”
✕

but when loose ends are removed, they are revealed to behave in rather simple ways:
✕

In a case like
✕

however, there is at least slightly more complicated merging (shown here after removing loose ends):
✕

If we include negative numbers we find cases like:
✕

✕

But in other “polynomial” cases one tends to get only trees; a merging corresponds to a solution to a highdegree Diophantine equation, and things like the ABC conjecture tend to suggest that very few of these exist.
Returning to the “linear” case, we can consider—as we did above—multiway graphs mod k. Such graphs always have just k nodes. And in a case like
✕

with graph
✕

they have a simple interpretation—as “remainder graphs” which one can use to compute a given input number n mod k. Consider for example the number 867, with digits 8, 6 and 7. Start at the 0 node. Follow 8 red arrows, followed by a blue one, thus reaching node 3. Then follow 6 red arrows, followed by blue. Then 7 red arrows, followed by blue. The node that one ends up on by this procedure is exactly the remainder. And in this case it is node 6, indicating that Mod[867, 7] is 6.
Not too surprisingly, there is a definite structure to such remainder graphs. Here is the sequence of “binary remainder graphs” generated from the rule
✕

for successive values of k:
✕

Continuing a numbertheoretical theme, we may note that the familiar “divisor graph” for a number can be considered as a multiway graph generated by the rule:
✕

Here’s an example for 100:
✕

Transitive reduction gives a graph which in this case is essentially a grid:
✕

Other initial numbers can give more complicated graphs
✕

but in general the transitive reduction is essentially a grid graph of dimension PrimeNu:
✕

As an alternative to looking at divisors, we can look, for example, at a rule which transforms any number to the list of numbers relatively prime to it:
✕

✕

The transitive reduction of this is always trivial, however:
✕

One general way to “probe” any function is to look at a multiway graph generated by the rule:
✕

Here, for example, is the result for
✕

starting with
:
✕

Once again, the transitive reduction is very simple:
✕

As another example, we can look at:
✕

✕

where each “efflorescence” corresponds to a prime gap:
✕

As a final example we can consider the digitreversal function:
✕

✕

✕

In almost everything we’ve discussed so far, we’ve been considering only integer values, both in our rules and our initial conditions. So what happens if we start a rule like
✕

with a noninteger value? Rather than taking a specific initial value, we can just use a symbolic value x—and it then turns out that the multiway graph is the same regardless of the value of x, integer or noninteger:
✕

What if the rule contains noninteger values? In a case like
✕

the basic properties of addition ensure that the multiway graph will always have the same grid structure, regardless of a, b and the initial value x:
✕

But in a case like
✕

things are more complicated. For arbitrary symbolic a, b and initial x, there are no relations that apply, and so the multiway graph is a pure tree:
✕

For a specific value of b, however, there are already relations, and a more complicated structure develops:
✕

✕

Continuing for more steps and removing loose ends we get
✕

which is to be compared to the result from above for , :
✕

What happens if we choose a noninteger value of b, say:
✕

We immediately see that there are “special relations” associated with and its powers:
✕

Continuing for longer we get the somewhat complex structure:
✕

or in a different rendering with loose ends removed:
✕

This structure is very dependent on the algebraic properties of . For a transcendental number like π there are no “special relations”, and the multiway graph will be a tree. For we get
✕

and for :
✕

There are many possible generalizations to consider. An immediate one is to complex integers.
For real numbers always generates a grid. But for example
✕

instead generates
✕

Continuing for longer, the graph becomes:
✕

One feature of having values that are complex numbers is that these values themselves can be used to define coordinates to lay out the nodes of the multiway graph in the plane—giving in this case:
✕

or after more steps:
✕

Similarly
✕

gives
✕

The nonbranching rule
✕

yields
✕

while
✕

gives
✕

If we combine multiplication with addition, we get different forms—and we can make some interesting mathematical connections. Consider rules of the form
✕

where c is some complex number. I considered such rules in A New Kind of Science as a practical model of plant growth (though already then I recognized their connection to multiway systems). If we look at the case
✕

the multiway graph is structurally just a tree:
✕

But if we plot nodes at the positions in the complex plane corresponding to their values we get:
✕

Continuing this, and deemphasizing the “multiway edges” we see a characteristic “fractallike” pattern:
✕

Note that this is in some sense dual to the typical “line segment iteration” nested construction:
✕

Adding a third “real” branch
✕

we get
✕

And with
✕

the result builds up to a typical Sierpinski pattern:
✕

These pictures suggest that at least in the limit of an infinite number of steps there will be all sorts of merging between branches. And indeed it is fairly straightforward to prove this. But what about after, say, t steps?
The result from each branch for the rule
✕

is a polynomial such as
✕

or
✕

So now the question of merging becomes a question of finding solutions to equations which equate the polynomials associated with different possible branches. The simplest nontrivial case equates branch {1, 1} with branch {2, 2}, yielding the equation:
✕

with solution
✕

We can see this merging in action with the rule:
✕

✕

The core of what it generates is the repetitive structure:
✕

A few additional results are (where the decimals are algebraic numbers of degree 6, and a is a real number):
✕

In a case like
✕

there is an “early merger”
✕

but then the system just generates a tree:
✕

The family of rules of the form
✕

shows more elaborate behavior. For we get:
✕

Continuing for more steps this becomes:
✕

For we get instead:
✕

If we look at the actual distribution of values obtained by such rules we find for example:
✕

If we go beyond multiway systems with pure “1 + c n” rules we soon get results very similar to ones we’ve seen in previous sections. For example
✕

gives multiway graph (after removing loose ends)
✕

Placing nodes according to their numerical values this then has the form:
✕

In studying multiway systems based on complex numbers we’re effectively considering a special case of multiway systems based on collections of numbers. If the complexnumber rules are linear, then what we have are iterated affine maps—that form the basis for what I’ve called geometric substitution systems.
As a slightly more general case we can consider multiway systems in which we take pairs of numbers v and apply the rule
✕

where now a and b are matrices. If both matrices are the form then this is equivalent to the case of complex numbers. But we can also for example consider a rule like
✕

which yields
✕

or after more steps and in a different rendering:
✕

Laying this out in 2D using the actual pairs of numbers as coordinates, this becomes:
✕

Here are samples of typical behavior with 0, 1 matrices:
✕

Beyond pure matrix multiplication, we can also consider a rule that adds constant vectors, as in:
✕

We can also think in a more “elementwise” way, constructing for example simple rules such as
✕

This generates the multiway graph:
✕

Continuing for longer and removing loose ends yields:
✕
ResourceFunction["GraphRemoveLooseEnds"][ ResourceFunction["NestGraphTagged"][ v > {v + {2, 1}, {1, 0} + Reverse[v]}, {{1, 1}}, 12], All] 
Using values as coordinates then gives:
✕
{With[{g = ResourceFunction["NestGraphTagged"][ v > {v + {2, 1}, {1, 0} + Reverse[v]}, {{1, 1}}, 4, "StateLabeling" > True, "FormattingFunction" > (Style[Row[Riffle[#, ","]], Black] &)]}, Graph[g, VertexCoordinates > (# > # & /@ VertexList[g])]], With[{g = ResourceFunction["NestGraphTagged"][ v > {v + {2, 1}, {1, 0} + Reverse[v]}, {{1, 1}}, 8, "FormattingFunction" > (Style[Row[Riffle[#, ","]], Black] &)]}, Graph[g, VertexCoordinates > (# > # & /@ VertexList[g])]]} 
In our Physics Project and other applications of multicomputation, we often discuss causal graphs, that track the causal relationships between updating events. So why is it that these haven’t come up in our discussion of multiway systems based on numbers? The basic reason is that when our states are individual numbers, there’s no reason to separately track updating events and transformations of states because these are exactly the same—because every time a state (i.e. a number) is transformed the number as a whole is “consumed” and new numbers are produced. Or, in other words, the flow of “data” is the same as the flow of “causal information”—so that if we did record events, there’d just be one on each edge of the multiway graph.
But the story is different as soon as our states don’t just contain individual “atomic” things, like single numbers. Because then an updating event can affect just part of a state—and asking what causal relationships there may be between events becomes something separate from asking about the transformation of whole states.
With a rule of the form, say,
✕

things are still fairly trivial. Yes, there are separate “x” and “y” events. But they don’t mix, so we’ll just get two independent causal graphs. Things can be less trivial in a case like the one above, of the form:
✕

But now there is a different problem. Let’s say that the rule transforms {x, y} to {y + 1, x + 1}. How should we decompose that into “elementary events”? We could say there’s one event that swaps x and y, and others that add 1. Or something different. It’s hard to know.
So why haven’t we encountered this kind of problem in other multicomputational systems, say in hypergraph rewriting systems or string substitution systems? The point is that in these systems the underlying elements always have a certain unique identity, which allows their “flow” to be traced. In our Physics Project, for example, each hypergraph updating event that occurs affects certain particular “atoms of space” (that we can think of as being labeled by unique identifiers)—and so we can readily trace how the effects of different events are related. Similarly, in a string substitution system, we can trace which characters at which positions in the string were affected by a given event, and we can then trace which new characters at which new positions these affect.
But in a system based on numbers this tracing of “unique elements” doesn’t really apply. We might think of 3 as being . But there’s nothing that uniquely tags these 1s, and allows us to trace how they affect 1s that might make up other numbers. In a sense, the whole point of numbers is to abstract away from the labeling of individual objects—and just ask the aggregate question of “how many” there are. So in effect the “packaging” of information into numbers can be thought of as “washing out” causal relationships.
When we give a rule based on numbers what it primarily does is to specify transformations for values. But it’s perfectly possible to add an ancillary “causal rule”, that, for example, can define which elements in an “input” list of numbers should be thought of as being “used as the inputs” to produce particular numbers in an output list of numbers.
There’s another subtlety here, though. The point of a multiway graph is to represent all possible different histories for a system, corresponding to all possible sequences of transformations for states. A particular history corresponds to a particular path in the multiway graph. And if—as in a multiway system based on single numbers—each step in this path is associated with a single, specific event, then the causal graph associated with a particular history will always be trivial.
But in something like a hypergraph or stringbased system there’s usually a nontrivial causal graph even for a single path of history. And the reason is that each transformation between states can involve multiple events—acting on different parts of the state—and there can be nontrivial causal relationships between these events “mediated” by shared elements in the state.
One can think of the resulting causal graph as representing causal relationships in “spacetime”. Successive events define the passage of time. And the layout of different elements in each state can be thought of as defining something like space. But in a multiway system based on single numbers, there isn’t a natural notion of space associated with each state, because the states are just single numbers which “don’t have enough structure” to correspond to something like space.
If we’re dealing with collections of numbers, there’s more possibility of “having something like space”. But it’s easiest to imagine this when one’s dealing with very large collections of numbers, and when the “locations” of the numbers are more important than their values—at which point the fact that they’re numbers (rather than, say, characters in a string) doesn’t make much difference.
But in a multiway system one’s dealing with multiple paths of history, not just one. And one can then start asking about causal relationships not just within a single path of history, but across different paths: a multiway causal graph. And that’s the kind of causal graph we’ll readily construct for a multiway system based on numbers. For a system based on strings or hypergraphs there’s a certain wastefulness to starting with a standard multiway graph of transformations between states. Because if one looks at all possible states, there’s typically a lot of repetition between the “context” of different updating events.
And so an alternative approach is to look just as the “tokens” that are involved in each event: hyperedges in a hypergraph, or runs of characters in a string. So how does it work for a multiway system based on numbers? For this we have to again think about how our states are decomposed for purposes of events, or, in other words, what the “tokens” in them are. And for multiway systems based on single numbers, the natural thing is just to consider each number as a token.
For collections of numbers, it’s less obvious how things should work. And one possibility is to treat each number in the collection as a separate token, and perhaps to ignore any ordering or placement in the collection. We could then end up with a “multitoken” rule like
✕

whose behavior we can represent with a tokenevent graph:
✕

But given this, there is then the issue of deciding how collections of tokens should be thought of as aggregated into states. And in general multitoken numerical multiway systems represent a whole separate domain of exploration from what we have considered here.
A basic point, however, is that while our investigations of things like hypergraph and string systems have usually had a substantial “spatial component”, our investigation of multiway systems based on numbers tends to be “more branchial”, and very much centered around the relationships between different branches of history. This does not mean that there is nothing “geometrical” about what is going on. And in fact we fully expect that in an appropriate limit branchial space will indeed have a geometrical structure—and we have even seen examples of this here. It is just that that geometrical structure is—in the language of physics—about the space of quantum states, not about physical space. So this means that our intuition about ordinary physical space won’t necessarily apply. But the important point is that by studying multiway systems based on numbers we can now hope to sharpen our understanding and intuition about things like quantum mechanics.
The basic setup for multiway systems based on numbers is very simple. But what we’ve seen here is that—just like for so many other kinds of systems in the computational universe—the behavior of multiway systems based on numbers can be far from simple.
In many ways, what’s here just scratches the surface of multiway systems based on numbers. There is much more to explore, in many different directions. There are many additional connections to traditional mathematics (and notably number theory) to be made. There are also questions about the geometrical structures that can be generated, and their mathematical characterization.
In the general study of multicomputational systems, branchial—and causal—graphs are important. But here we have barely begun to consider them. A particularly important issue that we haven’t addressed at all is that of alternative possible foliations. In general it has been difficult to characterize these. But it seems possible that in multiway systems based on numbers these may be amenable to investigation with some kind of mathematical techniques. In addition, for things like our Physics Project questions about the coordinatization of branchial space are of great significance—and the “natural coordinatizability” of numbers makes multiway systems based on numbers potentially an attractive place to study these kinds of questions.
Here we’ve considered only ordinary multiway systems, in which the rules always transform one object into several. It’s also perfectly possible to study more general multicomputational systems in which the rules can “consume” multiple objects—and this is particularly straightforward to set up in the case of numbers.
Here we’ve mostly looked at multiway systems whose states are individual integers. But we can consider other kinds of numbers and collections of numbers. We can also imagine generalizing to other kinds of mathematical objects. These could be algebraic constructs (such a polynomials) based on ordinary real or complex numbers. But they could also, for example, be objects from universal algebra. The basic setup for multiway systems—involving repeatedly applying functions—can be thought of as equivalent to repeatedly multiplying by elements (say, generators) of a semigroup. Without any relations between these elements, the multiway graphs we’ll get will always be trees. But if we add relations things can be more complicated.
Multiway systems based on semigroups are in a sense “lower level” than ones based on numbers. In something like arithmetic, one already has immediate knowledge of operations and equivalences between objects. But in a semigroup, these all have to be built up. Of course, if one goes beyond integers, equivalences can be difficult to determine even between numbers (say different representations of radicals or, worse, transcendental numbers).
In their basic construction, multiway systems are fundamentally discrete—involving as they do discrete states, discrete branches, and discrete notions like merging. But in our Physics Project and other applications of the multicomputational paradigm it’s often of interest to think about “continuum limits” of multiway systems. And given that real numbers provide the quintessential example of a continuum one might suppose that by somehow looking at multiway systems based on real numbers one could understand their continuum limit.
But it’s not so simple. Yes, one can imagine allowing a whole “real parameter’s worth” of outputs from the multiway rule. But the issue is how to “knit these together” from one step to the next. The situation is somewhat similar to what happens when one looks at ensembles of random walks, or stochastic partial differential equations. But with multiway systems things are both cleaner and more general. The closest analogy is probably to path integrals of the kind considered in quantum mechanics. And in a sense this is not surprising, because it is precisely the appearance of multiway systems in our Physics Project that seems to lead to quantum mechanics—and in a “continuum limit” to the path integral there.
It’s not clear just how multiway systems are best generalized to the continuum case. But multiway systems based on numbers seem to provide a potentially promising bridge to existing mathematical investigations of the continuum—and I think have a good chance of revealing some elegant and powerful mathematics.
I first looked at multiway systems based on numbers back in the early 1990s, and I always meant to come back and look at them further. But what we’ve found here is that they’re richer and more interesting than I ever imagined. And particularly from what we’ve now seen I expect them to have a very bright future, and for all sorts of important science and mathematics to connect to them, and flow from them.
I worked on what’s described here during two distinct periods: May 2020 and September 2021. I thank for help of various kinds Tali Beynon, José Manuel Rodríguez Caballero, Bernat EspigulePons, Jonathan Gorard, Eliza Morton, Nik Murzin, Ed Pegg and Joseph Stocke—as well as my weekly virtual highschool “Computational Adventures” group.
]]>This is the first of a series of pieces I’m planning in connection with the upcoming 20th anniversary of the publication of A New Kind of Science.
For me the story began nearly 50 years ago—with what I saw as a great and fundamental mystery of science. We see all sorts of complexity in nature and elsewhere. But where does it come from? How is it made? There are so many examples. Snowflakes. Galaxies. Lifeforms. Turbulence. Do they all work differently? Or is there some common underlying cause? Some essential “phenomenon of complexity”?
It was 1980 when I began to seriously work on these questions. And at first I did so in the main scientific paradigm I knew: models based on mathematics and mathematical equations. I studied the approaches people had tried to use. Nonequilibrium thermodynamics. Synergetics. Nonlinear dynamics. Cybernetics. General systems theory. I imagined that the key question was: “Starting from disorder and randomness, how could spontaneous selforganization occur, to produce the complexity we see?” For somehow I assumed that complexity must be created as a kind of filtering of ubiquitous thermodynamiclike randomness in the world.
At first I didn’t get very far. I could write down equations and do math. But there wasn’t any real complexity in sight. But in a quirk of history that I now realize had tremendous significance, I had just spent a couple of years creating a big computer system that was ultimately a direct forerunner of our modern Wolfram Language. So for me it was obvious: if I couldn’t figure out things myself with math, I should use a computer.
And there was something else: the computer system I’d built was a language that I’d realized (in a nod to my experience with reductionist physical science) would be the most powerful if it could be based on principles and primitives that were as minimal as possible. It had worked out very well for the language. And so when it came to complexity, it was natural to try to do the same thing. And to try to find the most minimal, most “meta” kind of model to use.
I didn’t know just what magic ingredient I’d need in order to get complexity. But I thought I might as well start absolutely as simple as possible. And so it was that I set about running programs that I later learned were a simplified version of what had been called “cellular automata” before. I don’t think it was even an hour before I realized that something very interesting was going on. I’d start from randomness, and “spontaneously” the programs would generate all sorts of complex patterns.
At first, it was experimental work. I’d make observations, cataloging and classifying what I saw. But soon I brought in analysis tools—from statistical mechanics, dynamical systems theory, statistics, wherever. And I figured out all sorts of things. But at the center of everything, there was still a crucial question: what was the essence of what I was seeing? And how did it connect to existing science?
I wanted to simplify still further. What if I didn’t start from randomness, but instead started from the simplest possible “seed”? There were immediately patterns like fractals. But somehow I just assumed that a simple program, with simple rules, starting from a simple seed just didn’t have what it took to make “true complexity”. I had printouts (yes, that was still how it worked back then) that showed this wasn’t true. But for a couple of years I somehow ignored them.
Then in 1984 I made my first highresolution picture of rule 30. And I now couldn’t get away from it: a simple rule and simple seed were making something that seemed extremely complex. But was it really that complex? Or was there some magic method of analysis that would immediately “crack” it? For months I looked for one. From mathematics. Mathematical physics. Computation theory. Cryptography. But I found nothing.
And slowly it began to dawn on me that I’d been fundamentally wrong in my basic intuition. And that in the world of simple programs—or at least cellular automata—complexity was actually easy to make. Could it really be that this was the secret that nature had been using all along to make complexity? I began to think it was at least a big part of it. I started to make connections to specific examples in crystal growth, fluid flow, biological forms and other places. But I also wanted to understand the fundamental principles of what was going on.
Simple programs could produce complex behavior. But why? It wasn’t long before I realized something fundamental: that this was at its core a computational phenomenon. It wasn’t something one could readily see with math. It required a different way of thinking about things. A fundamentally computational way.
At first I had imagined that having a program as a model of something was essentially just a convenience. But I realized that it wasn’t. I realized that computational models were something fundamentally new, with their own conceptual framework, character and intuition. And as an example of that, I realized that they showed a new central phenomenon that I called computational irreducibility.
For several centuries, the tradition and aspiration of exact science had been to predict numbers that would say what a system would do. But what I realized is that in most of the computational universe of simple programs, you can’t do that. Even if you know the rules for a system, you may still have to do an irreducible amount of computational work to figure out what it will do. And that’s why its behavior will seem complex.
By 1985 I knew these things. And I was tremendously excited about their implications. I had got to this point by trying to solve the “problem of complexity”. And it seemed only natural to label what could now be done as “complex systems theory”: a theory of systems that show complexity, even from simple rules.
And so it was that in 1985 I began to promote the idea of a new field of “complex systems research”, or, for short “complexity”—fueled by the discoveries I’d made about things like cellular automata.
Now that I know more about history I realize that the thrust of what I wanted to do had definite precursors, especially from the 1950s. For that was a time when the concepts of computing were first being worked out—and through approaches like cybernetics and the nascent area of artificial intelligence, people started exploring the broader scientific implications of computational ideas. But with no inkling of the phenomena I discovered decades later, this didn’t seem terribly promising, and the effort was largely abandoned.
By the late 1970s, though, there were other initiatives emerging, particularly coming from mathematics and mathematical physics. Among them were fractals, catastrophe theory and chaos theory. Each in a different way explored some form of complexity. But all of them in a sense operated largely in the “comfort” of traditional mathematical ideas. And while they used computers as practical tools, they never made the jump to seeing computation as a core paradigm for thinking about science.
So what became of the “complex systems research” I championed in 1985? It’s been 36 years now. Careers have come and gone. Several academic generations have passed by. Some things have developed well. Some things have not developed so well.
But I, for one, know much more than I did then. For me, my work in the early 1980s was a foundation for the whole tower of science and technology that I’ve spent my life since then building, most recently culminating in our Wolfram Physics Project and what in just the past few weeks I’ve called the multicomputational paradigm.
Nothing I’ve learned in these 36 years has dulled the strength and beauty of rule 30 and those early discoveries about complexity. But now I have so much more context, and a somuchbigger conceptual framework—from which it’s possible to see so much more about complexity and about its place and potential in science.
Back in 1985 I was pretty much a lone voice expressing the potential for studying complexity in science. Now there are perhaps a thousand scientific institutes around the world nominally focused on complexity. And my goal here is to share what I’ve learned and figured out about what’s now possible to do under the banner of complexity.
There are exciting—and surprising—things. Some I was already beginning to think about in the 1980s. But others have only come into focus—or even become conceivable—as a result of very recent progress around our Physics Project and the formalism it has developed.
Back in 1985 I was tremendously excited about the potential for developing the field of complex systems research. It seemed as if there was a vast new domain that had suddenly been made accessible to scientific exploration. And in it I could see so much great science that could be done, and so many wonderful opportunities for so many people.
I myself was still only 25 years old. But I’d had some organizational experience, both leading a research group, and starting my first company. And I set about applying what I knew to complex systems research. By the following year, I’d founded the first research center and the first journal in the field (Complex Systems, still going strong after 35 years). (And I’d also done things like suggesting “complexity” as the theme for what became the Santa Fe Institute.) But somehow everything moved very slowly.
Despite my efforts, complex systems research wasn’t a thing yet. It wasn’t something universities were teaching; it wasn’t something that was a category for funding. There were some applications for the field emerging. And there was tremendous pressure—particularly in the context of those applications—to shoehorn it into some existing area. Yes, it might have to take on the methodology of its “host” area. But at least it would have a home. But it really wasn’t physics, or computer science, or math, or biology, or economics, or any known field. At least as I envisioned it, it was its own thing, with its own, new, emerging methodology. And that was what I really thought should be developed.
I was impatient to have it happen. And by late 1986 I’d decided the best path was just to try to do it myself—and to set up the best tools and the best environment for that. The result was Mathematica (and now the Wolfram Language), as well as Wolfram Research. For a few years the task of creating these entirely consumed me. But in 1991 I returned to basic science and set about continuing where I had left off five years earlier.
It was an exciting time. I quickly found that the phenomena I had discovered in cellular automata were quite general. I explored all sorts of different kinds of rules and programs, always trying to understand the essence of what they were doing. But every time, the core phenomena I found were the same. Computational irreducibility—as unexpected as it had been when I first saw it in cellular automata—was everywhere. And I soon realized that beneath what I was seeing, there was a deep and general principle—that I called the Principle of Computational Equivalence—that I now consider to be the most fundamental thing we know about the computational universe.
But what did these discoveries about simple programs and the computational universe apply to? My initial target had been immediately observable phenomena in the natural world. And I had somehow assumed that ideas like evolutionary adaptation or mathematical proof would be outside the domain. But as the years went by, I realized that the force of the Principle of Computational Equivalence was much greater than I’d ever imagined, and that it encompassed these things too.
I spent the 1990s exploring the computational universe and its applications, and steadily writing a book about what I was discovering. At first, in recognition of my original objective, I called the book A Science of Complexity. But by the mid1990s I had realized that what I was doing far transcended the specific goal of understanding the phenomenon of complexity.
Instead, the core of what I was doing was to introduce a whole new kind of science, based on a new paradigm—essentially what I would now call the paradigm of computation. For three centuries, theoretical science had been dominated by the idea of using mathematical equations to describe the world. But now there was a new idea. The idea not of solving equations, but instead of setting up computational rules that could be explicitly run to represent and reproduce things in the world.
For three centuries theoretical models had been based on the fairly narrow set of constructs provided by mathematical equations, and particularly calculus. But now the whole computational universe of possible programs and possible rules was opened up as a source of raw material for making models.
But with this new power came a sobering realization. Out in the unrestricted computational universe, computational irreducibility is everywhere. So, yes, there was now a way to create models for many things. But to figure out the consequences of those models might take irreducible computational work.
Without the computational paradigm, systems that showed significant complexity had seemed quite inaccessible to science. But now there was an underlying way to model them, and to successfully reproduce the complexity of their behavior. But computational irreducibility was all over them, fundamentally limiting what could be predicted or understood about how they behave.
For more than a decade, I worked through the implications of these ideas, continually surprised at how many foundational questions across all sorts of fields they seemed to address. And particularly given the tools and technology I’d developed, I think I became pretty efficient at the research I did. And finally in 2002 I decided I’d pretty much “picked all the lowhanging fruit”, and it was time to publish my magnum opus, titled—after what I considered to be its main intellectual thrust—A New Kind of Science.
The book was a mixture of pure, basic science about simple programs and what they do, together with a discussion of principles deduced from studying these programs, as well as applications to specific fields. If the original question had been “Where does complexity come from?” I felt I’d basically nailed that—and the book was now an exploration of what one could do in a science where the emergence of complexity from simplicity was just a feature of the deeper idea of introducing the computational paradigm as a foundation for a new kind of science.
I put tremendous effort into making the exposition in the book (in both words and pictures) as clear as possible—and contextualizing it with extensive historical research. And in general all this effort paid off excellently, allowing the message of the book to reach a very wide audience.
What did people take away from the book? Some were confused by its new paradigm (“Where are all the equations?”). Some saw it as a somewhat mysterious wellspring of new forms and structures (“Those are great pictures!”). But what many people saw in it was a thousand pages of evidence that simple programs—and computational rules—could be a rich and successful source of models and ideas for science.
It’s hard to trace the exact chains of influence. But in the past two decades there’s been a remarkable—if somewhat silent—transformation. For three hundred years, serious models in science had essentially always been based on mathematical equations. But in the short space of just twenty years that’s all changed—and now the vast majority of new models are based not on equations but on programs. It’s a dramatic and important paradigmatic change, whose implications are just beginning to be felt.
But what of complexity? In the past it was always a challenge to “get complexity” out of a model. Now—with computational models—it tends to be very easy. Complexity has gone from something mysterious and out of reach to something ubiquitous and commonplace. But what has that meant for the “study of complexity”? Well, that’s a story with quite some complexity to it….
From about 1984 to 1986 I put great effort into presenting and promoting the idea of “complex systems research”. But by the time I basically left the field in 1986 to concentrate on technology for a few years, I hadn’t seen much traction for the idea. A decade later, however, the story was quite different. I myself was quietly working away on what became A New Kind of Science. But elsewhere it seemed like my “marketing message” for complexity had firmly taken root, and there were complexity institutes starting to pop up all over the place.
What did people even mean by “complexity”? It often seemed to mean different things to different people. Sometimes it just meant “stuff in our field we haven’t figured out yet”. More often it meant “stuff that seems fundamental but we haven’t been able to figure out”. Pretty often there was some visualization component: “Look at how complex this plot seems!” But whatever exactly it might mean to different people, “complexity” was unquestionably becoming a popular science “brand”, and there were plenty of people eager to affiliate with it—at the very least to give work they’d been doing for years a new air of modernity.
And while it was easy to be cynical about some of this, it had one very important positive consequence: “complexity” became a kind of banner for interdisciplinary work. As science had gotten bigger and more institutionalized, it inevitably become more siloed, with people in different departments at the same university routinely never having even met. But now people from all kinds of fields could say, “Yes, we run into complexity in our field”, and with complexity as a banner they now had a reason to connect, and maybe even to form an institute together.
So what actually got done? Some of it I might summarize as “Yes, it’s complex, but we can find something mathematical in it”—with a typical notion being the pursuit of some kind of power law formula. But the more important strand has been one that starts to actually take the computational paradigm on board—with the thrust typically being “We can write a program to reproduce what we’re looking at”.
And one of the great feelings of power has been that even in fields—like the social sciences—where there haven’t really been much more than “verbal” models before, it’s now appeared possible to get models that at least seem much more “scientific”. Sometimes the models have been purely empirical (“Look, there’s a power law!”). Sometimes they have been based on constructing programs to reproduce behavior.
The definition of success has often been a bit questionable, however. Yes, there’s a program that shows some features of whatever system one’s looking at. But how complicated is the program? How much of what’s coming out is basically just being put right into the program? For mathematical models, people have long had familiarity with questions like “How many parameters does that model have?”. But when it comes to programs, there’s been a tendency just to put more and more into them without doing much accounting of it.
And then there’s the matter of complexity. Let’s say whatever one’s trying to model shows complexity. Then often the thinking seems to be that to get that complexity out, there’s a need to somehow have enough complexity in the model. And when complexity does manage to come out, there’s a feeling that this is some kind of triumph, and evidence that the model is on the right track.
But actually—as I discovered in studying the computational universe of simple programs—this really isn’t the right intuition at all. Because it fundamentally doesn’t take into account computational irreducibility. And knowing that computational irreducibility is ubiquitous, we know that complexity is too. It’s not something special and “on the right track” that’s making a model produce complexity; instead producing complexity is just something a very wide range of computational models naturally do.
Still, the general field and brand of complexity continued to gain traction. Back in 1986 my Complex Systems had been the only journal devoted to complex systems research. By the late 2010s there were dozens of journals in the field. And my original efforts from the 1980s to promote the study of complexity had been thoroughly dwarfed by a whole “complexity industry” that had grown up. But looking at what’s been done, I feel like there’s something important that’s missing. Yes, it’s wonderful that there’s been so much “complexity activity”. But it feels scattered and incoherent—and without a strong common thread.
There’s a vast amount that’s now been done under the banner of complexity. But how does it fit together? And what are its intellectual underpinnings? The dynamics of academia has led most of the ongoing activity of complexity research to be about specific applications in specific fields—and not really to concern itself with what basic science might lie underneath, and what the “foundations of complexity” might be.
But the great power of basic science is the economy of scale it brings. Find one principle of basic science and it can inform a vast range of different specific applications, that would otherwise each have to be explored on their own. Learn one principle of basic science and you immediately know something that subsumes all sorts of particular things you would otherwise separately have to learn.
So what about complexity? Is there something underneath all those specifics that one can view as a coherent “basic science of complexity”—and for example the raw material for something like a course on the “Foundations of Complexity”? At first it might not be obvious where to look for this. But there’s immediately a big clue. And it’s what is in a sense the biggest “meta discovery” of the study of complexity over the past few decades: that across all kinds of systems, computational models work.
So then one’s led to the question of what the basic science of computational models—or computational systems in general—might be. But that’s precisely what my work on the computational universe of simple programs—and my book A New Kind of Science—are about. They’re about the core basic science of the computational universe, and the principles it involves—in a sense the foundational science of computation.
It’s important, by the way, to distinguish this from computer science. Computer science is about programs and computations that we humans construct for certain purposes. But the foundational science we need is instead about programs and computations “in the wild”—and about what’s out there in general in the computational universe, independent of whether we humans would have a reason to construct or use it.
It’s a very abstract kind of thing. That—like pure mathematics—can be studied completely on its own, without reference to any particular application. And in fact the analogy to pure mathematics is an apt one. Because just as pure mathematics is in a sense the abstract underpinning for the mathematical sciences and the whole mathematical paradigm for representing the world, so now our foundational science of computation is the abstract underpinning for the computational paradigm for representing the world—and for all the “computational X” fields that flow from it.
So, yes, there is a core basic science of complexity. And it’s also essentially the foundational science of computation. And by studying this, we can bring together all sorts of seemingly disparate issues that arise in the study of complexity in different systems. Everywhere we’ll see computational irreducibility. Everywhere we’ll see intrinsic randomness generation. Everywhere we’ll see the effects of the Principle of Computational Equivalence. These are general, abstract things from pure basic science. They’re the intellectual underpinnings of the study of complexity—the “foundations of complexity”.
I was at a complexity conference once, talking to someone who was modeling fish and their behavior. Proudly the person showed me his simulated fish tank. “How many parameters does this involve?”, I asked. “About 90”, he said. “My gosh”, I said, “with that many parameters, you could put an elephant in your fish tank too!”
If one wanted to make a simulated fish tank display just for people to watch, then having all those parameters might be just fine. But it’s not so helpful if one wants to understand the science of fish. The fish have different shapes. The fish swim around in different configurations. What are the core things that lead to what we see?
To answer that, we have to drill down: we have to find the essence of fish shape, or fish behavior.
At first, if confronted with complexity, we might say “It’s hopeless, we’ll never find the essence of what’s going on—it’s all too complicated”. But the whole point is that we know that in the computational universe of possible programs, there can in fact be simple programs with simple rules that lead to immense complexity. So even though there’s immense complexity in behavior we see, underneath it all there can still be something simple and understandable.
In a sense, the concept of taking phenomena and drilling down to find their underlying essential causes is at the heart of reductionist science. But as this has traditionally been practiced, it’s relied on being able to see one’s way through this “drilling down” process, or in effect, to explicitly do reverse engineering. But a big lesson of the computational paradigm is the phenomenon of computational irreducibility—and the “irreducible distance” that can exist between rules and the behavior they produce.
It’s a doubleedged thing, however. Yes, it’s hard to drill down through computational irreducibility. But in the end the details of what’s underneath may not matter so much; the main features one sees may just be generic reflections of the phenomenon of computational irreducibility.
Still, there are normally structural features of the underlying models (or their interpretations) that matter for particular applications. Is one dealing with something on a 2D grid? Are there nonlocal effects in the system? Is there directionality to the states of the system? And so on.
If one looks at the literature of complexity, one finds all sorts of models for all sorts of systems. And often—like the fish example—the models are very complicated. But the question is: are there simpler models lurking underneath? Models simple enough that one can readily understand at least their basic rules and structure. Models simple enough that it’s plausible that they could be useful for other systems as well.
To find such things is in a sense an exercise in what one can call “metamodeling”: trying to make a model of a model, doing reductionist science not on observations of the world, but on the structure of models.
When I first worked on the problem of complexity, one of the main things I did was a piece of metamodeling. I was looking at models for a whole variety of phenomena, from snowflake growth to selfgravitating gases to neural nets. But what I did was to try to identify an underlying “metamodel” that would cover all of them. And what I came up with was simple cellular automata (which, by the way, don’t cover everything I had been looking at, but turn out to be very interesting anyway).
As I think about it now, I realize that the activity of metamodeling is not a common one in science. (In mathematics, one could argue that something like categorification is somewhat analogous.) But to me personally, metamodeling has seemed very natural—because it’s very much like something I’ve done for a very long time, which is language design.
What’s involved in language design? You start off from a whole collection of computations, and descriptions of how to do them. And then you try to drill down to identify a small set of primitives that let you conveniently build up those computations. Just like metamodeling is about removing all the “hairy” parts of models to get to their minimal, primitive forms, so also language design is about doing that for computations and computational structures.
In both cases there’s a certain art to it. Because in both cases the consumers of those minimal forms are humans. And it’s to humans that they need to seem “simple” and understandable. Some of the practical definition of simplicity has to do with history. What, for example, has become familiar, or are there words for? Some is more about human perception. What can be represented by a diagram that our visual processing system can readily absorb?
But once one’s found something minimal, the great value of it is that it tends to be very general. Whereas a detailed “hairy” model tends to have all sorts of features specific to a particular system, a simple model tends to be applicable to all sorts of systems. So by doing the metamodeling, and finding the simplest “common” model, one is effectively deriving something that will have the greatest leverage.
I’ve seen this quite dramatically with cellular automata over the past forty years. Cellular automata are in a sense minimal models in which there’s a definite (discrete) structure for space and time and a finite number of states associated with each discrete cell. And it’s been remarkable how many different kinds of systems can successfully be modeled by cellular automata. So that for example of the 256 very simplest 2color nearestneighbor 1D rules, a significant fraction have found application somewhere, and many have found several (often completely different) applications.
I have to say that I haven’t explicitly thought of myself as pursuing “metamodeling” in the past (and I only just invented the term!). But I believe it’s an important technique and idea. And it’s one that can “mine” the specific modeling achievements of work on complexity and bring them to a broader and more foundational level.
In A New Kind of Science I cataloged and studied minimal kinds of models of many types. And in the twenty years since A New Kind of Science was finished, I have only seen a modest number of new minimal models (though I haven’t been looking for them with the focus that metamodeling now brings). But recently, I have another major example of what I now call metamodeling. For our Physics Project we’ve developed a particular class of models based on multiway hypergraph rewriting. But I’ve recently realized that there’s metamodeling to do here, and the result has been the general concept of multicomputation and multicomputational models.
Returning to complexity, one can imagine taking all the academic papers in the field and identifying the models they use—and then trying to do metamodeling to classify and boil down these models. Often, I suspect, the resulting minimal classes of models will be ones we’ve already seen (and that, for example, appear in A New Kind of Science). But occasionally they will be new: in a sense new primitives for the language of modeling, and new “metascientific” output from the study of complexity.
If one sets up a system to follow a particular set of simple rules, what will the system do? Or, put another way, how do all those simple programs out there in the computational universe of possible programs behave?
These are pure, abstract questions of basic science. They’re questions one’s led to ask when one’s operating in the computational paradigm that I describe in A New Kind of Science. But at some level they’re questions about the specific science of what abstract rules (that we can describe as programs) do.
What is that science? It’s not computer science, because that would be about programs we construct for particular purposes, rather than ones that are just “out there in the wilds of the computational universe”. It’s not (as such) mathematics, because it’s all about “seeing what rules do” rather than finding frameworks in which things can be proved. And in the end, it’s clear it’s actually a new science—that’s rich and broad, and that I, at least, have had the pleasure of practicing for forty years.
But what should this science be called? I’ve wondered about this for decades. I’ve filled so many pages with possible names. Could it be based on Greek or Latin words associated with rules? Those are arch and reg: very welltrafficked roots. What about words associated with computation? That’d be logis or calc. None of these seem to work. But—in something akin to the process of metamodeling—we can ask: What is the essence of what we want to communicate in the word?
It’s all about studying rules, and what their consequences are. So why not the simple and obvious “ruliology”? Yes, it’s a new and slightly unusualsounding word. But I think it does well at communicating what this science that I’ve enjoyed for so long is about. And I, for one, will be pleased to call myself a “ruliologist”.
But what is ruliology really about? It’s a pure, basic science—and a very clean and precise one. It’s about setting up abstract rules, and then seeing what they do. There’s no “wiggle room”. No issue with “reproducibility”. You run a rule, and it does what it does. The same every time.
What does the rule 73 cellular automaton starting from a single black cell do? What does some particular Turing machine do? What about some particular multiway string substitution system? These are specific questions of ruliology.
At first you might just do the computation, and visualize the result. But maybe you notice some particular feature. And then you can use whatever methods it takes to get a specific ruliological result—and to establish, for example, that in the rule 73 pattern, black cells appear only in oddlength blocks.
Ruliology tends to start with specific cases of specific rules. But then it generalizes, looking at broader ranges of cases for a particular rule, or whole classes of rules. And it always has concrete things to do—visualizing behavior, measuring specific features, and so on.
But ruliology quickly comes face to face with computational irreducibility. What does some particular case of some particular rule eventually do? That may require an irreducible amount of computational effort to find out—and if one insists on knowing what amounts to a general truly infinitetime result, it may be formally undecidable. It’s the same story with looking at different cases of a rule, or different rules. Is there any case that does this? Or any rule that does it?
What’s remarkable to me—even after 40 years of ruliology—is how many surprises there end up being. You have some particular kind of rule. And it looks as if it’s only going to behave in some particular way. But no, eventually you find a case where it does something completely different, and unexpected. And, yes, this is in effect computational irreducibility reaching into what one’s seeing.
Sometimes I’ve thought of ruliology as being at first a bit like natural history. You’re exploring the world of simple programs, finding what strange creatures exist in it—and capturing them for study. (And, yes, in actual biological natural history, the diversity of what one sees is presumably at its core exactly the same computational phenomenon we see in abstract ruliology.)
So how does ruliology relate to complexity? It’s a core part—and in fact the most fundamental part—of studying the foundations of complexity. Ruliology is like studying complexity at its ultimate source. And about seeing just how complexity is generated from its simplest origins.
Ruliology is what builds raw material—and intuition—for making models. It’s what shows us what’s possible in the computational universe, and what we can use to model—and understand—the systems we study.
In metamodeling we’re going from models that have been constructed, and drilling down to see what’s underneath them. In ruliology we’re in a sense going the other way, building up from the minimal foundations to see what can happen.
In some ways, ruliology is like natural science. It’s taking the computational universe as an abstracted analog of nature, and studying how things work in it. But in other ways, ruliology is something more generative than natural science: because within the science itself, it’s thinking not only about what is, but also about what can abstractly be generated.
Ruliology in some ways starts as an experimental science, and in some ways is abstract and theoretical from the beginning. It’s experimental because it’s often concerned with just running simple programs and seeing what they do (and in general, computational irreducibility suggests you often can’t do better). But it’s abstract and theoretical in the sense that what’s being run is not some actual thing in the natural world, with all its details and approximations, but something completely precise, defined and computational.
Like natural science, ruliology starts from observations—but then builds up to theories and principles. Long ago I found a simple classification of cellular automata (starting from random initial conditions)—somehow reminiscent of identifying solids, liquids and gases, or different kingdoms of organisms. But beyond such classifications, there are also much broader principles—with the most important, I believe, being the Principle of Computational Equivalence.
The everyday course of doing ruliology doesn’t require engaging directly with the whole Principle of Computational Equivalence. But throughout ruliology, the principle is crucial in guiding intuition, and having an idea of what to expect. And, by the way, it’s from ruliology that we can get evidence (like the universality of rule 110, and of the 2,3 Turing machine) for the broad validity of the principle.
I’ve been doing ruliology (though not by that name) for forty years. And I’ve done a lot of it. In fact, it’s probably been my top methodology in everything I’ve done in science. It’s what led me to understand the origins of complexity, first in cellular automata. It’s what led me to formulate the general ideas in A New Kind of Science. And it’s what gave me the intuition and impetus to launch our new Physics Project.
I find ruliology deeply elegant, and satisfying. There’s something very aesthetic—at least to me—about the purity of just seeing what simple rules do. (And it doesn’t hurt that they often make very pleasing images.) It’s also satisfying when one can go from so little and get so much—and do so automatically, just by running something on a computer.
And as well I like the fundamental permanence of ruliology. If one’s dealing with the simplest rules of some type, they’re going to be foundational not only now, but forever. It’s like simple mathematical constructs—like the icosahedron. There were icosahedral dice in ancient Egypt. But when we find them today, their shapes still seem completely modern—because the icosahedron is something fundamental and timeless. Just like the rule 30 pattern or countless other discoveries in ruliology.
In a sense perhaps one of the biggest surprises is that ruliology is such a comparatively new activity. But as I cataloged in A New Kind of Science, it has precursors going back hundreds and perhaps thousands of years. But without the whole paradigm of A New Kind of Science, there wasn’t a context to understand why ruliology is so significant.
So what constitutes a good piece of ruliology? I think it’s all about simplicity and minimality. The best ruliology happens after metamodeling is finished—and one’s really dealing with the simplest, most minimal class of rules of some particular type. In my efforts to do ruliology, for example in A New Kind of Science, I like to be able to “explain” the rules I’m using just by an explicit diagram, if possible with no words needed.
Then it’s important to show what the rules do—as explicitly as possible. Sometimes—as in cellular automata—there’s a very obvious visual representation that can be used. But in other cases it’s important to do the work to find some scheme for visualization that’s as explicit as possible, and that both shows the whole of what’s going on and doesn’t introduce distracting or arbitrary additional elements.
It’s amazing how often in doing ruliology I’ll end up making an array of thumbnail images of how certain rules behave. And, again, the explicitness of this is important. Yes, one often wants to do various kinds of filtering, say of rules. But in the end I’ve found that one needs to just look at what happens. Because that’s the only way to successfully notice the unexpected, and to get a sense of the irreducible complexity of what’s out there in the computational universe of possible rules.
When I see papers that report what amounts to ruliology, I always like it when there are explicit pictures. I’m disappointed if all I see are formal definitions, or plots with curves on them. It’s an inevitable consequence of computational irreducibility that in doing good ruliology, one has to look at things more explicitly.
One of the great things about ruliology as a field of study is how easy it is to explore new territory. The computational universe contains an infinite number of possible rules. And even among ones that one might consider “simple”, there are inevitably astronomically many on any human scale. But, OK, if one explores some particular ruliological system, what of it?
It’s a bit like chemistry where one explores properties of some particular molecule. Exploring some particular class of rules, you may be lucky enough to come upon some new phenomenon, or understand some new general principle. But what you know you’ll be doing is systematically adding to the body of knowledge in ruliology.
Why is that important? For a start, ruliology is what provides the raw material for making models, so you’re in effect creating a template for some potential future model. And in addition, when it comes to technology, an important approach that I’ve discussed (and used) quite extensively involves “mining” the computational universe for “technologically useful” programs. And good ruliology is crucial in helping to make that feasible.
It’s a bit like creating technology in the physical universe. It was crucial, for example, that good physics and chemistry had been done on liquid crystals. Because that’s what allowed them to be identified—and used—in making displays.
Beyond its “pragmatic” value for models and for technology, another thing ruliology does is to provide “empirical raw material” for making broader theories about the computational universe. When I discovered the Principle of Computational Equivalence, it was as a result of several years of detailed ruliology on particular types of rules. And good ruliology is what prepares and catalogs examples from which theoretical advances can be made.
It’s worth mentioning that there’s a certain tendency to want to “nail down ruliology” using, for example, mathematics. And sometimes it’s possible to derive a nice summary of ruliological results using, say, some piece of discrete mathematics. But it’s remarkable how quickly the mathematics tends to get out of hand, with even a very simple rule having behavior that can only be captured by large amounts of obscure mathematics. But of course that’s in a sense just computational irreducibility rearing its head. And showing that mathematics is not the methodology to use—and that instead something new is needed. Which is precisely where ruliology comes in.
I’ve spent many years defining the character and subject matter of what I’m now calling ruliology. But there’s something else I’ve done too, which is to build a large tower of practical technology for actually doing ruliology. It’s taken more than forty years to build up to what’s now the fullscale computational language that is the Wolfram Language. But all that time, I was using what we were building to do ruliology.
The Wolfram Language is great and important for many things. But when it comes to ruliology, it’s simply a perfect fit. Of course it’s got lots of relevant builtin features. Like visualization, graph manipulation, etc., as well as immediate support for systems like cellular automata, substitution systems and Turing machines. But what’s even more important is that its fundamental symbolic structure gives it an explicit way to represent—and run—essentially any computational rule.
In doing practical ruliological explorations—and for example searching the computational universe—it’s also useful to have immediate support for things like parallel computation. But another crucial aspect of the Wolfram Language for doing practical ruliology is the concept of notebooks and computable documents. Notebooks let one organize both the process of research and the presentation of its results.
I’ve been accumulating research notebooks about ruliology for more than 30 years now—with textual notes, images of behavior, and code. And it’s a great thing. Because the stability of the Wolfram Language (and its notebook format) means that I can immediately go back to something I did 30 years ago, run the code, and build on it. And when it comes to presenting results, I can do it as a computational essay, created in a notebook—in which the task of exposition is shared between text, pictures and computational language code.
In a traditional technical paper based on the mathematical paradigm, the formal part of the presentation will normally use mathematical notation. But for ruliology (as for “computational X” fields) what one needs instead is computational notation, or rather computational language—which is exactly what the Wolfram Language provides. And in a good piece of ruliology—and ruliology presentation—the notation should be simple, clear and elegant. And because it’s in computational language, it’s not just something people read; it’s also something that can immediately be executed or integrated somewhere else.
What should the future of ruliology be? It’s a huge, wideopen field. In which there are many careers to be made, and immense numbers of papers and theses and books that can be written—that will build up a body of knowledge that advances not just the pure, basic science of the computational universe but also all the science and technology that flows from it.
How should the phenomenon of complexity affect one’s worldview, and one’s general way of thinking about things? It’s a bit of a rollercoasterlike ride. When first confronted with complexity in a system, one might think “There doesn’t seem to be any science to that”. But then with great effort it may turn out to be possible to “drill down” and find the underlying rules for the system, and perhaps they’ll even be quite simple. And at that point we might think “OK, science has got this one”—we’ve solved it.
But that ignores computational irreducibility. And computational irreducibility implies that even though we may know the underlying rules, that doesn’t mean we can necessarily “scientifically predict” what the system will do; instead, it may take an irreducible amount of computational work to figure it out.
Yes, you may have a model that correctly captures the underlying rules for a system—and even explains the overall complexity in the behavior of the system. But that absolutely does not mean that you can successfully make specific predictions about what the system will do. Because computational irreducibility gets in the way, essentially “eating away the power of science from the inside”—as an inevitable formal fact about how systems based on the computational paradigm typically behave.
But in a sense even the very phenomenon of computational irreducibility—and even more so, the Principle of Computational Equivalence—give us ways to reason and think about things. It’s a bit like in evolutionary biology, or in economics, where there are principles that don’t specifically define predictions, but do give us ways to reason and think about things.
So what are some conceptual and philosophical consequences of computational irreducibility? One thing it does is to explain ubiquitous apparent randomness in the world, and say why it must happen—or at least must be perceived to happen by computationally bounded observers like us. And another thing it does is to tell us something about the perception of free will. Even if the underlying rules for a system (such as us humans) are deterministic, there can be an inevitable layer of computational irreducibility which makes the system still seem to a computationally bounded observer to be “free”.
Metamodeling and ruliology are in effect the extensions of traditional science needed to handle the phenomenon of complexity. But what about extensions to philosophy?
For that one must think not just about the phenomenology of complexity, but really about its foundations. And that’s where I think one inevitably runs into the whole computational paradigm, with all its intellectual implications. So, yes, there’s a “philosophy of complexity”, but it’s really the “philosophy of the computational paradigm”.
I started to explore this towards the end of A New Kind of Science. But there’s much more to be done, and it’s yet something else that can be reached by serious study of the foundations of complexity.
Computational irreducibility is a very strong phenomenon, that in a sense pervades the computational universe. But within computational irreducibility, there must always be pockets—or slices—of computational reducibility: aspects of a system that are amenable to a reduced description. And for example in doing ruliology, part of the effort is to catalog the computational reducibility one finds.
But in typical ruliology—or, for example, a random sampling of the computational universe of possible programs—computational reducibility is at best a scattered phenomenon. It’s not something one can count on seeing. But there’s something confusing about this when it comes to thinking about our universe, and our experience of it. Because perhaps the most striking fact about our universe—and indeed the one that leads to the possibility of what we normally call science—is that there’s order in what happens in it.
Yet even if the universe ultimately operates at the lowest level according to simple rules, we might expect that at our level, all we would see is rampant computational irreducibility. But in our recent Physics Project there has been a big surprise. Because with the structure of the models we used, it seemed that within all that computational irreducibility, we were always seeing certain slices of reducibility—that turn out to correspond to the major known laws of physics: general relativity and quantum mechanics.
A more careful examination showed that what was picking out this computational reducibility was really the combination of two things. First, a certain general structure to the underlying model. And second, certain rather general features of us as observers of the system.
In the usual computational paradigm, one imagines rules that are successively applied to determine how the state of a system should evolve in time. But our Physics Project needed a new paradigm—that I’ve recently called the multicomputational paradigm—in which there can be many possible states of a system evolving in effect on many possible interwoven threads of time. In the computational paradigm, one can always identify the particular state reached after a certain amount of evolution. But in the multicomputational paradigm, it takes an observer to define how a “perceived state” should be extracted from all the possible threads of time.
In the multicomputational paradigm, the actual evolution on all the threads of time will show all sorts of computational irreducibility. But somehow what an observer like us perceives has “smoothed” all of that out. And what’s left is something that’s a reflection of the core structure of the underlying multicomputational rules. And that turns out to show a certain set of emergent “physicslike laws”.
It’s all an important piece of metamodeling. We started from a model intended to capture fundamental physics. But we’ve been able to “drill down” to find the essential “primitive structure” underneath—which turns out to be the idea of multicomputation. And wherever multicomputation occurs, we can expect that there will be computational reducibility and emergent physicslike laws, at least for certain kinds of observers.
So how does this relate to complexity? Well, when systems fundamentally follow the computational paradigm—with standard computational models—they’ll tend to show computational irreducibility and complexity. But if instead they follow the multicomputational paradigm, then there’ll be emergent laws to discover in them.
There are all sorts of fields—like economics, linguistics, molecular biology, immunology, etc.—where I have recently come to suspect that there may be good multicomputational models to be made. And in these fields, yes, there will be complexity to be seen. But the multicomputational paradigm suggests that there will also be definite regularities and emergent laws. So in a sense from “within complexity” there will inexorably emerge a certain simplicity. So that if one “observes the right things” one can potentially find what amount to “ordinary scientific laws”.
It’s a curious twist in the story of complexity, and one that I, for one, did not see coming. Back in the early 1980s when I was first working on complexity, I used to talk about finding “scientific laws of complexity”. And at some level computational irreducibility and the Principle of Computational Equivalence are very general such laws—that were at first very surprising to see.
But what we’ve discovered is that in the multicomputational paradigm, there’s another surprise: complexity can produce simplicity. But not just any simplicity. Simplicity that specifically follows physicslike laws. And that for a variety of fields might indeed give us something we could consider to be “scientific laws of complexity”.
It’s a wonderful thing to see something go from “just an idea” to a whole, developed ecosystem in the world. But that’s what’s happened over the past forty years with the concept of doing science around the phenomenon of complexity. And over that time countless “workflows” associated with particular applications have been developed—and there’s been all sorts of activity in all sorts of areas. But now I think it’s time to take stock of what’s been achieved—and see what might be possible going forward.
I myself have not been much involved in the “daily work of the complexity field” since my early efforts in the 1980s. And perhaps that distance makes it easier to see what lies ahead. For, yes, by now there’s plenty of understanding of how to apply “complexityinspired methodology” (and computational models) in particular areas. But the great opportunity is to turbocharge all this by focusing again on the “foundations of complexity”—and bringing the basic science that arises from that to bear on all the various applications whose “workflows” have now been defined.
But what is that basic science? Its great “symptom” is complexity. But there’s much more to it than that. It’s heavily based on the computational paradigm. And it’s full of deep and powerful ideas and methods. And I’ve been thinking about it for more than forty years. But it’s only very recently—particularly based on what I’ve learned from our Physics Project—that I think I see with true clarity just how that science should be defined and pursued.
First, there’s what I’m calling here metamodeling: going from specific models constructed for particular applications, and working out what the underlying more minimal and more general models are. And second, there’s what I’m calling ruliology: the study of what possible rules (or possible programs) in the computational universe do.
Metamodeling is a kind of “meta” analog of science, probably most directly related to activities like computational language design. Ruliology is a pure, basic science, a bit like pure mathematics, but based on a very different methodology.
In both metamodeling and ruliology there is much of great value to do. And even after more than forty years of pursuing what I’m now calling ruliology, I feel as if I’ve only just scratched the surface of what’s possible.
Applications under the banner of complexity will come and go as different fields and their objectives ebb and flow. But both metamodeling and ruliology have a certain purity, and clear anchoring to intellectual bedrock. And so we can expect that whatever is discovered there will—like the discoveries of pure mathematics—be part of the permanent corpus of theoretical knowledge.
Hovering over all of what we might study around complexity is the phenomenon of computational irreducibility. But within that irreducibility are pockets and slices of reducibility. And informed by our Physics Project, we now know that multicomputational systems can be expected to expose to observers like us what amount to physicslike laws—in effect leveraging the phenomenon of complexity to deliver accessible scientific laws.
Complexity is a field that fundamentally rests on the computational paradigm—and in a sense when we see complexity what is really happening is that some lump of irreducible computation is being exposed. So at its core, the study of complexity is a study of irreducible computation. It’s computation whose details are irreducibly hard to figure out. But which we can reason about, and which, for example, we can also use for technology.
Even forty years ago, the fundamental origin of complexity still seemed like a complete mystery—a great secret of nature. But now through the computational paradigm, I think we have a clear notion of where complexity fundamentally comes from. And by leveraging the basic science of the computational universe—and what I’m now calling metamodeling and ruliology—there’s a tremendous opportunity that now exists to dramatically advance everything that’s been done under the banner of complexity.
The first phase of “complexity” is complete. The ecosystem is built. The applications are identified. The workflows are defined. And now it’s time to return to the foundations of complexity. And to take the powerful basic science that lies there to define “complexity 2.0”. And to deliver on the amazing potential that the concept of studying complexity has for science.
One might have thought it was already exciting enough for our Physics Project to be showing a path to a fundamental theory of physics and a fundamental description of how our physical universe works. But what I’ve increasingly been realizing is that actually it’s showing us something even bigger and deeper: a whole fundamentally new paradigm for making models and in general for doing theoretical science. And I fully expect that this new paradigm will give us ways to address a remarkable range of longstanding central problems in all sorts of areas of science—as well as suggesting whole new areas and new directions to pursue.
If one looks at the history of theoretical science, I think one can identify just three major modeling paradigms that have been developed over the course of scientific history—each of them leading to dramatic progress. The first, originating in antiquity, one might call the “structural paradigm”. Its key idea is to think of things in the world as being constructed from some kind of simpletodescribe elements—say geometrical objects—and then to use something like logical reasoning to work out what will happen with them. Typically this paradigm has no explicit notion of time or dynamical change, though in its modern forms it often involves making descriptions of structures of relationships, usually built from logical or “flowchartlike” elements.
Many would say that modern exact science was launched in the 1600s with the introduction of what we can call the “mathematical paradigm”: the idea that things in the world can be described by mathematical equations—and that their behavior can be determined by finding solutions to these equations. It’s common in this paradigm to discuss time—but normally it’s just treated as a variable in the equations, and one hopes that to find out what will happen at some arbitrary time one can just substitute the appropriate value for that variable into some formula derived by solving the equations.
For three hundred years the mathematical paradigm was the state of the art in theoretical science—and immense progress was made using it. But there remained plenty of phenomena—particularly associated with complexity—that this paradigm seemed to have little to say about. But then—basically starting in the early 1980s—there was a burst of progress based on a new idea (of which, yes, I seem to have ultimately been the primary initiator): the idea of using simple programs, rather than mathematical equations, as the basis for models of things in nature and elsewhere.
Part of what this achieves is to generalize beyond traditional mathematics the kind of constructs that can appear in models. But there is something else too—and it’s from this that the full computational paradigm emerges. In the mathematical paradigm one imagines having a mathematical equation and then separately somehow solving it. But if one has a program one can imagine just directly taking it and running it to find out what it does. And this is the essence of the computational paradigm: to define a model using computational rules (say, for a cellular automaton) and then explicitly be able to run these to work out their consequences.
And one feature of this setup is that time becomes something much more fundamental and intrinsic. In the mathematical paradigm it’s in effect just the arbitrary value of a variable. But in the computational paradigm it’s a direct reflection of the actual process of applying computational rules in a model—or in other words in this paradigm the passage of time corresponds to the actual progress of computation.
A major discovery is that in the computational universe of possible programs even ones with very simple rules can show immensely complex behavior. And this points the way—through the Principle of Computational Equivalence—to computational irreducibility: the phenomenon that there may be no faster way to find out what a system will do than just to trace each of its computational steps. Or, in other words, that the passage of time can be an irreducible process, and it can take an irreducible amount of computational work to predict what a system will do at some particular time in the future. (Yes, this is closely related not only to things like undecidability, but also to things like the Second Law of Thermodynamics.)
In the full arc of scientific history, the computational paradigm is very new. But in the past couple of decades, it’s seen rapid and dramatic success—and by now it’s significantly overtaken the mathematical paradigm as the most common source for new models of things. Despite this, however, fundamental physics always seemed to resist its advance. And now, from our Physics Project, we can see why.
Because at the core of our Physics Project is actually a new paradigm that goes beyond the computational one: a fourth paradigm for theoretical science that I’m calling the multicomputational paradigm. There’ve been hints of this paradigm before—some even going back a century. But it’s only as a result of our Physics Project that we’ve been able to start to see its full depth and structure. And to understand that it really is a fundamentally new paradigm—that transcends physics and applies quite generally as the foundation for a new and broadly applicable methodology for making models in theoretical science.
In the ordinary computational paradigm the typical setup is to have a system that evolves in a series of steps by repeatedly applying some particular rule. Cellular automata are a quintessential example. Given a rule like
✕

one can think of the evolution implied by the rule
✕

as corresponding to a sequence of states of the cellular automaton:
✕

The essence of the multicomputational paradigm is to generalize beyond just having simple linear sequences of states, and in effect to allow multiple interwoven threads of history.
Consider as an example a system defined by the string rewrite rules:
✕

Starting from A, the next state has to be BBB. But now there are two possible ways to apply the rules, one generating AB and the other BA. And if we trace both possibilities we get what I call a multiway system—whose behavior we can represent using a multiway graph:
✕

A typical way to think about what’s going on is to consider each possible underlying rule application as an “updating event”. And then the point is that even within a single string multiple updating events (shown here in yellow) may be possible—leading to multiple branches in the multiway graph:
✕

At first, one might want to say that while many branches are in principle possible, the system must somehow in any particular case always choose (even if perhaps “nondeterministically”) a single branch, and therefore a particular history. But a key to the multicomputational paradigm is not to do this, and instead to say that “what the system does” is defined by the whole multiway graph, with all its branches.
In the ordinary computational paradigm, time in effect progresses in a linear way, corresponding to the successive computation of the next state of the system from the previous one. But in the multicomputational paradigm there is no longer just a single thread of time; instead one can think of every possible path through the multiway system as defining a different interwoven thread of time.
If we look at the four paradigms for theoretical science that we’ve identified we can now see that they involve successively more complicated views of time. The structural paradigm doesn’t directly talk about time at all. The mathematical paradigm does consider time, but treats it as a mathematical variable whose value can in a sense be arbitrarily chosen. The computational paradigm treats time as reflecting the progression of a computation. And now the multicomputational paradigm treats time as something multithreaded, reflecting the interwoven progression of multiple threads of computation.
It’s not difficult to construct multiway system models. There are multiway Turing machines. There are multiway systems based on rewriting not only strings, but also trees, graphs or hypergraphs. There are also multiway systems that work just with numbers. It’s even possible (though not especially natural) to define multiway cellular automata. And in fact, whenever there’s a system where a single state can be updated in multiple ways, one’s led to a multiway system. (Examples include games where multiple moves are possible at each turn, and computer systems with asynchronous or distributed elements that operate independently.)
And once one has the idea of multiway systems it’s amazing how often they end up being the most natural models for things. And indeed one can see them as minimal models pretty much whenever there’s no rigid builtin notion of time, and no predefined specification of “when things happen” in a system.
But right now the “killer app” for multiway systems is our Physics Project. Because what we seem to be learning is that in fact our whole universe is operating as a giant multiway system. And it’s the limiting properties of that multiway system that give us space and time and relativity and quantum mechanics.
In the mathematical paradigm one expects to immediately “read off” from a model what happens at a particular time. In the computational paradigm one might have to run an irreducible computation, but then one can still “read off” what happens after a certain time. But in the multicomputational paradigm, it’s more complicated—because now there are multiple threads of time, with no intrinsic way to line up “what happens when” across different threads.
But imagine you’re trying to see what’s going on in a multicomputational system. In principle you could keep track of the behaviors on all the threads as well as the complicated interweavings between them. But a crucial fact about us as observers is that we don’t normally do that. Instead, we normally combine things so that we can describe the system as somehow just progressively “evolving through time”.
There might in principle be some alien intelligence that routinely keeps track of all the different threads. But we humans—and the descriptions we use of the world—always tend to sequentialize things. In other words, in order to understand “what’s happening in the world” we try to approximate what might underneath be multicomputational by something that is “merely computational”. Instead of following lots of different “local times” on different threads, we try to think about things in terms of a single “global time”.
And this isn’t just something we do “for convenience”; the tendency to “sequentialize” like this is directly related to our perception that we have a single thread of experience, which seems to be a key defining feature of our notion of consciousness and our general way of relating to the world.
But how should we line up different threads of time in a multicomputational system? A crucial point is that there typically isn’t just “one natural way” to do it. Instead, there are many possible choices. And it’s “up to the observer” which one to use—and therefore “how to parse” the behavior of the multicomputational system.
The underlying structure of the multiway system puts constraints on what’s possible, but typically there are many ways of choosing a sequence of “time slices” that successively sample the behavior of the system. Here are two choices of how to do this for the multiway system above:
✕

In both cases the underlying multicomputational behavior is the same. But the “experience” of the observer is different. And—taking a term used in relativity theory that we’ll later see captures exactly the same idea—we can consider the different choices of time slices as different “reference frames” from which to view what’s going on.
The reference frame isn’t something intrinsic to the underlying multicomputational system (though the system does put constraints on what reference frames are possible). Instead, the reference frame is just something the observer “uses to understand the system”. But as soon as an observer sequentializes time—as I believe we characteristically do—then essentially by definition they must be using some reference frame.
In the ordinary computational paradigm there are fundamental limits on our prediction or understanding of the behavior of systems, associated with the phenomenon of computational irreducibility. And things get even more difficult when it comes to multicomputational systems—where not only can individual threads of history show computational irreducibility, but also these threads can interweave in computationally irreducible ways.
But what will an observer with a certain reference frame perceive about the multicomputational system? Well, it depends on the reference frame. And for example one might imagine that one could have a very elaborate reference frame that somehow “untangles” the computational irreducibility associated with the weaving of different threads and delivers some arbitrarily different “perception” of what’s going on.
But now there’s another crucial point: actual observers such as us don’t use arbitrary reference frames; they only use computationally bounded ones. In other words, there’s a limit to how complicated the reference frame can be, and how much computation it can effectively serve to “decode”.
If the observer is somehow embedded inside the multicomputational system (as must be the case if, for example, the system corresponds to the fundamental physics of our whole universe), then it’s necessary and inevitable that the observer (being a subpart of the whole system)—and the reference frames they use—must be computationally bounded. But the notion of a computationally bounded observer is actually something much more general—and as we’ll see in a series of examples later—it’s a central part of multicomputational models for all sorts of systems.
By the way, we’ve discussed sequentialization in time separately from computational boundedness. But in some sense sequentialization in time is actually just a particular example of computational boundedness that happens to be very obvious and significant for us humans. And potentially some alien intelligence could act as a computationally bounded observer with some other way of “simplifying time”.
But, OK, so we have a multicomputational system that’s behaving in some computationally irreducible way. And we have a computationally bounded observer who’s “parsing” the multicomputational system using particular reference frames. What will that observer perceive about the behavior of the system?
Well, here’s the crucial and surprising thing that’s emerged from our Physics Project: with the setup for multicomputational systems that we’ve described, the observer will almost inevitably perceive the system to follow laws that are simple enough to be captured by mathematical equations. And in the case of physics these laws basically correspond in different situations to general relativity and to quantum mechanics.
In other words, despite the complexity of the underlying behavior of the multicomputational system, the comparative simplicity of the observer makes them inevitably sample only certain “simple aspects” of the whole behavior of the multicomputational system. In computational terms, the observer is perceiving a computationally reducible slice of the whole computationally irreducible behavior of the system.
But what exactly will they perceive? And how much does it depend on the details of the underlying computationally irreducible behavior? Well, here’s something very crucial—and surprising—about multicomputational systems: there’s a lot that can be said quite generically about what observers will perceive, largely independent of the details of underlying computationally irreducible behavior.
It’s deeply related to (but more general than) the result in thermodynamics and statistical physics that there are generic laws for, say, the perceived behavior of gases. At an underlying level, gases consist of large numbers of molecules with complicated and computationally irreducible patterns of motion. But a computationally bounded observer perceives only certain “coarsegrained” features—which don’t depend on the underlying properties of the molecules, and instead correspond to the familiar generic laws for gases.
And so it is in general with multicomputational systems: that quite independent of the details of underlying computationally irreducible behavior there are generic (“computationally reducible”) laws that computationally bounded observers will perceive. The specifics of those laws will depend on aspects of the observer (like their sequentialization of time). But the fact that there will be such laws seems to be an essentially inevitable consequence of the core structure of multicomputational systems.
As soon as one imagines that events can occur “whenever and wherever” rules allow, this inevitably leads to a kind of inexorable combinatorial structure of interwoven “threads of time” that necessarily leads to certain “generic perceptions” by computationally bounded observers. There can be great complexity in the underlying behavior of multicomputational systems. But there’s a certain inevitable overall structure that gets revealed when observers sample the systems. And that inevitable structure can manifest itself in fairly simple laws for certain aspects of the system.
A characteristic feature of systems based on the ordinary computational paradigm is the appearance of computational irreducibility and complex behavior. And with such systems it’s perfectly possible to have computationally bounded observers who sample this complex behavior and reduce it to rather simple features. But what tends to happen is that rather little is left; the observer has in a sense crushed everything out. (Imagine, say, an observer averaging the colors of a complexenoughtoseemrandom sequence of black and white cells to a simple uniform gray.)
But with a multicomputational system, things work differently. Because there’s enough inevitable structure in the fundamental multicomputational setup of the system that even when it’s sampled by a somewhat arbitrary observer there are still nontrivial effective laws that remain. And in the case of fundamental physics we can identify these laws as general relativity and quantum mechanics.
But the point is that because these laws depend only on the fundamental setup of the system, and on certain basic properties of the observer, we can expect that they will apply quite generally to multicomputational systems. Or, in other words, that we can expect to identify overall laws in basically any multicomputational system—and those laws will in effect be direct analogs of general relativity and quantum mechanics.
In ordinary computational systems there’s a very powerful general result: the Principle of Computational Equivalence, which leads to computational irreducibility. And this result also carries over to multicomputational systems. But in multicomputational systems—which basically inevitably have to be sampled by an observer—there’s an additional result: that from the fundamental structure of the system (and the observer) there’s a certain amount of computational reducibility, which leads to certain specific overall laws of behavior.
We might have thought that as we made the underlying structure of models more complicated—going from the ordinary computational paradigm to the multicomputational one—we’d inevitably have less to say about how systems generally behave. But actually—basically because of the interplay of the observer with the fundamental structure of the system—it’s the exact opposite. And that’s very important when it comes to theoretical science. Because it means that systems that seemed like they would show only unreachably complex behavior can actually have features that are described by definite overall laws that are potentially within reach even of the mathematical paradigm.
Or, in other words, if one analyzes things correctly through the multicomputational paradigm, it’s potentially possible to find overall laws even in situations and fields where this seemed hopeless before.
The multicomputational paradigm is something that’s emerging from our Physics Project, and from thinking about fundamental physics. But one of the most powerful things about having a general paradigm for theoretical science is that it implies a certain unity across different areas of science—and by providing a common framework it allows results and intuitions developed in one area to be transferred to others.
So with its roots in fundamental physics the multicomputational paradigm immediately gets to leverage the ideas and successes of physics—and in effect use them to illuminate other areas.
But just how does the multicomputational paradigm work in physics? And how did it even arise there? Well, it’s not something that the traditional mathematical approach to physics would readily lead one to. And instead what basically happened is that having seen how successful the computational paradigm was in studying lots of kinds of systems I started wondering whether something like it might apply to fundamental physics.
It was fairly clear, though, that the ordinary computational paradigm—especially with its “global” view of time—wasn’t a great match for what we already knew about things like relativity in physics. But the pivotal idea that eventually led inexorably to the multicomputational paradigm was a hint from the computational paradigm about the nature of space.
The traditional view in physics had been that space is something continuous, that serves just as a kind of “mathematical source of coordinates”. But in the computational paradigm one tends to imagine that everything is ultimately made of discrete computational elements. So in particular I began to think that this might be true of space.
But how would the elements of space behave? The computational approach would suggest that there must be “finitely specifiable” rules—that effectively define “update events” involving limited numbers of elements of space. But right here is where the multicomputational idea comes in. Because inevitably—across all the elements of space in our universe—there must be a huge number of different ways these updating events could be applied. And the result is that there is no just one unique “computational history”—but instead a whole multiway system with different threads of history for different sequences of updating events.
As we’ll discuss later, it’s the updating events—and the relations between them—that are in a sense really the most fundamental things in the multicomputational paradigm. But in understanding the multicomputational paradigm, and its way of representing fundamental physics, it’s helpful to start instead by thinking about what the updating events act on, or, in effect, the “data structure of the universe”.
A convenient way to set this up is to imagine that the universe—or, in particular, space and everything in it—is defined by a large number of relations between the elements of space. Representing each element of space by an integer, one might have a collection of (in this case, binary) relations like
✕

which can in turn be thought of as a defining a graph (or, in general a hypergraph):
✕

But now imagine a rule like
✕

or, stated pictorially,
✕

that specifies what updating events should occur. There are in general many different places where a rule like this can be applied to a given hypergraph:
✕

So—in a multicomputational fashion—we can define a multiway graph to represent all the possibilities (here starting from {{0,0},{0,0}}):
✕

In our model of fundamental physics, the presence of many different branching and merging paths is a reflection of quantum mechanics—with every path in effect representing a history for the universe.
But to get at least some idea of “what the universe does” we can imagine following a particular path, and seeing what hypergraphs are generated:
✕

And the concept is that after a large number of steps of such a process we’ll get a recognizable representation of an “instantaneous state of space” in the universe.
But what about time? Ultimately it’s the individual updating events that define the progress of time. Representing updating events by nodes, we can now draw a causal graph that shows the “causal relationships” between these updating events—with each edge representing the fact that the “output” from one event is being “consumed” as “input” by another event:
✕

And as is characteristic of the multicomputational paradigm this causal graph reflects the fact that there are many possible sequences in which updating events can occur. But how does this jibe with our everyday impression that a definite sequence of things happen in the universe?
The basic point is that we don’t perceive the whole causal graph in all its detail. Instead, as computationally bounded observers, we just pick some particular reference frame from which to perceive what’s going on. And this reference frame defines a sequence of global “time slices” such as:
✕

Each “time slice” contains a collection of events that—with our reference frame—we take to be “happening simultaneously”. And we can then trace the “steps in the evolution of the universe” by seeing the results of all updating events in successive time slices:
✕

But how do we determine what reference frame to use? The underlying rule determines the structure of the causal graph, and what event can follow what other one. But it still allows huge freedom in the choice of reference frame—in effect imposing only the constraint that if one event follows another, then these events must appear in that order in the time slices defined by the reference frame:
✕

In general each of these different choices of reference frame will lead to a different sequence of “instantaneous states of space”. And in principle one could imagine that some elaborately chosen reference frame could lead to arbitrarily pathological perceived behavior. But in practice there is an important constraint on possible reference frames: as computationally bounded observers we are limited in the amount of computational effort that we can put into the construction of the reference frame.
And in general to achieve a “pathological result” we’ll typically have to “reverse engineer” the underlying computational irreducibility of the system—which we won’t be able to do with a reference frame constructed by a computationally bounded observer. (This is directly analogous to the result in the ordinary computational paradigm that computationally bounded observers effectively can’t avoid perceiving the validity of the Second Law of Thermodynamics.)
So, OK, what then will an observer perceive in a system like the one we’ve defined? With a variety of caveats the basic answer is that in the limit of a “sufficiently large universe” they’ll perceive average behavior that’s simple enough to describe mathematically, and specifically to describe as following Einstein’s equations from general relativity. And the key point is that this is in a sense a generic result (a bit like the gas laws in thermodynamics) that’s independent of the details of the underlying rule.
But there’s more to this story. We’ll talk about it a bit more formally in the next section. But the basic point is that so far we’ve just talked about picking reference frames in a “spacetime causal graph”. But ultimately we have to consider the whole multiway graph of all possible sequences of update events. And then we have to figure out how an observer can set up some kind of reference frame to give them a perception of what’s going on.
At the core of the concept of a reference frame is the idea of being able to treat certain things (typically events) as somehow “equivalent”. In the case of the causal graphs we’ve discussed so far, what we’re doing is to treat certain events as equivalent in the sense that they can be viewed as happening “in the same time slice” or effectively “simultaneously”. But if we just pick two events at random, there’s no guarantee that it’ll be consistent to consider them to be in the same time slice.
In particular, if one event causally depends on another (in the sense that its input requires output from the other), then it can only occur in a later time slice. And in this situation (which corresponds to one event being reachable from the other by following directed edges in the causal graph) we can say that these events are “timelike separated”. Similarly, if two events can occur in the same time slice, we can say that they are “spacelike separated”. And in the language of relativity, this means that our “time slices” are spacelike hypersurfaces in spacetime—or at least discrete analogs of them.
So what about with the full multiway graph? We can look at every event that occurs in every state in the multiway graph. And there are then basically three kinds of separation between events. There can be timelike separation, in the sense that one event causally depends on another. There can be spacelike separation, in the sense that different events occur in different parts of space that are not causally connected. And then there’s a third case, which is that different events can occur on different branches of the multiway graph—in which case we say that they’re branchlike separated.
And in general when we pick a reference frame in the full multiway system, we can have time slices that contain both spacelike and branchlikeseparated events. What’s the significance of this? Basically, just as spacelike separation is associated with the concept of ordinary space, branchlike separation is associated with a different kind of space, that we call branchial space.
With a multiway graph of the kind we’ve drawn above (in which every node represents a possible “complete state of the universe”), we can investigate “pure branchial space” by looking at time slices in the graph:
✕

For example, we can construct “branchial graphs” by looking at which states are connected by having immediate common ancestors. And in effect these branchial graphs are the branchialspace analogs of the hypergraphs we’ve constructed to represent the instantaneous state of ordinary space:
✕

But now, instead of representing ordinary space—with features like general relativity and gravity—they represent something different: they represent a space of quantum states, with the branchial graph effectively being a map of quantum entanglements.
But to define a branchial graph, we have to pick the analog of a reference frame: we have to say what branchlikeseparated events we consider to happen “at the same time”. In the case of spacelikeseparated events it’s fairly easy to interpret that what we get from a reference frame is a view of what’s happening throughout space at a particular time. But what’s the analog for branchlikeseparated events?
In effect what we’re doing when we make a reference frame is to treat as equivalent events that are happening “on different branches of history”. At first, that may seem like a very odd thing to do. But the thing to understand is that as entities embedded in the same universe that’s generating all these different branches of history, we too are branching. So it’s really a question of how a “branching brain” will perceive a “branching universe”. And that depends on what reference frame (or “quantum observation frame”) we pick. But as soon as we insist that we maintain a single thread of experience, or, equivalently, that we sequentialize time, then—together with computational boundedness—this puts all sorts of constraints on the reference frames we pick.
And just as in the case of ordinary space, the result is that it ultimately seems to be possible to give a fairly simple—and essentially mathematical—description of what the observer will perceive. And the answer is that it basically appears to correspond to quantum mechanics.
But there’s actually more to it. What we get is a kind of generic multicomputational result—that doesn’t depend on the details of underlying rules or particular choices of reference frames. Structurally it’s basically the same result as for ordinary space. But now it’s interpreted in terms of branchial space, quantum states, and so on. And what was interpreted as the geodesic equation of general relativity now essentially gets interpreted as the path integral of quantum mechanics.
In a sense it’s then a basic consequence of the multicomputational nature of fundamental physics that quantum mechanics is the same theory as general relativity—though operating in branchial space rather than ordinary space.
There are important implications here for physics. But there are also general implications for all multicomputational systems. Because the sophisticated definitions and phenomena of both general relativity and quantum mechanics we can now expect will have analogs in any system that can be modeled in a multicomputational way, whatever field of science it may come from.
So, later, when we talk about the application of the multicomputational paradigm to other fields, we can expect to talk and reason in terms of things we know from physics. So we’ll be able to bring in light cones, inertial frames, time dilation, black holes, the uncertainty principle, and much more. In effect, the common use of the multicomputational paradigm will allow us to leverage the development of physics—and its status as the most advanced current area of theoretical science—to “physicalize” all sorts of other areas, and shed new light on them. As well, of course, as taking ideas and intuition from other areas (including ones much closer to everyday experience) and “applying them back” to physics.
In the previous section, we discussed how the multicomputational paradigm plays out in the particular case of fundamental physics. And in many ways, physics is probably a fairly typical application of the paradigm. But there are some special features it has that add complication, though also add concreteness.
So what are the ultimate foundations of the multicomputational paradigm? At its core, I think it’s fair to say that the paradigm is about events and their relationships—where the events are defined by some kind of rules.
What happens in an event? It’s a bit like the application of a function. It takes some set of “expressions” or “tokens” as input, and returns some other set as output.
In a simple ordinary computational system there might just be one input and one output expression for each event, as in x ⟼ f[x], leading to a trivial graph for the sequence of states reached in the evolution of the system:
✕

But now let’s imagine that there are two expressions generated by each event: x ⟼ {f[x], g[x]}. Then the evolution of the system can instead be represented by the tree:
✕

But what starts making a nontrivial multiway graph is when some states that are generated in different ways end up being the same, so that they get merged in the graph. As an example, consider the rule
✕

The multiway graph produced in this case is
✕

where now we see merging even at the top of the graph, associated, for example, with the equivalence of 1 + 1 + 1 and 2 × 1 + 1. And as we can see, even with this very simple rule, the multiway graph is not so simple.
But there’s still an important simplifying feature in the system we’re considering—that affects causal dependence: in all its events complete states (here integers) are used as input and output. But in a stringbased system (say with a rule like A → BBB, BB → A) the situation is different. Because now the events can act on just part of the string:
✕

And it’s the same when we use hypergraphs—as in our models of fundamental physics. The events don’t typically apply to complete hypergraphs, but instead to subhypergraphs within them.
But let’s look a bit more carefully at the string case above. When we see different update events for a given string, we can identify two different cases. The first is a case like
✕

where the updates don’t overlap, and the second is a case like
✕

where they do. And what we’ll find is that in the first case we can consider the events to be purely spacelike separated, while in the second they are also branchlike separated.
The full multiway graph above effectively shows all possible histories for our system—obtained by running all possible update events on each state (i.e. string) that is generated.
But what if we choose for example just to use the first update event found in a lefttoright scan of each state (so we’ve got a “sequential substitution system”)? Then we’d get a “singleway” graph with no branching:
✕

As another “evaluation strategy” we could scan the string at each step, applying all updates that don’t overlap:
✕

Both the results we’ve just got are subgraphs of the full multiway graph. But they both have the feature that they effectively just yield a single sequence of states for the system. In the first case this is obvious. In the second case there are little “temporary branchings” but they always merge back into a single state. And the reason for this is that with the evaluation strategy we’ve used, we only ever get spacelikeseparated events, so there are no “true multiway branches”, as would be generated by branchlikeseparated events.
But even though ultimately there’s just a “single branch of history” there’s a “shadow” of the presence of other branches visible in the nontrivial causal graph that shows causal relationships between updating events:
✕

So what about our models of physics? In exploring them it’s often convenient not to track the whole multiway system but instead just to look at the results from a particular “evaluation strategy”. In a hypergraph there’s no obvious “scan order”, but we still often use a strategy that—like our second string strategy above—attempts to “do whatever can be done in parallel”.
Inevitably, though, there’s a certain arbitrariness to this. But it turns out there’s a more “principled” way to set things up. The basic idea is not to think about complete states (like strings or hypergraphs) but instead just to think separately about the “tokens” that will be used as inputs and outputs in events.
And—giving yet more evidence that even though hypergraphs may be hard for us humans to handle, there’s great naturalness to them—it’s considerably easier to do this for hypergraphs than for strings. And the basic reason is that in a hypergraph each token automatically comes “appropriately labeled”.
The relevant tokens for hypergraphs are hyperedges. And in a rule like
✕

we see that two “hyperedge tokens” are used as input, and four “hyperedge tokens” are generated as output. And the point is that when we have a hypergraph like
✕

that corresponds for example to
✕

we can just think of this as an unordered “sea” (or multiset) of hyperedges, where each event will just pick up some pair of hyperedges that match the pattern {{x, y}, {y, z}}. But what does it mean to “match the pattern”? x, y, z can each correspond to any node of the hypergraph (i.e. for our model of physics, any atom of space). But the key constraint is that the two instances of y must refer to the same node.
If we tried to do the same thing for strings, it’d be considerably more difficult. Because then the relevant tokens would be individual characters in the string. But whereas in a hypergraph every token is a hyperedge that can be identified from the uniquely named nodes it contains, every A or every B in a string is usually thought of as just being the same—giving us no immediate way to identify distinct tokens in our system.
But assuming we have a way to identify distinct tokens, we can consider representing the evolution of our system just in terms of events applied to tokens (or what we can call a “tokenevent graph”). This is going to get a bit complicated. But here’s an example of how it works for the hypergraph system we’ve just shown. Each blue node is a token (i.e. a hyperedge) and each yellow node is an event:
✕

What’s going on here? At each step shown, there’s a token (i.e. blue node) for every hyperedge generated at that step. Let’s compare with the overall sequence of hypergraphs:
✕

The initial state contains two hyperedges, so there are two tokens at the top of the tokenevent graph. Both these hyperedges are “consumed” by the event associated with applying the rule—and out of that event come four new hyperedges, represented by the four tokens on the next step.
Let’s look in a little more detail at what’s happening. Here is the beginning of the tokenevent graph, annotated with the actual hyperedges represented by each token (the numbers in the hyperedges are the “IDs” assigned to the “atoms of space” they involve):
✕

At the first step our rule {{x,y},{y,z}} → {{w,y},{y,z},{z,w},{x,w}} consumes the hyperedges {0,0} and {0,0} and generates four new hyperedges. (Note that the {0,0} on step 2 is considered a “new hyperedge”, even though it happens to have the same content as both hyperedges on step 1; more about this later.) At the second step, the rule consumes {1,0} and {0,0}. And at the third step, there are two invocations of the rule (i.e. two events), each consuming two hyperedges, and generating four new ones.
And looking at this one might ask “Why did the second event consume {1,0} and {0,0} rather than, say, {1,0} and one of the {0,1} tokens?” Well, the answer is that the tokenevent graph we’re showing is just for a specific possible history, obtained with a particular “evaluation strategy”—and this is what that strategy picked to do.
But it’s possible to extend our tokenevent graph to show not just what can happen for a particular history, but for all possible histories. In effect what we’re getting is a finergrained version of our multiway graph, where now the (blue) nodes are not whole states (i.e. hypergraphs) but instead just individual tokens (i.e. hyperedges) from inside those states.
Here’s the result for a single step:
✕

There are two possible events because the two initial hyperedges given here can in effect be consumed in two different orders. Continuing even one more step things rapidly get significantly more complicated:
✕

Let’s compare this with our ordinary multiway graph (including events) for the same system:
✕

Why is this so much simpler? First, it’s because we’ve collected the individual tokens (i.e. hyperedges) into complete states (i.e. hypergraphs)—“knitting them together” by seeing which atoms they have in common. But we’re doing something else as well: even if hypergraphs are generated in different ways, we’re conflating them whenever they’re “the same”. And for hypergraphs our definition of “being the same” is that they’re isomorphic, in the sense that we can transform them into each other just by permuting node labels.
Note that if we don’t conflate isomorphic hypergraphs the multiway graph we get is
✕

which corresponds much more obviously to the tokenevent graph above.
When we think about multicomputational systems in general, the conflation of “identical” (say by isomorphism) states is in a sense the “lowestlevel act” of an observer. The “true underlying system” might in some sense “actually” be generating lots of separate, identical states. But if the observer can’t tell them apart then we might as well say they’re all “the same state”. (Of course, when there are different numbers of paths that lead to different states, this can affect the weightings of these different states—and indeed in our model of physics this is where the different magnitudes of quantum amplitudes for different states come from.)
It seems natural and obvious to conflate hypergraphs if they’re isomorphic. But actual observers (say humans observing the physical universe) typically conflate much, much more than that. And indeed when we say that we’re operating in some particular reference frame we’re basically defining potentially huge collections of states to conflate.
But there’s actually also a much lower level at which we can do conflation. In the tokenevent graphs that we’ve looked at so far, every token generated by every event is shown as a separate node. But—as the labeled versions of these graphs make clear—many of these tokens are actually identically the same, in the sense that they’re just direct copies created by our way of computing (and rendering) the tokenevent graph.
So what about conflating all of these—or in effect “deduplicating” tokens so that we have just one unique shared representation of every token, regardless of how many times or where it appears in the original graph?
Here’s the result after doing this for the 2step version of the tokenevent graph above:
✕

This deduplicatedtokenevent graph in essence records every “combinatorially possible” “distinct event” that yields a “transition” between distinct tokens. But while sharing the representation of identical tokens makes the graph much simpler, the graph now no longer has a definite notion of “progress in time”: there are edges “going both up and down”, sometimes even forming loops (i.e. “closed timelike curves”).
So how can this graph represent the actual evolution of the original system with a particular evaluation strategy (or, equivalently, as “viewed in a particular reference frame”)? Basically what we need are some kind of “markers” that move around the graph from “step to step” to indicate which tokens are “reached” at each step. And doing this, this is what we get for the “standard evaluation strategy” above:
✕

In a sense a deduplicated tokenevent graph is the ultimate minimal invariant representation of a multicomputational system. (Note that in physics and elsewhere the graph is typically infinite.) But any particular observer will effectively make some kind of sampling of this graph. And in working out this sampling we’re going to encounter issues about knitting together states and reference frames—that are ultimately equivalent to what we saw before from our earlier perspective on multiway systems.
(Note that if we had a deduplicated tokenevent graph with markers that is finite then this would basically be a Petri net, with decidable reachability results, etc. But in most relevant cases, our graphs won’t be finite.)
So although tokenevent graphs—even in deduplicated form—don’t ultimately avoid the complexities of other representations of multicomputational systems, they do make some things easier to discuss. For example, in a tokenevent graph there’s a straightforward way to read off whether two events are branchlike or spacelike separated. Consider the “all histories” tokenevent graph we had before:
✕

To figure out the type of separation between events, we just need to look at their first common ancestor. If it’s a token, that means the events are branchlike separated (because there must have been some “ambiguity” in how the token was transformed). But if the common ancestor is an event, that means the events we’re looking at are spacelike separated. So, for example, events 1 and 2 here are branchlike separated, as are 4 and 5. But events 4 and 9 are spacelike separated.
Note that if instead of looking at an “all histories” tokenevent graph, we restrict to a single history then there will only be spacelike (and timelike) separated events:
✕

A tokenevent graph is in a sense a lowestlevel representation of a multicomputational system. But when an observer tries to “see what’s going on” in the system, they inevitably conflate things together, effectively perceiving only certain equivalence classes of the lowestlevel elements. Thus, for example, an observer might tend to “knit together” tokens into states, and pick out particular histories or particular sequences of time slices—corresponding to using what we can call a certain “reference frame”. (In mathematical terms, we can think of particular histories as like fibrations, and sequences of time slices as like foliations. )
And in studying multicomputational systems of different types a key question is what kinds of reference frames are “reasonable” based on some general model for the observer. And one almost inevitable constraint is that it should only require bounded computational effort to construct the reference frame.
Our Physics Project then suggests that in appropriate largescale limits specific structures like general relativity and quantum mechanics should then emerge. And it seems likely that this is a general and very powerful result that’s essentially inexorably true about the limiting behavior of any multicomputational system.
But if so, the result represents an elaborate—and unprecedented—interweaving of fundamentally computational and fundamentally mathematical concepts. Maybe it’ll be possible to use a generalization of category theory as a bridge. But it’s going to involve not only discussing ways in which operations can be applied and composed, but also what the computational costs and constraints are. And in the end computational concepts like computational reducibility are going to have to be related to mathematical concepts like continuity—I suspect shedding important new light all around.
Before closing our discussion of the formalism of multicomputation there’s something perhaps still more abstract to discuss—that we can call “rulial multicomputation”. In ordinary multicomputation we’re interested in seeing what happens when we follow certain rules in all possible ways. But in rulial multicomputation we go a step further, and also ask about following all possible rules.
One might think that following all possible rules would just “make every possible thing happen”—so there wouldn’t be much to say. But the crucial point is that in a (rulial) multiway system, different rules can lead to equivalent results, yielding a whole elaborately entangled structure of possible states and events.
But at the level of the tokenevent formalism we’ve discussed above, rulial multicomputation in some sense just “makes events diverse”, and more like tokens. For in a rulial multiway system, there are lots of different kinds of events (representing different rules)—much as there are different kinds of tokens (containing, for example, different underlying elements or atoms).
And if we look at different events in a rulial multiway system, there is now another possible form of separation between them: in addition to being timelike, spacelike or branchlike separated, the events can also be rulelike separated (i.e. be based on different rules). And once again we can ask about an observer “parsing” the (rulial) multiway system, and defining a reference frame that can, for example, treat events in a single “rulelike hypersurface” as equivalent.
I’ve discussed elsewhere the rather remarkable implications of rulial multiway systems for our understanding of the physical (and mathematical) universe, and its fundamental formal necessity. But here the main point to make is that the presence of many possible rules doesn’t fundamentally affect the formalism for multicomputational systems; it just requires the observer to define yet more equivalences to reduce the “raw multiway behavior” to something computationally simple enough to parse.
And although one might have thought that adding the concept of multiple rules would just make everything more complicated, I won’t be surprised if in the end the greater “separation” between “raw behavior” and what the observer can perceive will actually make it easier to derive robust general conclusions about overall behavior at the level of the observer.
From the basic definitions of multicomputation it’s hard to have much intuition about how multicomputational systems will work. But knowing how multicomputation works in our model of fundamental physics immediately gives us not only powerful intuition, but also all sorts of metaphors and language for describing multicomputation in pretty much any possible setting.
As we saw in the previous section, at the lowest level in any multicomputational system there are what we can call (in correspondence with physics) “events”—that represent individual applications of rules, “progressing through time”. We can think of these rules as operating on “tokens” of some kind (and, yes, that’s a term from computation, not physics). And what these tokens represent will depend on what the multicomputational system is supposed to be modeling. Often (as in our Physics Project) the tokens will consist of combinations of elements—where the same elements can be shared across different tokens. (In the case of our Physics Project, we view the elements as “atoms of space”, with the tokens representing connections among them.)
The sharing of elements between tokens is one way in which the tokens can be “knitted together” to define something like space. But there is another, more robust way as well: whenever a single event produces multiple tokens it effectively defines a relation between those tokens. And the map of all such relations—which is essentially the tokenevent graph—defines the way that different tokens are knitted together into some kind of generalized spacetime structure.
At the level of individual events, ideas from the theory and practice of computation are useful. Events are like functions, whose “arguments” are incoming tokens, and whose output is one or more outgoing tokens. The tokens that exist in a certain “time slice” of the tokenevent graph together effectively represent the “data structure” on which the functions are acting. (Unlike in basic sequential programming, however, the functions can act in parallel on different parts of the data structure.) The whole tokenevent graph then gives the complete “execution history” of how the functions act on the data structure. (In an ordinary computational system, this “execution history” would essentially form a single chain; a defining feature of a true multicomputational system is that this history instead forms a nontrivial graph.)
In understanding the analogy with our everyday experience with physics, we’re immediately led to ask what aspect of the tokenevent graph corresponds to ordinary, physical space. But as we’ve discussed, the answer is slightly complicated. As soon as we set up a foliation of the tokenevent graph, effectively dividing it into a sequence of time slices, we can say that the tokens on each slice correspond to a certain kind of space, “knitted together” by the entanglements of the tokens defined by their common ancestry in events.
But the kind of space we get is in general something beyond ordinary physical space—effectively something we can call “multispace”. In the specific setup of our Physics Project, however, it’s possible to define at least in certain limits a decomposition of this space into two components: one that corresponds to ordinary physical space, and one that corresponds to what we call branchial space, that is effectively a map of entangled possible quantum states. In multicomputational systems set up in different ways, this kind of decomposition may work differently. But given our everyday intuition—and mathematical physics knowledge—about ordinary physical space it’s convenient first to focus on this in describing the general “physicalization” of multicomputational systems.
In our Physics Project ordinary “geometrical” physical space emerges as a very largescale limit of slices of the tokenevent graph that can be represented as “spatial hypergraphs”. In the Physics Project we imagine that at least in the current universe, the effective dimension of the spatial hypergraph (measured, for example, through growth rates of geodesic balls) corresponds to the observed 3 dimensions of physical space. But it’s important to realize that the underlying structure of multicomputation doesn’t in any way require such a “tame” limiting form for space—and in other settings (even branchial space in physics) things may be much wilder, and much less amenable to presentday mathematical characterization.
But the picture in our Physics Project is that even though there is all sorts of computationally irreducible—and seemingly random—underlying behavior, physical space still has an identifiable largescale limiting structure. Needless to say, as soon as we talk about “identifiable structure” we’re implicitly assuming something about the observer who’s perceiving it. And in seeing how to leverage intuition from physics, it’s useful to discuss what we can view as the simpler case of thermodynamics and statistical mechanics.
At the lowest level something like a gas consists of large numbers of discrete molecules interacting according to certain rules. And it’s almost inevitable that the detailed behavior of these molecules will show computational irreducibility—and great complexity. But to an observer who just looks at things like average densities of molecules the story will be different—and the observer will just perceive simple laws like diffusion.
And in fact it’s the very complexity of the underlying behavior that leads to this apparent simplicity. Because a computationally bounded observer (like one who just looks at average densities) won’t be able to do more than just read the underlying computational irreducibility as being like “simple randomness”. And this means that for such an observer it’s going to be reasonable to model the overall behavior by using mathematical concepts like statistical averaging, and—at least at the level of that observer—to describe the system as showing computationally reducible behavior represented, say, by the diffusion equation.
It’s interesting to note that the emergence of something like diffusion depends on the presence of certain (identifiable) underlying constraints in the system—like conservation of the number of molecules. Without such constraints, the underlying computational irreducibility would lead to “pure randomness”—and no recognizable largerscale structure. And in the end it’s the interplay of identifiable underlying constraints with identifiable features of the observer that leads to identifiable emergent computational reducibility.
And it’s very much the same kind of thing with multicomputational systems—except that the “identifiable constraints” are much more abstract ones having to do with the fundamental structure of multicomputation. But much as we can say that the detailed computationally irreducible behavior of underlying molecules leads to things like largescale fluid mechanics at the level of practical (“coarsegrained”) observers, so also we can say that the detailed computationally irreducible behavior of the hypergraph that represents space leads to the largescale structure of space, and things like Einstein’s equations.
And the important point is that because the “constraints” in multicomputational systems are generic features of the basic abstract structure of multicomputation, the emergent laws like Einstein’s equations can also be expected to be generic, and to apply with appropriate translation to all multicomputational systems perceived by observers that operate at least somewhat like the way we operate in perceiving the physical universe.
Any system in which the same rules get applied many times must have a certain ultimate uniformity to its behavior, manifest, for example, in the “same laws” applying “all over the system”. And that’s why, for example, we’re not surprised that physical space seems to work the same throughout the physical universe. But given this uniformity, how do there come to be any identifiable features or “places” in the universe, or, for that matter, in other kinds of systems that are constructed in similar ways?
One possibility is just that the observer can choose to name things: “I’ll call this token ‘Tokie’ and then I’ll trace what happens, and describe the behavior of the universe in terms of the ‘adventures of Tokie’”. But as such, this approach will inevitably be quite limited. Because a feature of multicomputational systems is events are continually happening, consuming existing tokens and creating new ones. In physics terms, there is nothing fundamentally constant in the universe: everything in it (including space itself) is being continually recreated.
So how come we have any perception of permanence in physics? The answer is that even though individual tokens are continually being created and destroyed, there are overall patterns that are persistent. Much like vortices in a fluid, there can for example be essentially topological phenomena whose overall structure is preserved even though their specific component parts are continually changed.
In physics, those “topological phenomena” presumably correspond to things like elementary particles, with all their various elaborate symmetries. And it’s not clear how much of this structure will carry over to other multicomputational systems, but we can expect that there will be some kinds of persistent “objects”—corresponding to certain pockets of local computational reducibility.
An important idea in physics is the concept of “pure motion”: that “objects” can “move around in space” and somehow maintain their character. And once again the possibility of this depends on the observer, and on what it means that their “character is maintained”. But we can expect that as soon as there is a concept of space in a multicomputational system there will also be a concept of motion.
What can we say about motion? In physics, we can discuss how it will be perceived in different reference frames—and for example we define inertial frames that explore space and time differently precisely so as to “cancel out motion”. This leads to phenomena like time dilation, which we can view as a reflection of the fact that if an object is “using its computational resources to move in space” then it has less to devote to its evolution in time—so it will “evolve less in a certain time” than if it wasn’t moving.
So if we can identify things like motion (and, to make it as simple as possible, things like inertial frames) in any multicomputational system, we can expect to see phenomena like time dilation—though potentially translated into quite different terms.
What about phenomena like gravity? In physics, energy (and mass) act as a “source of gravity”. But in our models of physics, energy has a rather simple (and generic) interpretation: it is effectively just the “density of activity” in the multicomputational system—or the number of events in a certain “region of space”.
Imagine that we pick a token in a multicomputational system. One question we can ask is: what is the shortest path through the tokenevent graph to get to some specific other token? There’ll be a “light cone” that defines “how far in space” we can get in a certain time. But in general in physics terms we can view the shortest path as defining a spacetime geodesic. And now there’s a crucial—but essentially structural—fact: the presence of activity in the tokenevent graph inevitably effectively “deflects” the geodesic.
And at least with the particular setup of our Physics Project it appears that that deflection can be described (in some appropriate limit) by Einstein’s equations, or in other words, that our system shows the phenomenon of gravity. And once again, we can expect that—assuming there is any similar kind of notion of space, or similar character of the observer—a phenomenon like gravity will also show up in other multicomputational systems.
Once we have gravity, what about phenomena like black holes? The concept of an event horizon is immediately something quite generic: it is just associated with disconnection in the causal graph, which can potentially occur in basically any multicomputational system.
What about a spacetime singularity? In the most familiar kind of singularity in physics (a “spacelike singularity” of the kind that appears at the center of a nonrotating black hole spacetime), what fundamentally happens is that there is a piece of the tokenevent graph to which no rules apply—so that in essence “time ends” there. And once again, we can expect that this will be a generic phenomenon in multicomputational systems.
But there’s more to say about this. In general relativity, the singularity theorems say that when there’s “enough energy or mass” it’s inevitable that a singularity will be formed. And we can expect that the same kind of thing will happen in any multicomputational system, though potentially it’ll be interpreted in very different terms. (By the way, the singularity theorems implicitly depend on assumptions about the observer and about what “states of the universe” they can prepare, and these may be different for other kinds of multicomputational systems.)
It’s worth mentioning that when it comes to singularities, there’s a computational characterization that may be more familiar than the physics one (not least since, after all, we don’t have direct experience of black holes). We can think of the progress of a multicomputational system through time as being like a process of evaluation in which rules are repeatedly applied to transform whatever “input” was given. In the most familiar case in physics, this process will just keep going forever. But in the more familiar case in practical computing, it will eventually reach a fixed point representing the “result of the computation”. And this fixed point is the direct analog of a “time ends” singularity in physics.
When we have a large multicomputational system we can expect that—like in physics—it will seem (at least to appropriate observers, etc.) like an approximate continuum of some kind. And then it’s essentially inevitable that there will be a whole collection of rather general “local” statements about the behavior that can be made. But what if we look at the multicomputational system as a whole? This is the analog of studying cosmology in physics. And many of the same concepts can be expected to apply, with, for example, the initial conditions for the multicomputational system playing the role of the Big Bang in physics.
In the history of physics over the past century or so three great theoretical frameworks have emerged: statistical mechanics, general relativity and quantum mechanics. And when we look at multicomputational systems we can expect to get intuition—and results—from all three of these.
So what about quantum mechanics? As I mentioned above, quantum mechanics is—in our model of physics—basically just like general relativity, except played out not in ordinary physical space, but instead in branchial space. And in many ways, branchial space is a more immediate kind of space to appear in multicomputational systems than physical space. But unlike physical space, it’s not something about which we have everyday experience, and instead to think about it we tend to have to rely on the somewhat elaborate traditional formalism of quantum mechanics.
A key question about branchial space both in physics and in other multicomputational systems is how it can be coordinatized (and, yes, that’s inevitably a question about observers). In general the issue of how to put meaningful “numerical” coordinates on a very “nonnumerical space” (where the “points of the space” are for example tokens corresponding to strings or hyperedges or whatever) is a difficult one. But the formalism of quantum mechanics makes for example the suggestion of thinking in terms of complex numbers and phases.
The spaces that arise in multicomputational systems can be very complicated, but it’s rather typical that they can be thought of as somehow “curved”, so that, for example, “parallel” lines (i.e. geodesics) don’t stay a fixed distance apart, and that “squares” drawn out of geodesics won’t close. And in our model of physics, this kind of phenomenon not only yields gravity in physical space, but also yields things like the uncertainty principle when applied to branchial space.
We might at first have imagined that a theory of physics would be specific to physics. But as soon as we imagine that physics is multicomputational then that fact alone leads to a robust and inexorable structure that should appear in any other multicomputational system. It may be complicated to know quite what the detailed translations and interpretations are for other multicomputational systems. But we can expect that the core phenomena we’ve identified in physics will somehow be reflected there. So that through the common thread of multicomputation we can leverage the tower of successes in physics to shed light on all sorts of systems in all sorts of fields.
We’ve talked about the nature of the multicomputational paradigm, and about its application in physics. But where else can it be applied? Already in the short time I’ve been thinking directly about this, I’ve identified a remarkable range of fields that seem to have great potential for the multicomputational paradigm, and where in fact it seems quite conceivable that by using the paradigm one might be able to successfully unlock what have been longunresolved foundational problems.
Beginning a few decades ago, the computational paradigm also helped shed new light on the foundations of all sorts of fields. But typically its most important message has been: “Great and irreducible complexity arises here—and limits what we can expect to predict or describe”. But what’s particularly exciting about the multicomputational paradigm is that it potentially delivers a quite different message. It says that even though the underlying behavior of a system may be mired in irreducible complexity, it’s still the case that those aspects of the system perceived by an observer can show predictable and reducible behavior. Or, in other words, that at the level of what the observer perceives, the system will seem to follow definite and understandable laws.
But that’s not all. As soon as one assumes that the observer in a multicomputational system is enough “like us” to be computationally bounded and to “sequentialize time” then it follows that the laws they will perceive will inevitably be some kind of translated version of the laws we’ve already identified in fundamental physics.
Physics has always been a standout field in its ability to deliver laws that have a rich (typically mathematical) structure that we can readily work with. But with the multicomputational paradigm there’s now the remarkable possibility that this feature of physics could be transported to many other fields—and could deliver there what’s in many cases been seen as a “holy grail” of finding “physicslike” laws.
One might have thought that what would be required most would be to do a successful “reduction” to an accurate model of the primitive parts of the system. But actually what the multicomputational paradigm indicates is that there’s a certain inexorability to what happens, independent of those details. The challenge, though, is to figure out what an “observer” of a certain kind of system will actually perceive. In other words, successfully finding overall laws isn’t so much about applying reductionism to the system; it’s more about understanding how observers fit together the details of the system to synthesize their perception of it.
So what kinds of systems can we expect to describe in multicomputational terms? Basically any kind of system where there are many component parts that somehow “operate independently in parallel”—interacting only through certain “events”. And the key idea is that there are many possible detailed histories for the system—but in the multicomputational paradigm we look at all of them together, thereby building up a structure with inexorable properties, at least as perceived by certain general kinds of observers.
In areas like statistical physics it’s been common for a century to think about “ensembles of possible states” for a system. But what’s different about the multicomputational paradigm is that it’s not just looking “statically” at “possible states”; instead it’s “taking a bigger gulp”, and looking at all possible whole histories for the system, essentially developing through time. And, yes, a slice at a particular time will show some ensemble of possible states—but they’re states generated by the entangled possible histories of the system, not just states “statically” and combinatorially generated from the possible configurations of the system.
OK, so what are some areas to which the multicomputational paradigm can potentially be applied? There are many. But among the examples I’ve at least begun to investigate are metamathematics, molecular biology, evolutionary biology, molecular computing, neuroscience, machine learning, immunology, linguistics, economics and distributed computing.
So how can one start developing a multicomputational model in a particular area? Ultimately one wants to see how the structure and behavior of the system can be broken down into elementary “tokens” and “events”. The network of events will define some way in which the histories of tokens are entangled, and in which the tokens are effectively “knitted together” to define something that in some limiting sense can be interpreted as some kind of space. Often it’ll at first seem quite unclear that anything significant can be built up from the things one identifies as tokens and events—and the emergent space may seem more familiar, as it does in the case of physical space in our model of physics.
OK, so what might the tokens and events be in particular areas? I’m not yet sure about most of these. But here are a few preliminary thoughts:
✕

It’s important to emphasize that the multicomputational paradigm is at its core not about particular histories (say particular interactions between organisms or particular words spoken) but about the evolution of all possible histories. And in most cases it won’t have things to say about particular histories. But instead what it will describe is what an observer sampling the whole multicomputational process will perceive.
And in a sense the nub of the effort of using the multicomputational paradigm to find new laws in new fields is to identify just what it is that one should be looking at, or in effect what one would think an observer should do.
Imagine one’s looking at the behavior of a gas. Underneath there’s all sorts of irreducible complexity in the particular motions of the molecules. But if we consider the “correct” kind of observer, we’ll just sample the gas at a level where they’ll perceive overall laws like the diffusion equation or the gas laws. And in the case of a gas we’re immediately led to that “correct” kind of observer, because it’s what we get with our usual human sensory perception.
But the question is what the appropriate “observer” for the analog of molecules in metamathematics or linguistics might be. And if we can figure that out, we’ll potentially have overall laws—like diffusion or fluid dynamics—that apply in these quite different fields.
Let’s start by talking about perhaps the most abstract potential application area: metamathematics. The individual “tokens of mathematics” can be mathematical statements, written in some symbolic form (as they would be in the Wolfram Language). In a sense these mathematical statements are like the hyperedges of our spatial hypergraph in physics: they define relations between elements, which in the case of physics are “atoms of space” but in the case of mathematics are “literal mathematical objects”, like the number 1 or the operation Plus (or at least single instances of them).
Now we can imagine that the “state of mathematics” at some particular time in its development consists of a large number of mathematical statements. Like the hyperedges in the spatial hypergraph for physics, these mathematical statements are knitted together through their common elements (two mathematical statements might both refer to Plus, just as two hyperedges might both refer to a particular atom of space).
What is the “evolution of mathematics” like? Basically we imagine that there are laws of inference that take, say, two mathematical statements and deduce another one from them, either using something like structural substitution, or using some (symbolically defined) logical principle like modus ponens. The result of repeatedly applying a law of inference in all possible ways is to build up a multiway graph of—essentially—what statements imply what other ones, or in other words, what can be proved from what.
But what does a human mathematician perceive of all this? Most mathematicians don’t operate at the level of the raw proof graph and individual raw formalized mathematical statements. Instead, they aggregate together the statements and their relationships to form more “humanlevel” mathematical concepts.
In effect that aggregation can be thought of as choosing some “mathematical reference frame”—a slice of metamathematical space that can successfully be “parsed” by a human “mathematical observer”. No doubt there will be certain typical features of that reference frame; for example it might be set up so that things are “sufficiently organized” that “category theory works”, in the sense that there’s enough uniformity to be able to “move between categories” while preserving structure.
There are both familiar and unfamiliar features of this emerging picture. There are the analog of light cones in “proof space” that define dependencies between mathematical results. There are geodesics that correspond to shortest derivations. There are regions of “metamathematical space” (the slices of proof space) that might have higher “densities of proofs” corresponding to more interconnected fields of mathematics—or more “metamathematical energy”. And as part of the generic behavior of multicomputational systems we can expect an analog of Einstein’s equations, and we can expect that “proof geodesics” will be “gravitationally attracted” to regions of higher “metamathematical energy”.
In most areas of metamathematical space there will be “proof paths” that go on forever, reflecting the fact that there may be no path of bounded length that will reach a given statement, so that the question of whether that statement is present at all can be considered undecidable. But in the presence of large amounts of “metamathematical energy” there’ll effectively be a metamathematical black hole formed. And where there’s a “singularity in metamathematical space” there’ll be a whole collection of proof paths that just end—effectively corresponding to a decidable area of mathematics.
Mathematics is normally done at the level of “specific mathematical concepts” (like, say, algebraic equations or hyperbolic geometry)—that are effectively the “populated places” (or “populated reference frames”) of metamathematical space. But by having a multicomputational model of the lowlevel “machine code of metamathematics” there’s the potential to make more general statements—and to identify what amount to general “bulk laws of metamathematics” that apply at least to the “metamathematical reference frames” used by human “mathematical observers”.
What might these laws tell us? Perhaps they’ll say something about the homogeneity of metamathematical space and explain why the same structures seem to show up so often in different areas of mathematics. Perhaps they’ll say something about why the “aggregated” mathematical concepts we humans usually talk about can be connected without infinite paths—and thus why undecidability is so comparatively uncommon in mathematics as it is normally done.
But beyond these questions about the “insides of mathematics”, perhaps we’ll also understand more about the ultimate foundations of mathematics, and what mathematics “really is”. It might seem a bit arbitrary to have mathematics be constructed according to some particular law of inference. But in direct analogy to our Physics Project, we can also consider the “rulial multiway system” that allows all possible laws of inference. And as I’ve argued elsewhere, the limiting object that we get for mathematics will be the same as for physics, connecting the question of why the universe exists to the “Platonic” question of whether mathematics “exists”.
In mathematics, the tokens of our multicomputational model are abstract mathematical statements, and the “events between them” represent the application of laws of inference. In thinking about chemistry we can make a much more concrete multicomputational model: the tokens are actual individual molecules (represented say in terms of bonds) and the events are reactions between them. The tokenevent graph is then a “moleculardynamicslevel” representation of a chemical process.
But what would a more macroscopic observer make of this? One “chemical reference frame” might combine all molecules of a particular chemical species at a given time. The result would be a fairly traditional “chemical reaction network”. (The choice of time slices might reflect external conditions; the number of microscopic paths might reflect chemical concentrations.) Within the chemical reaction network a “synthesis pathway” is much like a proof in mathematics: a path that leads from certain “inputs” in the network to a particular output. (And, yes, one can imagine “chemical undecidability” where it’s not clear if there’s any path of any length to make “this from that”.)
A chemical reaction network is much like a multiway graph of the kind we’ve shown for string substitutions. And just as in that case we can define a branchial graph that describes relationships between chemical species associated with their “entanglement” through participation in reactions—and from which a kind of “chemical space” emerges in which different chemical species appear at different positions.
There’s plenty to study at this “species level”. (As a simple example, small loops represent equilibria but larger ones can reflect the effect of protecting groups, or give signatures of autocatalysis.) But I suspect there’s even more to learn by looking at something closer to the underlying tokenevent graph.
In standard chemistry, one typically characterizes the state of a chemical system at a particular time in terms of the concentrations of different chemical species. But ultimately there’s much more information in the whole tokenevent graph—for example about the entangled histories of individual molecules and the causal relationships between events that produced them (which at a physical level might be manifest in things like correlations in orientations or momenta of molecules).
Does this matter, though? Perhaps not for chemistry as it’s done today. But in thinking about molecular computing it may be crucial—and perhaps it’s also necessary for understanding molecular biology. Processes in molecular biology today tend to be described—like chemical reactions—in terms of networks and concentrations of chemical species. (There are additional pieces having to do with the spatial structure of molecules and the possibility of “events at different places on a molecule”.) But maybe the whole “entanglement network” at the “tokenevent level” is also important in successfully capturing what amounts to the molecularscale “chemical information processing” going on in molecular biology.
Just as in genetics in the 1950s there was a crucial realization that information could be stored not just, say, in concentrations of molecules, but in the structure of a single molecule, so perhaps now we need to consider that information can be stored—and processed—in a dynamic network of molecular interactions. And that in addition to seeing how things behave in “chemical species space”, one also needs to consider how they behave in branchial space. And in the end, maybe it just takes a different kind of “chemical observer” (and maybe one more embedded in the system and operating at a molecular scale) to be able to understand the “overall architecture” of many of the molecular computations that go on in biology.
(By the way, it’s worth emphasizing that even though branchial space is what’s associated with quantum mechanics in our model of fundamental physics we’re not thinking about the “physical quantum mechanics” of molecules here. It’s just that through the general structure of multicomputational models “quantum formalism” may end up being central to molecular computing and molecular biology even though—ironically enough—there doesn’t have to be anything “physically quantum” about them.)
What would it take to make a global theory of evolutionary biology? At a “local level” there’s natural selection. And there are plenty of “chemicalreactionequationlike” (and even “reactiondiffusionequationlike”) models for relations between the “concentrations” of small numbers of species. And, yes, there are global “developmental constraints”, that I for example have studied quite extensively with the computational paradigm. But somehow the multicomputational paradigm seems to have the potential to make global “structural” statements about things like the whole “space of species” (and even why there are lots of species at all) just on the basis of the pure “combinatorial structure” of biological processes.
For example, one can imagine making a multicomputational model of “generalized evolutionary biology” in which the tokens are possible specific individual organisms, and the events are all their conceivable behaviors and interactions (e.g. two organisms mating in all possible ways to produce another). (An alternative approach would take the tokens to be genes.) The particular history of all life on Earth would correspond to sampling a particular path through this giant tokenevent graph of all possibilities. And in a sense the “fitness environment” would be encoded in the “reference frame” being used. The “biologist observer” might “coarse grain” the tokenevent graph by combining tokens that are considered to be the “same species”—potentially reducing the graph to some kind of phylogenetic tree.
But the overall question is whether—much like in fundamental physics—the underlying multicomputational structure (as sampled by some class of observers) might inexorably imply certain “general emergent laws of biological evolution”. One might imagine that the layout of organisms in “evolutionary space” at a particular time could be defined from a slice of a causal graph. And perhaps there is an analog of general relativity that exists when the “fitness environment reference frames” are “computationally tame enough” relative to the computational process of evolution. And maybe there are even analogs of the singularity theorems of general relativity, that would generically lead to the formation of event horizons—so that in some sense the distribution of species is like the distribution of black holes in a latestage universe.
(There is a certain analogy with metamathematics here too: different organisms are like different mathematical statements, and finding a “paleontological connection” between them is like finding proofs in mathematics. Sometimes a particular evolutionary path might end in an “extinction singularity” but often—like in mathematics—the path can be infinite, representing an infinite future of “evolutionary innovations”.)
How do brains work? And how for example are “thoughts formed” out of the firings of lots of individual neurons? Maybe there’s an analog to how the coherent physical world we perceive is formed from the interactions of lots of individual atoms of space. And to explore this we might consider a multicomputational model of brains in which the tokens are individual neurons in particular states and events are possible interactions between them.
There’s a strange bit of circularity though. As I’ve argued elsewhere, what’s key to deriving the perceived laws of physics is our particular way of parsing the world (which we may view as core to our notion of consciousness)—in particular our concept that we have a single thread of experience, and thus “sequentialize time”. When applied to a multicomputational model of brains our core “brainrelated” way of parsing the world suggests reference frames that again sequentialize time and turn all those parallel neuron firings into a sequence of coherent “thoughts”.
Just like in physics one can expect that there are many possible reference frames—and one might imagine that ultimate equivalence between them (which leads to relativity in physics) might lead to the ability of different brains to “think comparable thoughts”. Are there analogs of other physical phenomena? One might imagine that in addition to a main “thread of conscious thought” there might be alternate multiway paths whose presence would lead to “quantumlike effects” that would manifest as “influence of the unconscious” (making an analog of Planck’s constant a “measure of the importance of the unconscious”).
The immune system, like the brain, involves a large number of elements “doing different things”. In the brain, there are neurons in a definite physical arrangement that interact electrically. In the (adaptive) immune system there are things like white blood cells and antibodies that basically just “float around”, occasionally interacting though molecularscale “shapebased” physical binding. It seems pretty natural to make a multicomputational model of this, in which individual immune system elements interact through all possible binding events. One can pick an “assay” reference frame in which one “coarse grains together”, say, all antibodies or all Tcell receptors that have a particular sequence.
And by aggregating the underlying tokenevent graph one will be able to get (at least approximately) a “summary graph” of interactions between types of antibodies, etc. Then much like we imagine physical space to be knitted together from atoms of space by their interactions, so also we can expect that the “shape space” of antibodies, etc. will also be defined by their interactions. Maybe “interactionally near” shapes will also be near in some simple sequencebased metric, but not necessarily. And for example there’ll be some analog of a light cone that governs any kind of “spreading of immunity” associated with an antigen “at a particular position in shape space”—and it’ll be defined by the causal graph of interactions between immune elements.
When it comes to understanding the “state of the immune system” we can expect—in a typical multicomputational way—that the whole dynamic network will be important. Indeed, perhaps for example “immune memory” is maintained as a “property of the network” even though individual immune elements are continually being created and destroyed—much as particles and objects in physics persist even though their constituent atoms of space are continually changing.
Languages, like all the other kinds of things we’ve discussed, are fundamentally dynamic constructs. And to make a multicomputational model of them we can for example imagine every instance of every word (or even every conceivable word) being a token—with events being utterances that involve multiple words. The resulting tokenevent graph then defines relationships between instances of words (essentially by the “context of their usage”). And within any given time slice these relationships will imply a certain layout of word instances in what we can interpret as “meaning space”.
There’s absolutely no guarantee that “meaning space” will be anything like a manifold, and I expect that—like the emergent spaces from most tokenevent graphs we’ve generated—it’ll be considerably more complicated to “coordinatize”. Still, the expectation is that instances of a word with a given sense will appear nearby, as will synonymous words—while different senses of a given word will appear as separate clusters.
In this setup, the time evolution of everything would be based on there being a sequence of utterances that are effectively strung together by someone somehow hearing a given word in a certain utterance, then at some point later using that word in another utterance. What utterances are possible? Essentially it’s all “meaningful” ones. And, yes, this is really the nub of “defining the language”. As a rough approximation one could for example use some simple grammatical rule—in which case the possible events might themselves be determined by a multiway system. But the key point is that—like in physics—we may expect that there’ll be global laws quite independent of the “microscopic details” of what precise utterances are possible, just as a consequence of the whole multicomputational structure.
What might these “global laws” of language be like? Maybe they’ll tell us things about how languages evolve and “speciate”, with event horizons forming in the “meaning space of words”. Maybe they’ll tell us slightly smallerscale things about the splitting and merging of different meanings for a single word. Maybe there’ll be an analog of gravity, in which the “geodesic” associated with the “etymological path” for a word will be “attracted” to some region of meaning space with large amounts of activity (or “energy”)—or in effect, if a concept is being “talked about a lot” then the meanings of words will tend to get closer to that.
By the way, picking a “reference frame for a language” is presumably about picking which utterances one’s effectively chosen to have heard by any given time, and thus which utterances one can use to build up one’s “sense of the meanings of words” at that time. And if the selection of utterances for the reference frame is sufficiently wild, then one won’t get a “coherent sense of meaning” for the language as a whole—making the “emergence of meaning” something that’s ultimately about what amounts to human choices.
A basic way to imagine “microscopically” modeling an economic system is to have a tokenevent graph in which the tokens are something like “configurations of agents”, and the events are possible transactions between them. Much like the relations between atoms of space that are the tokens (represented by hyperedges) in our models of fundamental physics, the tokens we’re describing here as “configurations of agents” can more accurately be thought of as relations between elements that, say, represent economic agents, objects, goods, services, currency, etc. In a transaction we’re imagining that an “interaction” between such “relations” leads to new “relations”—say representing the act of exchanging something, making something, doing something, buying something, etc.
At the outset, we’re not saying which transactions happen, and which don’t. And in fact we can imagine a setup (essentially a rulial tokenevent graph) where every conceivable transaction can in principle happen. The result will be a very complicated structure—though with certain inexorable features. But now consider how we would “observe” this system. Maybe there’d be a “fromtheoutside” way to do this, but we could also just “be in the system” getting data through transactions that we’re involved in. But then we’re in a situation that’s pretty closely analogous to fundamental physics. And to make sense of what we observe, we’ll basically inevitably end up sampling the system by setting up some kind of reference frame.
But if this reference frame has typical “generalized human” characteristics such as computational boundedness it’ll end up weaving through all possible transactions to pick out slices that are “computationally simple to describe”. And this seems likely to be related to the origin of “value” in economics (or perhaps more so to the notion of a numéraire). Much like in physics, a reference frame can allow coordinates to be assigned. But the question is what reference frames will lead to coordinates that are somehow stable under the time evolution of the system. And in effect this is what general relativity tells us. And quite possibly there’s an analog of this in economic systems.
Why isn’t there just an immediate value for everything? In the model we’re discussing, all that’s defined is the network of transactions. But just seeing particular local transactions only tells us about things like “local value equivalences”. To say something more global requires the whole knitting together of “economic space” achieved by all the local transactions in the network. It’s very much like in the emergence of physical space. Underneath, there’s all sorts of complicated and computationally irreducible behavior. But if we look at the right things, we see computational reducibility, and something we can describe in the limit as continuum space. In economic systems, lowlevel transactions may show complicated and computationally irreducible behavior. But the point is that if we look at the right things, we again see something like continuum behavior, but now it corresponds to money and value. (And, yes, it is ironic that computational irreducibility is the basic phenomenon that seems to lead to a robust notion of value—even as it’s also what proofofwork cryptocurrencies use to “mine” value.)
Like a changing metric etc. in spacetime, “value” can vary with position and time. And we can expect that there will be some generalrelativitylike principles about how this works (perhaps with “curvature in economic space” allowing arbitrage etc.). There also might be analogs of quantum effects—in which a value depends on a bundle of alternate paths in the multiway graph. (In “quant finance”—which, yes, coincidentally sounds a bit like “quantum”—it’s for example common to estimate prices from looking at the effects of all possible paths, say approximated by Monte Carlo.)
At the outset, it’s not obvious that one can make any “economicslevel” conclusion just based on thinking about what amount to arbitrary tokenevent graphs. But the remarkable thing about multicomputational models is that just from their general structure there are often inexorable quantitative laws that can be derived. And it’s conceivable that at least in the limit of a large economic system, it may finally be possible to do this.
One can think of machine learning as being about deducing models of what can happen in the world from collections of “training examples”. Often one imagines a collection of conceivable inputs (say, possible arrays of pixels corresponding to images), for which one wants to “learn a structure for the space”—in such a way that one can for example find a “manifoldstyle” “coordinatization” in terms of a feature vector.
How can one make a multicomputational model for this process? Imagine for example that one has a neural net with a certain architecture. The “state” of the net is defined by the values of a large number of weights. Then one can imagine a multiway graph in which each state can be updated according to a large number of different events. Each possible event might correspond to the incremental update of weights associated with backpropagating the effect of adding in a single new training example.
In presentday neural net training one normally follows a single path in which one applies a particular (perhaps randomly chosen) sequence of weight updates. But in principle there’s a whole multiway graph of possible training sequences. The branchial space associated with this graph in effect defines a space of possible models obtained after a certain amount of training—complete with a measure on models (derived from path weights), distances between models, etc.
But what about a tokenevent graph? Presentday neural nets—with their usual backpropagation methods—tend to show very little factorizability in the updating of weights. But if one could treat certain collections of weights as “independently updatable” then one could use these to define tokens—and eventually expect to identify some kind of “localizedeffectsinthenet” space.
But if training is associated with the multiway (or tokenevent) graph, what is evaluation? One possible answer is that it’s basically associated with the reference frame that we pick for the net. Running the net might generate some collection of output numbers—but then we have to choose some way to organize these numbers to determine whether they mean, say, that an image is of a cat or a dog. And it is this choice that in effect corresponds to our “reference frame” for sampling the net.
What does this mean, for example, about what is learnable? Perhaps this is where the analog of Einstein’s equations comes in—defining the possible largescale structure of the underlying space, and telling us what reference frames can be set up with computationally bounded effort?
In the applications we’ve discussed so far, the multicomputational paradigm enters basically in a descriptive way, providing raw material from which models can be made. In distributed computing, the paradigm also plays a very powerful prescriptive role, suggesting new ways to do computations, and new kinds of computations to do.
One can think of traditional sequential computation as being based on a simple chain of “evaluation events”, with each event being essentially the evaluation of a function that transforms its input to produce output. The input and output that the functions deal with can involve many “parallel” elements (as, for example, in a cellular automaton) but there’s always just “one output” produced by a given function.
The multicomputational paradigm, however, suggests computations that involve not just chains of evaluation events, but more complicated graphs of them. And one way this can arise is through having “functions” (or “evaluation events”) that produce not just one but several “results” that can then independently be “consumed” by future evaluation events.
A feature of traditional sequential computations is that they’re immediately suitable for execution on a single processor that successively performs a chain of evaluations. But the multicomputational paradigm involves in a sense lots of “separate” evaluation events, that can potentially occur on a whole distributed collection of processors. There are definite causal relations that have to exist between evaluation events, but there need be no single, total ordering.
Some events require as input the output from other events, and so have a definite relative ordering, making them—in physics terminology—“timelike separated”. Some events can be executed in parallel, essentially independently or “asynchronously” of each other—and so can be considered “spacelike separated”. And some events can be executed in different orders, but doing so can lead to different results—making these events (in our physics terminology) “branchlike separated”.
In practical distributed computing, there are usually great efforts made to avoid branchlikeseparated events (or “race conditions”, as they’re commonly called). And if one can do this then one has a computation that—despite its distributed character—can still be interpreted in a fundamentally sequential way in time, with a succession of “definite results” being generated. And, yes, this is certainly a natural thing for us humans to try to do, because it’s what allows us to map the computation into our typical sequentialized “single thread of experience” that seems to be a fundamental feature of our basic notion of consciousness.
But what the multicomputational paradigm suggests is that this isn’t the only way to set up distributed computing. Instead, we just want to think about the progress of a computation in terms of the “bulk perception” of some observer. The observer may be able to pick many different reference frames, but each will represent some computation. Sometimes this computation will correspond to a distributed version of something we were already familiar with. But sometimes it’ll effectively be a new kind of computation.
It’s common to talk about nondeterministic computation in which many paths can be followed—but ultimately one picks out one particular path (say, one that successfully satisfies some condition one’s looking for). The multicomputational paradigm is about the rather different idea of actually treating the “answer” as corresponding to a whole bundle of paths that are combined or conflated through a choice of reference frame. And, yes, this type of thing is rather alien to our traditional “singlethreadoftime” experience of computing. But the point is that particularly through its use and interpretation in physics and so many other areas the multicomputational paradigm gives us a general way to think about—and harness—such things.
And potentially gives us a very different—and powerful—new approach to distributed computing, perhaps complete with very general physicslike “bulk” laws.
OK, so what about other areas? There are quite a few more that I’ve thought at least a little about. Among them are ones like history, psychology and the general development of knowledge. And, yes, it might seem quite surprising that there could be anything scientific or systematic to say about such areas. But the remarkable thing is that by having a new paradigm for theoretical science—the multicomputational paradigm—it becomes conceivable to start bringing science to areas it’s never been able to touch before.
But even in what I’ve said above, I’ve only just begun to sketch how the multicomputational paradigm might apply in different areas. In each case there’s years of work to do in developing and refining things. But I think there’s amazing promise in expanding the domain of theoretical science, and potentially bringing physicslike laws to fields that have long sought such things, but never been able to find them.
What’s the backstory of what I’m calling the multicomputational paradigm? For me, the realization that one can formulate such a broad and general new paradigm is something that’s emerged only over the past year or so. But given what we now know it’s possible to go back and see a quite tangled web of indications and precursors of it stretching back decades and perhaps more than a century.
A key technical step in the development of the multicomputational paradigm was the idea of what I named “multiway systems”. I first used the term “multiway systems” in 1992 when I included a placeholder for a future section about them in an early draft of what would become my 2002 book A New Kind of Science.
A major theme of my work during the development of A New Kind of Science was exploring as broadly as possible the computational universe of simple programs. I had already in the 1980s extensively studied cellular automata—and discovered all sorts of interesting phenomena like computational irreducibility in them. But now I wanted to see what happened in other parts of the computational universe. So I started investigating—and inventing—different kinds of systems with different underlying structures.
And there, in Chapter 5, sandwiched between a section on Network Systems (one of the precursors of the discrete model of space in our Physics Project) and Systems Based on Constraints, is a section entitled Multiway Systems. The basic thrust is already the core multicomputational one: to break away from the idea of (as I put it) a “simple onedimensional arrangement of states in time”:
I studied multiway systems as abstract systems. Later in the book I studied them as idealizations of mathematical proofs. And I mentioned them as a possible (but as I thought then, rather unsatisfactory) underpinning for quantum mechanics.
I came back to multiway systems quite a few times over the years. But it was only when we started the Wolfram Physics Project in the latter half of 2019 that it began to become clear (particularly through an insight of Jonathan Gorard’s) just how central multiway systems would end up being to fundamental physics.
The basic idea of multiway systems is in a sense so straightforward and seemingly obvious that one might assume it had arisen many times. And in a sense it has, at least in special cases and particular forms—in quite a range of fields, under a wide variety of different names—though realistically in many cases we can only see the “multiway system character” when we look back from what we now know.
The rather trivial barelyarealmultiwaysystem case of pure trees no doubt arose for example with the construction of family trees, presumably already in antiquity. Another special and rather trivial case arose in the construction of Pascal’s triangle, which one can think of as working just like the “very simple multiway system” shown above. (In Pascal’s triangle, of course, the emphasis is not on the pattern of states, but on the path weights, which are binomial coefficients.)
Another very early—if implicit—use of multiway systems was in recreational mathematics puzzles and games. Perhaps in antiquity, and certainly by 800 AD, there was for example the wolfgoatcabbage river crossing problem, whose possible histories form a multiway system. Mechanical puzzles like Chinese rings are perhaps even older. And games like Mancala and Three Men’s Morris might date from early antiquity—even though the explicit “mathematical” concept of “game trees” (which are typically multiway graphs that include merging) seems to have only arisen (stimulated by discussions of chess strategies) as an “application of set theory” by Ernst Zermelo in 1912.
In mathematics, multiway systems seem to have first appeared—again somewhat implicitly—in connection with groups. Given words in a group, written out as sequences of generators, successive application of relations in the group essentially yield multiway string substitution systems—and in 1878 Arthur Cayley drew a kind of dual of this to give what’s now called a Cayley graph.
But the first morereadilyrecognizable examples of multiway systems seem to have appeared in the early 1900s in connection with efforts to find minimal representations of axiomatic mathematics. The basic idea—which arose several times—was to think of the process of mathematical deduction as consisting of the progressive transformation of something like sequences of symbols according to certain rules. (And, yes, this basic idea is also what the Wolfram Language now uses for representing general computational processes.) The notion was that any given deduction (or proof) would correspond to a particular sequence of transformations. But if one looks at all possible sequences what one has is a multiway system.
And in what seems to be the first known explicit example Axel Thue in 1914 considered (in a paper entitled “Problems Concerning the Transformation of Symbol Sequences According to Given Rules”) what are essentially string equivalences (twoway string transformations) and discussed what paths could exist between strings—with the result that string substitution systems are now sometimes called “semiThue systems”. In 1921 Emil Post then considered (oneway) string transformations (or, as he called them, “productions”). But, like Thue, he focused on the “decision problem” of whether one string was reachable from another—and never seems to have considered the overall multiway structure.
Thue and Post (and later Markov with his socalled “normal algorithms”) considered strings. In 1920 Moses Schönfinkel introduced his S, K combinators and defined transformations between what amount to symbolic expressions. And here again it turns out there can be ambiguity in how the transformations are applied, leading to what we’d now consider a multiway system. And the same issue arose for Alonzo Church’s lambda calculus (introduced around 1930). But in 1936 Church and Rosser showed that at least for lambda calculus and combinators the multiway structure basically doesn’t matter so long as the transformations terminate: the final result is always the same. (Our “causal invariance” is a more general version of this kind of property.)
Even in antiquity the idea seems to have existed that sentences in languages were constructed from words according to certain grammatical rules, that could (in modern terms) perhaps be recursively applied. For a long time this wasn’t particularly formalized (except conceivably for Sanskrit). But finally in 1956—following work on string substitution systems—there emerged the concept of generative grammars. And while the focus was on things like what sentences could be generated, the underlying representation of the process of generating all possible sentences from grammatical rules can again be thought of as a multiway system.
In a related but somewhat different direction, the development of various kinds of (often switchlike) devices with discrete states had led by the 1940s to the fairly formal notion of a finite automaton. In many engineering setups one wants just one “deterministic” path to be followed between the states of the automaton. But by 1959 there was explicit discussion of nondeterministic finite automata, in which many paths could be followed. But while in principle tracing all these paths would have yielded a multiway system it was quickly discovered that as far as the set of possible strings generated or recognized was concerned, there was always an equivalent deterministic finite automaton.
One way to think about multiway systems is that they’re the result of “repeated nondeterminism”—in which there are multiple outcomes possible at a sequence of steps. And over the course of the past century or so quite a few different kinds of systems based on repeated nondeterminism have arisen—a simple example being a random walk, investigated since the late 1800s. Usually in studying systems like this, however, one’s either interested only in single “random instances”, or in some kind of “overall probability distribution”—and not the more detailed “map of possible histories” defined by a multiway system.
Multiway systems are in a sense specifically about the structure of “progressive evolution” (normally in time). But given what amount to rules for a multiway system one can also ask essentially combinatorial questions about what the distribution of all possible states is. And one place where this has been done for over a century is in estimating equilibrium properties of systems in statistical physics—as summarized by the socalled partition function. Even after all these years there is, however, much less development of any general formalism for nonequilibrium statistical mechanics—though some diagrammatic techniques are perhaps reminiscent of multiway systems (and our full multicomputational approach might now make great progress).
Yet another place where multiway systems have implicitly appeared is in studying systems where asynchronous events occur. The systems can be based on Boolean algebra, database updating or other kinds of ultimately computational rules. And in making proofs about whether systems are for example “correct” or “safe” one needs to consider all possible sequences of asynchronous updates. Normally this is done using various optimized implicit methods, but ultimately there’s always effectively a multiway system underneath.
One class of models that’s been rediscovered multiple times since 1939—particularly in various systems engineering contexts—are socalled Petri nets. Basically these generalize finite automata by defining rules for multiple “markers” to move around a graph—and once again if one were to make the trace of all possible histories it would be a multiway system, so that for example “reachability” questions amount to path finding. (Note that—as we saw earlier—a tokenevent graph can be “rolled up” into what amounts to a Petri net by completely deduplicating all instances of equivalent tokens.)
In the development of computer science, particularly beginning in the 1970s, there were various investigations of parallel and distributed computer systems where different operations can occur concurrently, but at flexible or essentially asynchronous times. Concepts like channels, messagepassing and coroutines were developed—and formal models like Communicating Sequential Processes were constructed. Once again the set of possible histories can be thought of as a multiway system, and methods like process algebra in effect provide a formalism for describing certain aspects of what can happen.
I know of a few perhapscloser approaches to our conception of multiway systems. One is socalled Böhm trees. In studying “term rewriting” systems like combinators, lambda calculus and their generalization the initial focus was on sequences of transformations that terminate in some kind of “answer” (or “normal form”). But starting in the late 1970s a small amount of work was done on the nonterminating case and on what we would now call multiway graphs describing it.
We usually think of multiway graphs as being generated progressively by following certain rules. But if we just look at the final graphs, they (often) have the mathematical structure of Hasse diagrams for partial orderings. Most posets that get constructed in mathematics don’t have particularly convenient interpretations in terms of interesting multiway systems (especially when the posets are finite). But for example the “partially ordered set of finite causets” (or “poscau”) generated by all possible sequential growth paths for causal sets (and studied since about 2000) can be thought of as a multiway system.
Beginning around the 1960s, the general idea of studying systems based on repeated rewriting—of strings or other “terms”—developed essentially into its own field, though with connections to formal language theory, automated theorem proving, combinatorics on words and other areas. For the most part what was studied were questions of termination, decidability and various kinds of path equivalence—but apparently not what we would now consider “full multiway structure”.
Already in the late 1960s there started to be discussion of rewriting systems (and grammars) based on graphs. But unlike for strings and trees, defining how rewriting might structurally work was already complicated for graphs (leading to concepts like doublepushout rewriting). And in systematically organizing this structure (as well as those for other diagrammatic calculi), connections were made with category theory—and this in turn led to connections with formalizations of distributed computing such as process algebra and π calculus. The concept that rewritings can occur “in parallel” led to use of monoidal categories, and consideration of higher categories provided yet another (though rather abstract) perspective on what we now call multiway systems.
(It might be worth mentioning that I studied graph rewriting in the 1990s in connection with possible models of fundamental physics, but was somewhat unhappy with its structural complexity—which is what led me finally in 2018 to start studying hypergraph rewriting, and to develop the foundations of our Physics Project. Back in the 1990s I did consider the possibility of multiway graph rewriting—but it took the whole development of our Physics Project for me to understand its potential significance.)
An important feature of the multicomputational paradigm is the role of the observer and the concept of sampling multiway systems, for example in “slices” corresponding to certain “reference frames”. And here again there are historical precursors.
The term “reference frame” was introduced in the 1800s to organize ideas about characterizing motion—and was generalized by the introduction of special relativity in 1905 and further by general relativity in 1915. And when we talk about slices of multiway systems they’re structurally very much like discrete analogs of sequences of spacelike hypersurfaces in continuum spacetime in relativity. There’s a difference of interpretation, though: in relativity one’s dealing specifically with physical space, whereas in our multiway systems we’re dealing first and foremost with branchial space.
But beyond the specifics of relativity and spacetime, starting in the 1940s there emerged in mathematics—especially in dynamical systems theory—the general notion of foliations, which are basically the continuous analogs of our “slices” in multiway systems.
We can think of slices of multiway systems as defining a certain ordering in which we (or an observer) “scans” the multiway system. In mathematics starting about a century ago there were various situations in which different scanning orders for discrete sets were considered—notably in connection with diagonalization arguments, spacefilling curves, etc. But the notion of scanning orders became more prominent through the development of practical algorithms for computers.
The basic point is that any nontrivial recursive algorithm has multiple possible branches for recursion (i.e. it defines a multiway system), and in running the algorithm one has to decide in what order to follow these. A typical example involves scanning a tree, and deciding in what order to visit the nodes. One possibility is to go “depth first”, visiting nodes all the way down the bottom of one branch first—and this approach was used even by hand for solving mazes before 1900. But by the end of the 1950s, in the course of actual computer implementations, it was noticed that one could also go “breadth first”.
Algorithms for things like searching are an important use case for different scanning orders (or in our way of describing things, different reference frames). But another use case intimately tied into things like term rewriting is for evaluation orders. And indeed—though I didn’t recognize it at the time—my own work on evaluation orders in symbolic computation around 1980 is quite related to what we’re now doing with multicomputation. (Evaluation orders are also related to lazy evaluation and to recent ideas like CRDTs.)
The most typical “workflow” for a computation is a direct one (corresponding to what I call here the computational paradigm): start with an “input” and progressively operate on it to generate “output”. But another “workflow” is effectively to define some goal, and then to try to find a path that achieves it. Early examples around automated theorem proving were already implemented in the 1950s. By the 1970s the approach was used in practice in logic programming, and was also at a theoretical level formalized in nondeterministic Turing machines and NP problems. At an underlying level, the setup was “very multiway”. But the focus was almost always just on finding particular “winning” paths—and not on looking at the whole multiway structure. Slight exceptions from the 1980s were various studies of “distributions of difficulty” in NP problems, and early considerations of “quantum Turing machines” in which superpositions of possible paths were considered.
But as so often happens in the history of theoretical science, it was only through the development of a new conceptual framework—around our Physics Project—that the whole structure of multiway systems was able to emerge, complete with ideas like causal graphs, branchial space, etc.
Beyond the formal structure of multiway systems, etc., another important aspect of the multicomputational paradigm is the central role of the observer. And in a sense it might seem antithetical to “objective” theoretical science to even have to discuss the observer. But the development of relativity and quantum mechanics (as well as statistical mechanics and the concept of entropy) in the early 1900s was predicated on being “more realistic” about observers. And indeed what we now see is that the role of observers in these theories is deeply connected to their fundamentally multicomputational character.
The whole question of how one should think about observers in science has been discussed, arguably for centuries, particularly in the philosophy of physics. But for the most part there hasn’t been much intersection with computational ideas—with exceptions including Heinz von Foerster’s “SecondOrder Cybernetics” from the late 1960s, John Wheeler’s “It from Bit” ideas, and to some extent my own investigations about the origins of perceived complexity.
In some respects it might seem surprising that there’s such a long and tangled backstory of “almost sightings” of multiway systems and the multicomputational paradigm. But in a sense this is just a sign of the fact that the multicomputational paradigm really is a new paradigm: it’s something that requires a new conceptual framework, without which it really can’t be grasped. And it’s a tribute to how fundamental the multicomputational paradigm is that there have been so many “shadows” of it over the years.
But now that the paradigm is “out” I’m excited to see what it leads to—and I fully expect this new fourth paradigm for theoretical science to be at least as important and productive as the three we already have.
Thanks to Xerxes Arsiwalla, Hatem Elshatlawy, Jonathan Gorard, Nik Murzin, Max Piskunov and Christopher Wolfram for discussions and help with the general paradigm, and Etienne Bernard, Taliesin Beynon, James Boyd, Elise Cawley, Greg Chaitin, Jean du Plessis, Roger Germundsson, Fred Meinberg, Bob Nachbar, Terry Sejnowski and others for discussions about specific potential applications and history. Thanks also to the attendees of the 2021 Wolfram Summer School for stimulating me to formulate more generally the whole concept of multicomputation.
On December 7, 1920, Moses Schönfinkel introduced the S and K combinators—and in doing so provided the first explicit example of a system capable of what we now call universal computation. A hundred years later—as I prepared to celebrate the centenary of combinators—I decided it was time to try using modern computational methods to see what we could now learn about combinators. And in doing this, I got a surprise.
It’s already remarkable that S and K yield universal computation. But from my explorations I began to think that something even more remarkable might be true, and that in fact S alone might be sufficient to achieve universal computation. Or in other words, that just applying the rule
S f g x → f[x][g[x]]
over and over again might be all that’s needed to do any computation that can be done.
I don’t know for sure that this is true, though I’ve amassed empirical evidence that seems to point in this direction. And today I’m announcing a prize of $20,000 (yes, the “20” goes with the 1920 invention of combinators, and the 2020 making of my conjecture) for proving—or disproving—that the S combinator alone can support universal computation.
Why is it important to know? Obviously it’ll be neat if it turns out that hiding in plain sight for a century has been an even simpler basis for universal computation than we ever knew. But more than that, determining whether the S combinator alone is universal will provide an important additional data point in the effort to map out just where the threshold of universal computation lies.
Practical computers have complicated and carefully designed CPUs. But is that complexity really needed to support universal computation? My explorations in the computational universe over the past 40 years have led me to the conclusion that it absolutely is not, and that in fact even among systems with the very simplest rules, universal computation is actually quite ubiquitous.
I’ve developed a very general principle that I call the Principle of Computational Equivalence that implies that pretty much whenever we see behavior that isn’t in some sense obviously simple, then it will actually correspond to a computation that’s equivalent in sophistication to any other computation. And one of the many consequences of this principle is that it says computation universality should be ubiquitous.
For more than 30 years I’ve been pushing to get explicit evidence about this, by proving (or disproving) that particular systems are computation universal. And from this have come two very excellent examples that help validate the Principle of Computational Equivalence: the rule 110 cellular automaton
✕
RulePlot[CellularAutomaton[110]] 
and the 2,3 Turing machine:
✕
RulePlot[TuringMachine[{596440, 2, 3}]] 
Both these systems I identified as the simplest of their type that could conceivably be computation universal—and both I expected would actually be computation universal.
But in both cases it was hard work to come up with an explicit proof. In the first case, the proof was part of my book A New Kind of Science (with much of the heavy lifting done by a thenresearch assistant of mine). In the second case, I’d already “made the conjecture” in A New Kind of Science, but in 2007 I decided to put up a prize for actually resolving it. And I was very pleased when, after just a few months, a proof was found, and the prize was won.
So now I’m hoping something similar will happen in the S combinator case. I’m expecting that it will turn out to be computation universal, but it would perhaps be even more interesting if it was proved not to be.
In the past one might have viewed proving that a simple system is (or is not) computation universal as a curiosity—something like solving a specific mathematical puzzle. But the Principle of Computational Equivalence—and all the science I’ve done as a result of exploring the computational universe—now places such a question in a broader context, and shows that far from being a curiosity, it’s actually quite central.
For example, with computation universality comes computational irreducibility, and undecidability. And to know how common these are in systems in nature, in mathematics and in technology has great fundamental and practical significance for when predictions can be made, and what kinds of questions can be answered.
Identifying the threshold of computation universality also has direct implications for making a molecularscale computer, as well, for example, as in computer security, for knowing whether some part of some program is actually universal, so it can be programmed to do something bad.
In the usual S, K combinator setup one does computations by setting up an initial combinator expression that encodes the computation one wants to do, then one repeatedly applies the combinator rules until one gets to a fixed point that can be interpreted as the result of the computation. Of course, not all computations halt, and for computations that don’t halt, no fixed point will ever be reached.
With the S combinator alone a direct input → output representation of computations won’t work. The reason is that there is an elaborate, but finite, characterization of every S combinator expression that halts, and the existence of this characterization implies that halting S combinator evolutions don’t have enough richness to represent arbitrary computations.
There are, however, plenty of nonhalting S combinator evolutions. Here’s the very simplest of them:
✕
ResourceFunction["CombinatorEvolutionPlot"][ Text[ResourceFunction["CombinatorPlot"][ ReplaceAll[#, {s > CombinatorS, k > CombinatorK}], "CharactersLeftAssociative", "SKGlyphs" > {s, k}, "ApplicationGlyph" > "\[NegativeVeryThinSpace]"]] & /@ ResourceFunction["CombinatorEvolveList"][s[s][s][s[s]][s][s], 8, "SKGlyphs" > {s, k}], "StatesDisplay"] 
And here are examples of the sequences of sizes of expressions obtained in various such evolutions:
✕
Grid[Partition[ Labeled[ListStepPlot[ Differences[ ResourceFunction["SKCombinatorLeftmostOutermostLeafCounts"][#, 1000, "SKGlyphs" > {s, k}]], ImageSize > 130, PlotRange > All, Frame > True, FrameTicks > None, Filling > Axis, FillingStyle > Hue[0.56, 0.02, 0.9500000000000001], PlotStyle > Hue[0.56, 0.68, 0.71]], Text[Style[ResourceFunction["CombinatorTraditionalForm"][#], 12]]] & /@ {s[s[s[s[s]][s]]][s][s], s[s][s][s[s[s]]][s[s]], s[s][s][s[s[s[s][s]]]][s], s[s[s[s]][s[s[s]][s]]][s][s], s[s][s][s][s][s][s[s[s]]][s], s[s][s][s[s[s[s][s]][s]]][s], s[s[s][s][s[s]]][s[s][s]][s], s[s][s][s[s[s]]][s[s]][s[s]], s[s][s][s][s[s][s]][s][s][s][s], s[s][s][s[s[s[s[s]][s]][s]]][s], s[s][s][s[s][s[s[s[s][s]]]]][s], s[s[s[s]][s][s]][s[s[s]][s]][s]}, 4]] 
And potentially it’s possible to do computations by “piggybacking” on these nonhalting evolutions. Start with a specification of the computation you want to do. Now encode it as an initial condition for one of the infinite number of possible nonhalting combinator evolutions. Then run the combinator evolution until some particular feature occurs. Then decode from the results at that stage the output from the computation.
To prove that the S combinator is capable of supporting universal computation, one must show that something like this will work for any possible computation one wants to do. Or, in other words, one must show that an S combinator system can emulate some other system (say the S, K combinator one) that is already known to be universal. And by “emulate”, what we mean here is that a suitable “encoder”, “detector” and “decoder” can be found that will allow any evolution in the system being emulated to be mapped to a corresponding evolution in the S combinator system.
There is an important caveat, however: one has to be sure that the encoder, detector and decoder are not themselves capable of universal computation. If one’s lucky, these will operate in sufficiently straightforward ways so that it’ll be obvious they’re not universal. But in general it’ll be nontrivial to demonstrate that they’re not universal. Depending on the setup, one approach may be to show that for all inputs they must halt in some bounded time.
OK, so what if the S combinator system is not computation universal? How could one show that? One possibility would be to demonstrate that all, even infinite, evolutions have only a finite, or essentially finite, number of distinct forms. Another would be to establish that any “modulation” of such evolution must always die out in finite time, so that it must in effect correspond to a computation that halts.
A slightly different approach would be to show that S combinator evolution can be “solved” to the point where its properties after any number of steps can be determined by some bounded computation.
We’ve been talking about “doing computations” with combinators. But there’s a subtlety with that. Because there are in general many different possible evaluation orders for the combinator evolution. If the evolution halts, then it’s guaranteed that it’ll always reach the same fixed point, regardless of the order in which the evaluation was done. But if it doesn’t halt, there’s in general a whole multiway graph of possible sequences of results.
So what does computation universality then mean? As I’ve discussed elsewhere, a strong potential definition is to ask that the multiway system generated by the combinator system can effectively emulate the multiway system generated, say, by a multiway (or nondeterministic) Turing machine. But a weaker alternative definition might just be to ask that one can find some path (i.e. some evaluation order) that can perform any given (deterministic) computation. Or one might for example have detector and decoder functions that can work on some—or all—branches, somehow always being able to reproduce the computation one wants.
I don’t know how long it’s going to take, or how hard it’s going to be, but I’m hoping that someday a message will arrive that successfully resolves the S Combinator Challenge. What will the message have to contain?
The best case as far as I am concerned is specific Wolfram Language code that implements the solution. If the S combinator is in fact universal, then the code should provide a “compiler” that takes, say, a Turing machine or cellular automaton specification, and generates an S combinator initial condition, together with code for the “detector” and “decoder”. But how will we validate that this code is “correct”?
It might conceivably be simple enough that it’s amenable to direct human analysis. But more likely it’s going to require some level of automated analysis. At first one might just do explicit testing. But then one might for example try to generate an automated proof that the detector and decoder always halt, and even perhaps determine an upper bound on how long this can take.
If the S combinator is not universal, one might show this by having code that can “jump ahead” by any number of steps and explicitly determine the outcome, but that itself always halts. Or maybe one might have code that effectively implements what happens to any “modulation” of S combinator evolution—and then prove that this code leads to behavior that, say, always halts, or otherwise ultimately shows complete regularity.
But maybe one won’t have explicit code that implements a solution, and instead one will only have an abstract proof of what’s possible. This could conceivably be in the form of a standard humanoriented mathematical proof. But I think it’s more likely it will be complicated enough that it has to be presented in a systematic computational way. And in the end, if it’s a proof it’ll have to start from certain axioms.
What axioms can be used? One would hope that the “standard axioms of mathematics” will be enough. Perhaps only the Peano axioms will be needed. But I wouldn’t be surprised if transfinite induction were needed, requiring the axioms of set theory. And of course there are weird cases that could arise, where the proof will be possible, say, with one assumption about the Continuum Hypothesis, but not with the other.
There are other weird things that could happen. For example, it might be possible to show that the complete infinite structure obtained by running the combinator evolution for an infinite time could reproduce any computation, but one might not know whether this is possible with finite evolution. Or it might be that one could only make a construction if one had an infinite tree (say specified by a transfinite number) as the initial condition.
It’s also conceivable that the behavior of the S combinator could correspond to an “intermediate degree” of computational capability—and have undecidable features, but not be universal. I don’t think this will happen, but if it does, I would consider it a resolution of the S Combinator Challenge.
And then, of course, there’s the unexpected. And in my experience of exploring the computational universe over the past 40 years, that’s something one encounters with remarkable frequency. A corner case one didn’t anticipate. An intermediate situation that didn’t seem possible. A new form of behavior one never imagined. Sometimes these are the most interesting things to find. But inevitably they make giving a cutanddried definition of what’s needed for the S Combinator Challenge difficult.
It’s worth remembering, though, that the S Combinator Challenge is about answering the humanstated question “Is the S combinator computation universal?”. And in the end it may take humans to determine whether some particular potential solution really does answer that question or not.
In a sense the S Combinator Challenge is already a 100year story. But I’m certainly hoping that it’ll be resolved in far less than 100 more years. And that in doing so we’ll learn important things about the remarkable world of combinators, and the computational universe in general.
]]>Based on a talk at Numerous Numerosity: An interdisciplinary meeting on the notions of cardinality, ordinality and arithmetic across the sciences.
The aliens arrive in a starship. Surely, one might think, to have all that technology they must have the idea of numbers. Or maybe one finds an uncontacted tribe deep in the jungle. Surely they too must have the idea of numbers. To us numbers seem so natural—and “obvious”—that it’s hard to imagine everyone wouldn’t have them. But if one digs a little deeper, it’s not so clear.
It’s said that there are human languages that have words for “one”, “a pair” and “many”, but no words for specific larger numbers. In our modern technological world that seems unthinkable. But imagine you’re out in the jungle, with your dogs. Each dog has particular characteristics, and most likely a particular name. Why should you ever think about them collectively, as all “just dogs”, amenable to being counted?
Imagine you have some sophisticated AI. Maybe it’s part of the starship. And in it this computation is going on:
✕
Cell[BoxData[ RowBox[{"ArrayPlot", "[", RowBox[{ RowBox[{"CellularAutomaton", "[", RowBox[{ RowBox[{"{", RowBox[{"126403", ",", RowBox[{"{", RowBox[{"5", ",", "1"}], "}"}]}], "}"}], ",", RowBox[{"BlockRandom", "[", RowBox[{ RowBox[{"SeedRandom", "[", "234234", "]"}], ";", RowBox[{"RandomInteger", "[", RowBox[{"4", ",", "400"}], "]"}]}], "]"}], ",", RowBox[{"{", RowBox[{"150", ",", "All"}], "}"}]}], "]"}], ",", RowBox[{"ColorRules", "\[Rule]", RowBox[{"{", RowBox[{ RowBox[{"0", "\[Rule]", "Black"}], ",", RowBox[{"1", ">", "Red"}], ",", RowBox[{"2", ">", "Blue"}], ",", RowBox[{"3", ">", "Yellow"}], ",", RowBox[{"4", "\[Rule]", "Green"}]}], "}"}]}], ",", RowBox[{"Frame", ">", "None"}], ",", RowBox[{"ImageSize", ">", "600"}]}], "]"}]], "Input", CellChangeTimes>{{3.8306420749230623`*^9, 3.830642123424028*^9}, { 3.8306421623971853`*^9, 3.830642162868969*^9}}, CellID>872715772] 
Where are the numbers here? What is there to count?
Let’s change the rule for the computation a bit. Now here’s what we get:
✕
Cell[BoxData[ RowBox[{"ArrayPlot", "[", RowBox[{ RowBox[{"CellularAutomaton", "[", RowBox[{ RowBox[{"{", RowBox[{"641267", ",", RowBox[{"{", RowBox[{"5", ",", "1"}], "}"}]}], "}"}], ",", RowBox[{"BlockRandom", "[", RowBox[{ RowBox[{"SeedRandom", "[", "234234", "]"}], ";", RowBox[{"RandomInteger", "[", RowBox[{"4", ",", "400"}], "]"}]}], "]"}], ",", RowBox[{"{", RowBox[{"220", ",", "All"}], "}"}]}], "]"}], ",", RowBox[{"ColorRules", "\[Rule]", RowBox[{"{", RowBox[{ RowBox[{"0", "\[Rule]", "Black"}], ",", RowBox[{"1", ">", "Red"}], ",", RowBox[{"2", ">", "Blue"}], ",", RowBox[{"3", ">", "Yellow"}], ",", RowBox[{"4", "\[Rule]", "Green"}]}], "}"}]}], ",", RowBox[{"Frame", ">", "None"}], ",", RowBox[{"ImageSize", ">", "600"}]}], "]"}]], "Input", CellChangeTimes>{{3.8306420749230623`*^9, 3.830642123424028*^9}, { 3.83064219850028*^9, 3.8306422038874493`*^9}, {3.830642239353552*^9, 3.830642246431511*^9}}, CellID>2060456635] 
And now we’re beginning to have something where numbers seem more relevant. We can identify a bunch of structures. They’re not all the same, but they have certain characteristics in common. And we can imagine describing what we’re seeing by just saying for example “There are 11 objects…”.
Dogs. Sheep. Trees. Stars. It doesn’t matter what kinds of things they are. Once you have a collection that you view as all somehow being “of the same kind”, you can imagine producing a count of them. Just consider each of them in turn, at every step applying some specific operation to the latest result from your count—so that computationally you build up something like:
✕
Cell[BoxData[ RowBox[{"Append", "[", RowBox[{ RowBox[{"NestList", "[", RowBox[{"s", ",", "0", ",", "8"}], "]"}], ",", "\[Ellipsis]"}], "]"}]], "Input", CellChangeTimes>{{3.8306430011394978`*^9, 3.8306430157806883`*^9}, 3.830643443470106*^9, {3.830644248491436*^9, 3.830644262369773*^9}, 3.830905650127592*^9}, CellID>1694952072] 
For our ordinary integers, we can interpret s as being the “successor function”, or “add 1”. But at a fundamental level all that really matters is that we’ve reduced considering each of our original things separately to just repeatedly applying one operation, that gives a chain of results.
To get to this point, however, there’s a crucial earlier step: we have to have some definite concept of “things”—or essentially a notion of distinct objects. Our everyday world is of course full of these. There are distinct people. Distinct giraffes. Distinct chairs. But it gets a lot less clear if we think about clouds, for example. Or gusts of wind. Or abstract ideas.
So what is it that makes us able to identify some definite “countable thing”? Somehow the “thing” has to have some distinct existence—some degree of permanence or universality, and some ability to be independent and separated from other things.
There are many different specific criteria we could imagine. But there’s one general approach that’s very familiar to us humans: the way we talk about “things” in human language. We take in some visual scene. But when we describe it in human language we’re always in effect coming up with a symbolic description of the scene.
There’s a cluster of orange pixels over there. Brown ones over there. But in human language we try to reduce all that detail to a much simpler symbolic description. There’s a chair over there. A table over there.
It’s not obvious that we would be able to do this kind of “symbolicization” in any meaningful way. But what makes it possible is that pieces of what we see are repeatable enough that we can consider them “the same kind of thing”, and, for example, give them definite names in human language. “That’s a table; that’s a chair; etc.”.
There’s a complicated feedback loop, that I’ve written about elsewhere. If we see something often enough, it makes sense to give it a name (“that’s a shrub”; “that’s a headset”). But once we’ve given it a name, it’s much easier for us to talk and think about it. And so we tend to find or produce more of it—which makes it more common in our environment, and more familiar to us.
In the abstract, it’s not obvious that “symbolicization” will be possible. It could be that the fundamental behavior of the world will always just generate more and more diversity and complexity, and never produce any kind of “repeated objects” that could, for example, reasonably be given consistent names.
One might imagine that as soon as one believes that the world follows definite laws, then it’d be inevitable that there’d be enough regularity to guarantee that “symbolicization” is possible. But that ignores the phenomenon of computational irreducibility.
Consider the rule:
✕
Cell[BoxData[ RowBox[{"RulePlot", "[", RowBox[{ RowBox[{"CellularAutomaton", "[", RowBox[{"{", RowBox[{"11497", ",", "3", ",", RowBox[{"1", "/", "2"}]}], "}"}], "]"}], ",", RowBox[{"ColorRules", "\[Rule]", RowBox[{"{", RowBox[{ RowBox[{"0", "\[Rule]", RowBox[{"Darker", "[", RowBox[{"Yellow", ",", ".05"}], "]"}]}], ",", RowBox[{"1", ">", RowBox[{"Darker", "[", "Red", "]"}]}], ",", RowBox[{"2", ">", RowBox[{"Darker", "[", "Blue", "]"}]}]}], "}"}]}]}], "]"}]], "Input", CellChangeTimes>{{3.8306502296691*^9, 3.8306502564832697`*^9}, { 3.830650293899901*^9, 3.83065030003624*^9}, {3.8306504803757343`*^9, 3.830650516874546*^9}}, CellID>297907960] 
We might imagine that with such a simple rule we’d inevitably be able to describe the behavior it produces in a simple way. And, yes, we can always run the rule to find out what behavior it produces. But it’s a fundamental fact of the computational universe that the result doesn’t have to be simple:
✕
Cell[BoxData[ RowBox[{"ArrayPlot", "[", RowBox[{ RowBox[{"CellularAutomaton", "[", RowBox[{ RowBox[{"{", RowBox[{"11497", ",", "3", ",", RowBox[{"1", "/", "2"}]}], "}"}], ",", RowBox[{"{", RowBox[{ RowBox[{"{", "1", "}"}], ",", "0"}], "}"}], ",", RowBox[{"{", RowBox[{"300", ",", "All"}], "}"}]}], "]"}], ",", RowBox[{"ColorRules", "\[Rule]", RowBox[{"{", RowBox[{ RowBox[{"0", "\[Rule]", "Yellow"}], ",", RowBox[{"1", ">", "Red"}], ",", RowBox[{"2", ">", "Blue"}]}], "}"}]}], ",", RowBox[{"Frame", ">", "None"}]}], "]"}]], "Input", CellChangeTimes>{{3.8306501039736633`*^9, 3.830650148180499*^9}, { 3.8306502643578453`*^9, 3.8306502688904037`*^9}, 3.830650349517728*^9}, CellID>215317600] 
And in general we can expect that the behavior will be computationally irreducible, in the sense that there’s no way to reproduce it without effectively tracing through each step in the application of the rule.
With behaviors like these
✕
Cell[BoxData[ RowBox[{ RowBox[{ RowBox[{"ArrayPlot", "[", RowBox[{ RowBox[{"CellularAutomaton", "[", RowBox[{ RowBox[{"{", RowBox[{"#", ",", "3", ",", RowBox[{"1", "/", "2"}]}], "}"}], ",", RowBox[{"{", RowBox[{ RowBox[{"{", "1", "}"}], ",", "0"}], "}"}], ",", RowBox[{"{", RowBox[{"100", ",", "All"}], "}"}]}], "]"}], ",", RowBox[{"ColorRules", "\[Rule]", RowBox[{"{", RowBox[{ RowBox[{"0", "\[Rule]", "Yellow"}], ",", RowBox[{"1", ">", "Red"}], ",", RowBox[{"2", ">", "Blue"}]}], "}"}]}], ",", RowBox[{"Frame", ">", "None"}]}], "]"}], "&"}], "/@", RowBox[{"{", RowBox[{"16451", ",", "4983", ",", "8624"}], "}"}]}]], "Input", CellChangeTimes>{{3.8306514949747677`*^9, 3.830651530814527*^9}, { 3.830651825483645*^9, 3.8306518257404203`*^9}}, CellID>1121547572] 
it’s perfectly possible to imagine giving a complete symbolic description of what’s going on. But as soon as there’s computational irreducibility, this won’t be possible. There’ll be no way to have a “compressed” symbolicized description of the whole behavior.
So how come we manage to describe so much with language, in a “symbolic” way? It turns out that even when a system—such as our universe—is fundamentally computationally irreducible, it’s inevitable that it will have “pockets” of computational reducibility. And these pockets of computational reducibility are crucially important to how we operate in the universe. Because they’re what let us have a coherent experience of the world, with things happening predictably according to identifiable laws, and so on.
And they also mean that—even though we can’t expect to describe everything symbolically—there’ll always be some things we can. And some places where we can expect the concept of numbers to be useful.
The history of physics might make one think that numbers would be a necessary part of the structure of any fundamental theory of our physical universe. But the models of physics suggested by our Physics Project have no intrinsic reference to numbers.
Instead, they just involve a giant network of elements that’s continually getting rewritten according to certain rules. There aren’t intrinsically coordinates, or quantities, or anything that would normally be associated with numbers. And even though the underlying rules may be simple, the detailed overall behavior of the system is highly complex, and full of computational irreducibility.
But the key point is that as observers with particular characteristics embedded in this system we’re only sampling certain features of it. And the features we sample in effect tap into pockets of reducibility. Which is where “simplifying concepts” like numbers can enter.
Let’s talk first about time. We’re used to the experience that time progresses in some kind of linear fashion, perhaps marked off by something like counting rotations of our planet (i.e. days). But at the lowest level in our models, time doesn’t work that way. Instead, what happens is that the universe evolves by virtue of lots of elementary updating events happening throughout the network.
These updating events have certain causal relationships. (A particular updating event, for example, might “causally depend” on another event because it uses as “input” something that’s the “output” of the other event.) In the end, there’s a whole “causal graph” of causal relationships between updating events:
✕
CloudGet["https://wolfr.am/KXgcRNRJ"];(*drawFoliation*)gg=Graph[ResourceFunction["WolframModel"][{{x,y},{z,y}}>{{x,z},{y,z},{w,z}},{{0,0},{0,0}},14,"LayeredCausalGraph"]]; semiRandomWMFoliation={{1},{1,2,3, 4,5, 6,7,8, 10}, {1,2,3, 4,5, 6,7, 8, 9, 10, 11, 12, 13,14, 15, 16, 17,18,19, 20, 21, 22, 23, 24, 25, 26, 28, 30, 42, 43, 58, 59}, {1,2,3, 4,5, 6,7, 8, 9, 10, 11, 12, 13,14, 15, 16, 17,18,19, 20, 21, 22, 23, 24, 25, 26,27, 28, 29, 30,31, 32,33, 34, 35,36, 37, 38, 39, 40, 41, 42, 43, 44, 45,46,47, 48, 49, 50, 51, 52, 53,58, 59, 61, 62, 64, 65, 66, 68, 69, 70, 79, 80, 81, 83, 84, 95}, {1,2,3, 4,5, 6,7, 8, 9, 10, 11, 12, 13,14, 15, 16, 17,18,19, 20, 21, 22, 23, 24, 25, 26,27, 28, 29, 30,31, 32,33, 34, 35,36, 37, 38, 39, 40, 41, 42, 43, 44, 45,46,47, 48, 49, 50, 51, 52,53,54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 78, 79, 80, 81, 82, 83, 84, 85,86, 87,88, 89, 90, 91, 92,93, 94, 95, 96,97, 102, 101, 104, 109, 110, 111, 113, 112,114, 115, 116, 117,118, 119, 120, 121, 122, 123, 124, 125, 127, 128, 130, 131, 132,133, 134, 147, 148, 166}}; Quiet[drawFoliation[gg,semiRandomWMFoliation,Directive[Red]],FindRoot::cvmit] 
The full causal graph is immensely complex, and suffused with computational irreducibility. But we—as the observers we are—sample only certain features of this graph. And—as I’ve recently discussed elsewhere—it seems that the essence of our concept of consciousness is to define certain aspects of that sampling. In particular, despite all the updating events in the universe, and the complex causal relationships between them, we end up “parsing” the samples we take by imagining that we have a definite “sequentialized” thread of experience, or in effect that time progresses in a purely linear fashion.
How do we achieve this? One convenient idealization—developed for thinking about spacetime and relativity—is to set up a “reference frame” in which we imagine dividing the causal graph into a sequence of slices (as in the picture above) that we consider to correspond to “instantaneous complete states of the universe” at successive “moments in time”. It’s not obvious that it’ll be consistent to do this. But between causal invariance and assumptions about the computational boundedness of the observer it turns out that it is—and that the “experience” of the universe for such an observer must follow the laws of physics that we know from general relativity.
So what does this tell us about the emergence of numbers? At the lowest level, the universe is full of computational irreducibility in which there’s no obvious sign of anything like numbers. But in experiencing the universe through the basic features of our consciousness we essentially force some kind of “numberlike” sequentiality in time, reflected in the validity of general relativity, with its “essentially numericalized” notion of time. Or, in other words, “time” (or the “progress of the universe”) isn’t intrinsically “numerical”. But the way we—as “conscious observers”—sample it, it’s necessarily sequentialized, with one moment of time being succeeded by another, in a fundamentally “numerical” sequence.
It’s one thing, though, to sample the behavior of the universe in “time slices” in which all of space has been elided together. But for one to be able to “count” the moments in the passage of time (say aggregated into days), there has to be a certain “sameness” to those moments. The universe can’t do wildly different things at each successive moment; it has to have a certain coherence and uniformity that let us consider different moments as somehow “equivalent enough” to be able simply to be “counted”.
And in fact the emergence of general relativity as the largescale limit of our models (as viewed by observers like us) pretty much guarantees this result, except in certain pathological or extreme cases.
OK, so for observers like us, time in our universe is in some sense “inevitably numerical”. But what about space? At the lowest level in our models, space just consists of a giant and continually updating network of “atoms of space”. And to talk about something like “distance in space” we first have to get some kind of “timeconsistent” version of the network. It’s very much the same situation as with time. To get a simple definition of how time works, we have to elide space. Now, to have any chance of getting a simple definition of how space works, we have to somehow “elide time”.
Or, put another way, we have to think about dividing up the causal graph into “spatial regions” (the vertical “timelike” analog of the horizontal “spacelike slices” we used above) where we can in effect combine all events that occur at any time, in that “region of space”. (Needless to say, in practice we don’t want it to be “any time”—just some span of time that is long compared to what elapses between individual updating events.)
What is the analog for space of the “consciousness assumption” that time progresses in a single, sequential thread? Presumably it’s that we can sample space without having to think about time, or in other words, that we can consistently construct a stable notion of space.
Let’s say we’re trying to find the shortest “travel path” between two “points in space”. At the outset, the definition is quite subtle—not least because there are no “statically defined” “points in space”. Every part of the network is being continually rewritten, so in a sense by the time you “get to the other point”, it certainly won’t be the same “atom of space” as when you started out. And to avoid this, you essentially have to elide time. And just like for the case of spacelike slices for sequentialization in time, there are certain consistent choices of timelike slices that can be made.
And assuming such a choice is made, there will then be “timeelided” (or, roughly, timeindependent) paths between points in space, analogous to our previous “spaceelided” “path through time”. So then how might we measure the length of a path in space, or, effectively the distance between two points? In direct analogy to the case of time, if there is sufficient uniformity in the spatial structure then we can expect to just “count things” to get a numerical version of distance.
Sequentialization in time is what allows us to have the sense that we maintain a coherent existence—and a coherent thread of experience—through time. The ability to do something similar in space is what gives us the sense that we have a coherent existence through space, or, in other words, that we can maintain our identity when we move around in space.
In principle, there might be nothing like “pure motion”: it might be that any “movement in space” would necessarily change the structure and character of things. But the point is that one can consistently label positions in space so that this doesn’t happen, and “pure motion” is possible. And once we’ve done that, we’re again essentially forcing there to be a notion of distance, that can be measured with numbers.
OK, but so if we sample the universe in the way we expect a conscious observer who maintains their identity as they move to do, then there’s a certain inevitable “numerical character” to the way we measure time and space. But what “stuff in the universe”? Can we expect that also to be characterized by numbers? We talked above about “things”. Can the universe contain “things” that can for example readily be counted?
Remember that in our models the whole universe—and everything in it—is just a giant network. And at the lowest level this network is just atoms of space and connections between them—and nothing that we can immediately consider a “thing”. But we expect that within the structure of the network there are essentially topological features that are more like “things”.
A good example is black holes. When we look at the network—and particularly the causal graph—we can potentially identify the signature of event horizons and a black hole. And we can imagine “counting black holes”.
What makes this possible? First, that black holes have a certain degree of permanence. And second, that they can be to a large extent treated as independent. And third, that they can all readily be identified as “the same kind of thing”. Needless to say, none of these features is absolute. Black holes form, merge, evaporate—and so aren’t completely permanent. Black holes can have gravitational—and also presumably quantum—effects on each other, and so aren’t completely independent. But they’re permanent and independent enough that it’s a useful approximation to treat them as “definite things” that can readily be counted.
Beyond black holes, there’s another clear example of “countable” things in the universe: particles, like electrons, photons, quarks and so on. (And, yes, it won’t be a big surprise if there’s a deep connection between particles and black holes in our models.) Particles—like black holes—are somewhat permanent, somewhat independent and have a high degree of “sameness”.
A defining feature of particles is that they’re somewhat localized (for us, presumably in both physical and branchial space), and maintain their identity with time. They can be emitted and absorbed, so aren’t completely permanent, but somehow they exist for long enough to be identified.
It’s then a fundamental observation in physics that particles come only in certain discrete species—and within these species every particle (say, every electron) is identical, save for its position and momentum (and spin direction). We don’t yet know within our models exactly how such particles work, but the assumption is that they correspond to certain discrete possible “topological obstructions” in the behavior of the network. And much like a vortex in a fluid, their topological character endows them with a certain permanence.
It’s worth understanding that in our models, not everything that “goes on in the universe” can necessarily be best characterized in terms of particles. In principle one might be able to think of every piece of activity in the network as somehow related to a sufficiently small or shortlived “particle”. But mostly there won’t be “room for” the characteristics of something we can identify as a particular “countable” particle to emerge.
An extreme case is what would be considered zeropoint fluctuations in traditional quantum field theory: an everpresent infinite collection of shortlived virtual particle pairs. In our models this is not something one immediately thinks of in terms of particles: rather, it is continual activity in the network that in effect “knits space together”.
But in answering the question of whether physics inevitably leads to a notion of numbers, one can certainly point to situations where definite “countable” particles can be identified. But is this like the case of time and space that we discussed above: the numbers are somehow “not intrinsic” but just appear for “observers like us”?
Once again I suspect the answer is “yes”. But now the special feature of us as observers is that we think about the universe in terms of multiple, independent processes or experiments. We set things up so that we can concentrate, say, on the scattering of two particles that are initially sufficiently separated from everything else to be independent of it. But without this separation, we’d have no real way to reliably “count the particles”, and characterize what’s happening in terms of specific particles.
There’s actually a direct analog of this in a simple cellular automaton. On the left is a process involving “separated countable particles”; on the right—using exactly the same rule—is one where there are no similar particlebased “asymptotic states”:
✕
GraphicsRow[{With[{bkg=ResourceData["7ef9f42295414a0fbec2cf3e310fe5f2",All]["Background"],collisions=Normal@ResourceData["7ef9f42295414a0fbec2cf3e310fe5f2",All]["Collisions"]},ArrayPlot[CellularAutomaton[110,#,{300,200+{100,100}}],ColorRules>{0>LightYellow,1>Red},Frame>None]&[collisions[[1,"InitialConditions"]][[1]]]],ArrayPlot[CellularAutomaton[110,BlockRandom[SeedRandom[2423];RandomInteger[1,200]],300],ColorRules>{0>LightYellow,1>Red},Frame>None]}] 
As we’ve discussed, even with simple underlying rules, many systems behave in computationally irreducible ways. But when there’s computational reducibility—and when, in a sense, we can successfully “jump ahead” in the computation—are numbers always involved in doing that?
In cases like these
✕
Cell[BoxData[ RowBox[{ RowBox[{ RowBox[{"ArrayPlot", "[", RowBox[{ RowBox[{"CellularAutomaton", "[", RowBox[{ RowBox[{"{", RowBox[{"#", ",", "3", ",", RowBox[{"1", "/", "2"}]}], "}"}], ",", RowBox[{"{", RowBox[{ RowBox[{"{", "1", "}"}], ",", "0"}], "}"}], ",", RowBox[{"{", RowBox[{"100", ",", "All"}], "}"}]}], "]"}], ",", RowBox[{"ColorRules", "\[Rule]", RowBox[{"{", RowBox[{ RowBox[{"0", "\[Rule]", "Yellow"}], ",", RowBox[{"1", ">", "Red"}], ",", RowBox[{"2", ">", "Blue"}]}], "}"}]}], ",", RowBox[{"Frame", ">", "None"}], ",", RowBox[{"ImageSize", ">", "200"}]}], "]"}], "&"}], "/@", RowBox[{"{", RowBox[{"3363", ",", "2098", ",", "13753"}], "}"}]}]], "Input", CellChangeTimes>{{3.830814021443989*^9, 3.830814088320113*^9}}, CellID>2039815390] 
where there’s clear repetition in the behavior, numbers are an obvious path to figuring out what’s going to happen. Want to know what the system will do at step number t? Just take the number t and do some “numerical computation” on it (typically here involving modulo arithmetic) and immediately get the result.
But very often you end up treating t as a “number in name only”. Consider nested patterns like these:
✕
GraphicsRow[ArrayPlot[CellularAutomaton[{#,3,1/2},{{1},0},200],ColorRules>{0>Yellow,1>Red,2>Blue},Frame>None,ImageSize>{Automatic,170}]&/@{17920,18363,18323,4358}] 
It’s possible to work out the behavior at step t in a computationally reduced way, but it involves treating t not so much as a number (that one might, say, do arithmetic on) but instead more just a sequence of bits that one computes bitwise functions like BitXor on.
There are definitely other cases where the ability to jump ahead in a computation relies specifically on the properties of numbers. A somewhat special example is a cellular automaton whose rows can be thought of as digits of a number in base 6, that at each step gets multiplied by 3 (it’s not obvious that this procedure will be local to digits, “cellularautomatonstyle”, but it is):
✕
Cell[BoxData[ RowBox[{"ArrayPlot", "[", RowBox[{ RowBox[{"PadLeft", "[", RowBox[{"Table", "[", RowBox[{ RowBox[{"IntegerDigits", "[", RowBox[{ RowBox[{"3", "^", "t"}], ",", "6"}], "]"}], ",", RowBox[{"{", RowBox[{"t", ",", "200"}], "}"}]}], "]"}], "]"}], ",", RowBox[{"ColorRules", "\[Rule]", RowBox[{"Flatten", "[", RowBox[{"{", RowBox[{ RowBox[{"0", "\[Rule]", "White"}], ",", RowBox[{"Table", "[", RowBox[{ RowBox[{"i", ">", RowBox[{"Darker", "[", RowBox[{"Cyan", ",", RowBox[{".1", " ", "i"}]}], "]"}]}], ",", RowBox[{"{", RowBox[{"i", ",", "5"}], "}"}]}], "]"}]}], "}"}], "]"}]}]}], "]"}]], "Input", CellChangeTimes>{{3.830815710139923*^9, 3.8308158542493687`*^9}}, CellID>2141486456] 
In this case, repeated squaring of the rows thought of as numbers quickly gets the result—though actually t is again used more for its digits than its “numerical value”.
When one explores the computational universe, by far the most common sources of computational reducibility are repetition and nesting. But other examples do show up. A few are obviously “numerical”. But most are not. And typically what happens is just that there is an alternative, very much more efficient program that exists to compute the same results as the original program. But the more efficient program is still “just a program” with no particular connection to anything involving numbers.
Fast numbersbased ways to do particular computations are often viewed as representing “exact solutions” to corresponding mathematical problems. Such exact solutions tend to be highly prized. But they also tend to be few and far between—and rather specific.
Could there be other “generic” forms of computational reducibility beyond repetition and nesting? In general we don’t know—though it’d be an important thing to find out. Still, there is in a sense one other kind of computational reducibility that we do know about, and that’s been very widely used in mathematical science: the phenomenon of continuity.
So far, we’ve mostly been talking about numbers that are integers, and that can at some level be used to “count distinct things”. But in mathematics and mathematical science it’s very common to think not about discrete integers, but about the continuum of real numbers.
And even when there’s some discrete process going on underneath—that might even show computational irreducibility—it can still be the case that in the continuum limit there’s a “numerical description”, say in terms of a differential equation. If one looks, say, at cellular automata, it’s fairly rare to find examples that have such continuum limits. But in the models from our Physics Project—that have much less builtin structure—it seems to be almost a generic feature that there’s a continuum limit that can be described by continuous equations of just the kind that have shown up in traditional mathematical physics.
But beyond taking limits to derive continuum behavior, one can also just symbolically specify equations whose variables are from the start, say, real numbers. And in such cases one might think that everything would always “work out in terms of numbers”. But actually, even in cases like this, things can be more complicated.
Yes, for the equations that are typically discussed in textbooks, it’s common to get solutions that can be represented just as evaluating certain functions of numbers. But if one looks at other equations and other situations, there’s often no known way to get these kinds of “exact solutions”. And instead one basically has to try to find an explicit computation that can approximate the behavior of the equation.
And it seems likely that in many cases such computations will end up being computationally irreducible. Yes, they’re in principle being done in terms of numbers. But the dominant force in determining what happens is a general computational process, not something that depends on the specific structure of numbers.
And, by the way, it’s no coincidence that in the past couple of decades, as more and more modeling of systems with complex behavior is done, there’s been an overwhelming shift away from models that are based on equations (and numbers) to ones that are based directly on computation and computational rules.
Why do we use numbers so much? Is it something about the world? Or is it more something about us?
We discussed above the example of fundamental physics. And we argued that even though at the most fundamental level numbers really aren’t involved, our sampling of what happens in the universe leads us to a description that does involve numbers. And in this case, the origin of the way we sample the universe has deep roots in the nature of our consciousness, and our fundamental way of experiencing the universe, with our particular sensory apparatus, place in the universe, etc.
What about the appearance of numbers in the history of science and engineering? Why are they so prevalent there? In a sense, like the situation with the universe, I don’t think it’s that the underlying systems we’re dealing with have any fundamental connection to numbers. Rather, I think it’s that we’ve chosen to “sample” aspects of these systems that we can somehow understand or control, and these often involve numbers.
In science—and particularly physical science—we have tended to concentrate on setting up situations and experiments where there’s computational reducibility and where it’s plausible that we can make predictions about what’s going to happen. And similarly in engineering, we tend to set up systems that are sufficiently computationally reducible that we can foresee what they’re going to do.
As I discussed above, working with numbers isn’t the only way to tap into computational reducibility, but it’s the most familiar way, and it’s got an immense weight of historical experience behind it.
But do we even expect that computational reducibility will be a continuing feature of science and engineering? If we want to make the fullest use of computation, it’s inevitable that we’ll have to bring in computational irreducibility. It’s a new kind of science, and it’s a new kind of engineering. And in both cases we can expect that the role of numbers will be at least much reduced.
If we look at human history, numbers have played a quite crucial role in the organization of human society. They’re used to keep records, specify value in commerce, define how resources should be allocated, determine how governance should happen, and countless other things.
But does it have to be that way, or is it merely that numbers provide a convenient way to set things up so that we humans can understand what’s going on? Let’s say that we’re trying to achieve the objective of having an efficient transportation system for carrying people around. The traditional “numbersbased” way of doing that would be to have, say, trains that run at specific “numerical” times (“every 15 minutes”, or whatever).
In a sense, this is a simple, “computationally reducible” solution—that for example we can easily understand. But there’s potentially a much better solution, at least if we’re able to make use of sophisticated computation. Given the complete pattern of who wants to go where, we can dispatch specific vehicles to drive in whatever complicated arrangement is needed to optimally deliver people to their destinations. It won’t be like the trains, with their regular times. Instead, it’ll be something that looks more complex, and computationally irreducible. And it won’t be easy to characterize in terms of numbers.
And I think it’s a pretty general phenomenon: numbers provide a good “computationally reducible” way to set something up. But there are other—perhaps much more efficient—ways, that make more serious use of computation, and involve computational irreducibility, but don’t rely on numbers.
None of these computational approaches are possible until we have sophisticated computation everywhere. And even today we’re just in the early stages of broadly deploying the level of computational sophistication that’s needed. But as another example of how this can play out, consider economic systems.
One of the first and historically strongest uses of numbers has been in characterizing amounts of money and prices of things. But are “numerical prices” the only possible setup for an economic system? We already have plenty of examples of dynamic pricing, where there’s no “list price”, but instead AIs or bots are effectively bidding in real time to determine what transaction will happen.
Ultimately an economic system is based on a large network of transactions. One person wants to get a cookie. The person they’re getting it from wants to rent a movie. Somewhat in analogy to the transportation example above, with enough computation available, we could imagine a situation where at every node in the network there are bots dynamically arranging transactions and deciding what can happen and what cannot, ultimately based on certain goals or preferences expressed by people. This setup is slightly reminiscent of our model of fundamental physics—with causal graphs from physics now being something like supply chains.
And as in the physics case, there’s no necessity to have numbers involved at the lowest level. But if we want to “sample the system in a human way” we’ll end up describing it in collective terms, and potentially end up with an emergent notion of price a bit like the way there’s an emergent notion of gravitational field in the case of physics.
So in other words, if it’s just the bots running our economic system, they’ll “just be doing computation” without any particular need for numbers. But if we try to understand what’s going on, that’s when numbers will appear.
And so it is, I suspect, with other examples of the appearance of numbers in the organization of human society. If things have to be implemented—and understood—by humans, there’s no choice but to leverage computational reducibility, which is most familiarly done through numbers. But when things are instead done by AIs or bots, there’s no such need for computational reducibility.
Will there still be “humanlevel descriptions” that involve numbers? No doubt there’ll at least be some “naturalsciencelike” characterizations of what’s going on. But perhaps they’ll most conveniently be stated in terms of computational reducibility that’s set up using concepts other than numbers—that humans in the future will learn about. Or perhaps numbers will be such a convenient “implementation layer” that they’ll end up being used for essentially all humanlevel descriptions.
But at a fundamental level my guess is that ultimately numbers will fall away in importance in the organization of human society, giving way to more detailed computationbased decision making. And maybe in the end numbers will come to seem a little like the way logic as used in the Middle Ages might seem to us today: a framework for determining things that’s much less complete and powerful than what we now have.
Whatever their role in science, technology and society, one place where numbers seem fundamentally central is mathematics. But is this really something that is necessary, or is it instead somehow an artifact of the particular history or presentation of human mathematics?
A common view is that at the most fundamental level mathematics should be thought of as an exploration of the consequences of certain abstract underlying axioms. But which axioms should these be? Historically a fairly small set has been used. And a first question is whether these implicitly or explicitly lead to the appearance of numbers.
The axioms for ordinary logic (which are usually assumed in all areas of mathematics) don’t have what’s needed to support the usual concept of numbers. The same is true of axioms for areas of abstract algebra like group theory—as well as basic Euclidean geometry (at least for integers). But the Peano axioms for arithmetic are specifically set up to support integers.
But there is a subtlety here. What the Peano axioms actually do is effectively define certain constraints on abstract constructs. Ordinary integers are one “solution” to those constraints. But Gödel’s theorem shows that there are also an infinite number of other solutions: nonstandard “numbers” with weird properties that also happen to follow the same overall axioms.
So in a sense mathematics based on the Peano axioms can be interpreted as being “about” ordinary numbers—but it can also be interpreted as being about other, exotic things. And it’s pretty much the same story with the standard axioms of set theory: the mathematics they generate can be interpreted as covering ordinary numbers, but it can also be interpreted as covering other things.
But what happens if we ignore the historical development of human mathematics, and just start picking axiom systems “at random”? Most likely they won’t have any immediately recognizable interpretation, but we can still go ahead and build up a whole network of theorems and results from them. So will such axiom systems end up leading to constructs that can be interpreted as numbers?
This is again a somewhat tricky question. The Principle of Computational Equivalence suggests that axiom systems with nontrivial behavior will typically show computation universality. And that means that (at least in some metamathematical sense) it’s possible to set up an encoding of any other axiom system within them.
So in particular it should be possible to reproduce what’s needed to support numbers. (Again, there are subtleties here to do with axiom schemas, and their use in supporting the concept of induction, which seems quite central to the idea of numbers.) But if we just look at the raw theorems from a particular axiom system—say as generated by an automated theoremproving system—it’ll be very hard to tell what can be interpreted as being “related to numbers”.
But what if we restrict ourselves to mathematical results that have been proved by humans—of which there are a few million? There are a number of recent efforts to formalize at least a few tens of thousands of these, and show how they can be formally derived from specific axioms.
But now we can ask what the dependencies of these results are. How many of them need to “go through the idea of numbers”? We can get a sense of this by doing “empirical metamathematics” on a particular math formalization system (here Metamath):
✕
extensibleStructures = {"dfstruct","dfndx","dfslot","dfbase","dfbase","dfsets","dfress","brstruct","isstruct2","isstruct","structcnvcnv","structfun","structfn","slotfn","strfvnd","wunndx","strfvn","strfvn","strfvss","wunstr","ndxarg","ndxid","ndxid","strndxid","reldmsets","setsvalg","setsval","setsval","setsidvald","fvsetsid","fsets","wunsets","setsres","setsres","setsabs","setscom","setscom","strfvd","strfv2d","strfv2","strfv","strfv","strfv3","strssd","strssd","strss","strss","str0","str0","base0","strfvi","setsid","setsid","setsnid","setsnid","sbcie2s","sbcie3s","baseval","baseid","elbasfv","elbasov","strov2rcl","strov2rcl","basendx","reldmress","ressval","ressid2","ressval2","ressbas","ressbas2","ressbasss","ressbasss","resslem","resslem","ress0","ress0","ressid","ressinbas","ressval3d","ressress","ressress","ressabs","wunress","dfrest","dfrest","dftopn","restfn","topnfn","restval","restval","elrest","elrest","elrestr","elrestr","0rest","restid2","restsspw","firest","restid","restid","topnval","topnid","topnpropd","df0g","dfgsum","dfgsum","dfgsum","dftopgen","dfpt","dfprds","dfprds","reldmprds","reldmprds","dfpws","prdsbasex","imasvalstr","imasvalstr","imasvalstr","prdsvalstr","prdsvalstr","prdsvalstr","prdsvallem","prdsvallem","prdsval","prdsval","prdsval","prdssca","prdssca","prdssca","prdsbas","prdsbas","prdsbas","prdsplusg","prdsplusg","prdsplusg","prdsmulr","prdsmulr","prdsmulr","prdsvsca","prdsvsca","prdsvsca","prdsip","prdsle","prdsle","prdsless","prdsds","prdsds","prdsdsfn","prdstset","prdstset","prdshom","prdshom","prdsco","prdsco","prdsbas2","prdsbas2","prdsbasmpt","prdsbasfn","prdsbasprj","prdsplusgval","prdsplusgval","prdsplusgfval","prdsmulrval","prdsmulrfval","prdsleval","prdsdsval","prdsvscaval","prdsvscafval","prdsbas3","prdsbasmpt2","prdsbasmpt2","prdsbascl","prdsdsval2","prdsdsval3","pwsval","pwsbas","pwselbasb","pwselbas","pwselbas","pwsplusgval","pwsmulrval","pwsle","pwsleval","pwsvscafval","pwsvscaval","pwssca","pwsdiagel","pwssnf1o","dfordt","dfxrs","dfqtop","dfimas","dfqus","dfxps","imasval","imasval","imasval","imasbas","imasbas","imasbas","imasds","imasds","imasds","imasdsfn","imasdsval","imasdsval2","imasplusg","imasplusg","imasplusg","imasmulr","imasmulr","imasmulr","imassca","imassca","imasvsca","imasvsca","imasip","imastset","imasle","f1ocpbllem","f1ocpbl","f1ovscpbl","f1olecpbl","imasaddfnlem","imasaddvallem","imasaddflem","imasaddfn","imasaddfn","imasaddval","imasaddf","imasmulfn","imasmulval","imasmulf","imasvscafn","imasvscaval","imasvscaf","imasless","imasleval","qusval","quslem","qusin","qusbas","quss","divsfval","divsfval","ercpbllem","ercpbl","ercpbl","erlecpbl","erlecpbl","qusaddvallem","qusaddflem","qusaddval","qusaddf","qusmulval","qusmulf","xpsc","xpscg","xpscfn","xpsc0","xpsc1","xpscfv","xpsfrnel","xpsfeq","xpsfrnel2","xpscf","xpsfval","xpsff1o","xpsfrn","xpsfrn2","xpsff1o2","xpsval","xpslem","xpsbas","xpsaddlem","xpsadd","xpsmul","xpssca","xpsvsca","xpsless","xpsle","dfplusg","dfplusg","dfmulr","dfmulr","dfstarv","dfstarv","dfsca","dfsca","dfvsca","dfvsca","dfip","dfip","dftset","dftset","dfple","dfple","dfocomp","dfocomp","dfds","dfds","dfunif","dfhom","dfcco","strlemor0","strlemor1","strlemor1","strlemor2","strlemor2","strlemor3","strlemor3","strleun","strle1","strle2","strle3","plusgndx","plusgid","1strstr","1strbas","1strwunbndx","1strwun","2strstr","2strbas","2strop","grpstr","grpstr","grpbase","grpbase","grpplusg","grpplusg","ressplusg","grpbasex","grpplusgx","mulrndx","mulrid","rngstr","rngstr","rngbase","rngbase","rngplusg","rngplusg","rngmulr","rngmulr","starvndx","starvid","ressmulr","ressstarv","srngfn","srngfn","srngbase","srngbase","srngplusg","srngmulr","srnginvl","scandx","scaid","vscandx","vscaid","vscaid","lmodstr","lmodstr","lmodbase","lmodbase","lmodplusg","lmodplusg","lmodsca","lmodsca","lmodvsca","lmodvsca","ipndx","ipid","ipsstr","ipsstr","ipsstr","ipsbase","ipsbase","ipsbase","ipsaddg","ipsaddg","ipsaddg","ipsmulr","ipsmulr","ipsmulr","ipssca","ipssca","ipssca","ipsvsca","ipsvsca","ipsvsca","ipsip","ipsip","ipsip","resssca","ressvsca","ressip","phlstr","phlstr","phlbase","phlbase","phlplusg","phlplusg","phlsca","phlsca","phlvsca","phlvsca","phlip","phlip","tsetndx","tsetid","topgrpstr","topgrpbas","topgrpplusg","topgrptset","resstset","plendx","pleid","otpsstr","otpsbas","otpstset","otpsle","ressle","ocndx","ocid","dsndx","dsid","unifndx","unifid","odrngstr","odrngbas","odrngplusg","odrngmulr","odrngtset","odrngle","odrngds","ressds","homndx","homid","ccondx","ccoid","resshom","ressco","slotsbhcdif"}; metamathGraph = EdgeDelete[CloudGet["https://wolfr.am/PLbmdhRv"], Select[EdgeList[CloudGet["https://wolfr.am/PLbmdhRv"]], MemberQ[extensibleStructures, #[[2]]] &]]; metamathAssoc =CloudGet["https://wolfr.am/PLborw8R"]/. {"TG (TARSKIGROTHENDIECK) SET THEORY"> "ARITHMETIC & SET THEORY", "ZFC (ZERMELOFRAENKEL WITH CHOICE) SET THEORY"> "ARITHMETIC & SET THEORY", "ZF (ZERMELOFRAENKEL) SET THEORY"> "ARITHMETIC & SET THEORY"}; metamathDomains = Union[Values[metamathAssoc]]; metamathInfrastructure = {"SUPPLEMENTARY MATERIAL (USER'S MATHBOXES)", "GUIDES AND MISCELLANEA"}; metamathColors = Merge[{AssociationThread[Complement[metamathDomains, metamathInfrastructure] > Take[ColorData[54, "ColorList"], Length[Complement[metamathDomains, metamathInfrastructure]]]], AssociationThread[metamathInfrastructure > LightGray]}, Identity]; metamathDomainWeights = Tally[Values[metamathAssoc]]; metamathEdgeWeights = Tally[{metamathAssoc[#[[1]]], metamathAssoc[#[[2]]]} & /@ EdgeList[metamathGraph]]; metamathEdgesOutSimple = Append[Merge[AssociationThread[{#[[1, 1, 1]]}> Total[#[[2]]]] & /@ (Transpose /@ GatherBy[Select[metamathEdgeWeights, #[[1, 1]] != #[[1, 2]] &], #[[1, 1]] &]), Identity], "CLASSICAL FIRSTORDER LOGIC WITH EQUALITY" > {7649}]; metamathNormalizedEdgeWeights = DirectedEdge[#[[1, 1]], #[[1, 2]]] > #[[2]]/ Flatten[metamathEdgesOutSimple[#[[1,1]]]] & /@ metamathEdgeWeights; diskedLine[{line_,radii_}]:={RegionIntersection[Line[line],Circle[line[[1]],radii[[1]]]][[1,1]], RegionIntersection[Line[line],Circle[line[[2]],radii[[2]]]][[1,1]]}; weightedArrow[line_,weight_]:= Module[{len,start,end,angle, thick, rec, mid}, start=line[[1]]; end=line[[2]]; mid=Mean[line]; len=EuclideanDistance[start,end]; angle=Arg[(startend).{1,I}]; thick=weight/len; rec= #+mid&/@(RotationMatrix[angle].#&/@{{len/2, thick/2},{len/2, thick/2},{len/2, thick/2},{len/2, thick/2}}); Polygon[rec]]; Show[VertexDelete[SimpleGraph[Graph[metamathDomains, First /@ metamathNormalizedEdgeWeights, EdgeStyle>Thread[First/@metamathNormalizedEdgeWeights > ({AbsoluteThickness[15Last[#][[1]]],Arrowheads[0.15*Last[#][[1]]], GrayLevel[0.5, 0.5]}&/@metamathNormalizedEdgeWeights)], VertexSize>Thread[First/@metamathDomainWeights > (Sqrt[#]/100&/@(Last/@ metamathDomainWeights))], VertexStyle > (# > {Lighter /@ metamathColors[#]} & /@ metamathDomains), VertexLabels>{"BASIC ALGEBRAIC STRUCTURES" > "algebraic structures","BASIC CATEGORY THEORY" > "category theory","BASIC LINEAR ALGEBRA" > "linear algebra","BASIC ORDER THEORY" > "order theory","BASIC REAL AND COMPLEX ANALYSIS" > "real & complex analysis","BASIC REAL AND COMPLEX FUNCTIONS" > "real & complex functions","BASIC STRUCTURES" > "basic structures","BASIC TOPOLOGY" > "topology","CLASSICAL FIRSTORDER LOGIC WITH EQUALITY" > "logic","ELEMENTARY GEOMETRY" > "geometry","ELEMENTARY NUMBER THEORY" > "number theory","GRAPH THEORY" > "graph theory","GUIDES AND MISCELLANEA" > "miscellaneous","REAL AND COMPLEX NUMBERS" > "real & complex numbers","SUPPLEMENTARY MATERIAL (USER'S MATHBOXES)" > "supplementary material","ARITHMETIC & SET THEORY" > "arithmetic & set theory"}, GraphLayout > "SpringElectricalEmbedding", PerformanceGoal>"Quality", AspectRatio>1]], {"SUPPLEMENTARY MATERIAL (USER'S MATHBOXES)","CLASSICAL FIRSTORDER LOGIC WITH EQUALITY", "GUIDES AND MISCELLANEA"}], Editable > True] 
And what we see is that at least in a human formalization of mathematics, numbers do indeed seem to play a very central role. Of course, this doesn’t tell us whether in principle results, say in topology, could be proved “without numbers”; it just tells us that in this particular formalization numbers are used to do that.
We also can’t tell whether numbers were just “convenient for proofs” or whether in fact the actual mathematical results picked to formalize were somehow based on their “accessibility” through numbers.
Given any (universal) axiom system there are an infinite number of theorems that can be proved from it. But the question is: which of these theorems will be considered “interesting”? And one should expect that theorems that can be interpreted in terms of concepts—like numbers—that have historically become well known in human mathematics will be preferred.
But is this just a story of accidents of the history of mathematics, or is there more to it?
The traditional view of the foundations of mathematics has involved imagining that some particular axiom system is picked, and then mathematics is some kind of exploration of the implications of this axiom system. It’s the analog of saying: pick some particular rule for a potential model of the universe, then see what consequences it has.
But what we’ve realized is that at least when it comes to studying the universe, we don’t fundamentally have to pick a particular rule: instead, we can construct a rulial multiway system in which, in effect, all possible rules are simultaneously used. And we can imagine doing something similar for mathematics. Instead of picking a particular underlying axiom system, just consider the structure made from simultaneously working out the consequences of all possible axiom systems.
The resulting object seems to be closely related to things like the infinity groupoid that arises in higher category theory. But the important point here is that in a sense this object is a representation of all possible results in all possible forms of mathematics. But now the question is: how should we humans sample this? If we’re in a sense computationally bounded, we basically have to pick a certain “reference frame”.
There seems to be a close analogy here to physics. In the case of physics, basic features of our consciousness seem to constrain us to certain kinds of reference frames, from which we inevitably “parse” the whole rulial multiway system as following known laws of physics.
So perhaps something similar is going on in mathematics. Perhaps here too something very much like the basic features of consciousness constrain our sampling of the limiting rulial object. But what then are the analogs of the laws of physics? Presumably they will be some kind of asyetundiscovered general “laws of bulk metamathematics”. Maybe they correspond to overall structural principles of “mathematics as we sample it” (conceivably related to category theory). Or maybe—as in the case of space and time in physics—they actually inevitably lead to something akin to numbers.
In other words, maybe—just as in physics the appearance of numbers can be thought of as reflecting aspects of our characteristics as observers—so too this may be happening in mathematics. Maybe given even the barest outline of our human characteristics, it’s inevitable that we’ll perceive numbers to be central to mathematics.
But what about our aliens in their starship? In physics we’ve realized that our view of the universe—and the laws of physics we consider it to follow—is not the only possible one, and there are others completely incoherent with ours that other kinds of observers could have. And so it will be with mathematics. We have a particular view—that’s perhaps ultimately based on things like features of our consciousness—but it’s not the only possible one. There can be other ones that still describe the same limiting rulial object, but are completely incoherent with what we’re used to.
Needless to say, by the time we can even talk about “aliens arriving in a starship”, we’ve got to assume that their “view of the universe” (or, in effect, their location in rulial space) is not too far from our own. And perhaps this also implies a certain alignment in the “view of mathematics”, perhaps even making numbers inevitable.
But in the abstract, I think we can expect that there are “views of mathematics” that are incoherently different from our own, and that while in a sense they are “still mathematics”, they don’t have any of the familiar features of our typical view of mathematics, like numbers.
Numbers have been part of human civilization throughout recorded history. But here we’ve asked the fundamental question of why that’s been the case. And what we’ve seen is that there doesn’t appear to be anything ultimately fundamental about the universe—or, for example, about mathematics—that inevitably leads to numbers. Instead, numbers seem to arise through our human efforts to “parse” what’s going on.
But it’s not just that numbers were invented at some point in human history, and then used. There’s something more fundamental and essential about us that makes numbers inevitable for us.
Our general capability for sophisticated computation—which the Principle of Computational Equivalence implies is shared by many systems—isn’t what does it. And in fact when there’s lots of sophisticated computation—and computational irreducibility—going on, numbers aren’t a particularly useful description.
Instead, it’s when there’s computational reducibility that numbers can appear. And the point is that there are fundamental things about us that lead us to pick out pockets of computational reducibility. In particular, what we view as consciousness seems to be fundamentally related to the fact that we sample things in a particular way that leverages computational reducibility.
Not all computational reducibility need be related to numbers, but some examples of it are. And it’s these that seem to lead to the widespread appearance of numbers in our experience of the universe.
Could things be different? If we were different, definitely. And, for example, there’s no reason to think that a distributed AI system would have to intrinsically make use of anything like numbers. Yes, in our attempts to understand or explain it, we might use numbers. But nothing in the system itself would “know about” numbers.
And indeed by operating like this, the system would be able to make richer use of the computational resources available in the computational universe of possible programs. Numbers have been widely used in science, engineering and many aspects of the organization of society. But as things become more computationally sophisticated, I think we can expect that the intrinsic use of numbers will progressively taper off.
But it’ll still be true that as long as we preserve core aspects of our experience as what we consider conscious observers some version of numbers will in the end be inevitable for us. We can aspire to generalize from numbers, and, for example, sample other representations of computational reducibility. But for now, numbers seem to be inextricably connected to core aspects of our existence.
Thanks to the organizers of Numerous Numerosity for the “essay prompt” that led to this piece, and to Jonathan Gorard for some very helpful input.
]]>It’s hard to believe we’ve been doing this for 35 years, building a taller and taller tower of ideas and technology that allow us to reach ever further. In earlier times we used to release the results of efforts only every few years. But in recent times we’ve started doing incremental (“.1”) releases that deliver our latest R&D achievements—both fully fleshed out, and partly as “coming attractions”—much more frequently.
We released Version 12.2 on December 16, 2020. And today, just five months later, we’re releasing Version 12.3. There are some breakthroughs and major new directions in 12.3. But much of what’s in 12.3 is just about making Wolfram Language and Mathematica better, smoother and more convenient to use. Things are faster. More “But what about ___?” cases are handled. Big frameworks are more completely filled out. And there are lots of new conveniences.
There are also the first pieces of what will become largescale structures in the future. Early functions—already highly useful in their own right—that will in future releases be pieces of major systemwide frameworks.
One way to assess a release is to talk about how many new functions it contains. For Version 12.3 that number is 111 (or about 5 new functions per developmentweek). It’s a very impressive level of R&D productivity. But particularly for 12.3 it’s just part of the story; there are also 1190 bug fixes (about a quarter for externally reported bugs), and 105 substantially updated and enhanced functions.
Incremental releases are part of our commitment to open development. We’ve also been sharing more kinds of functionality in opensource form (including more than 300 new functions in the Wolfram Function Repository). And we’ve been doing our unique thing of livestreaming our internal design processes. For Version 12.3 it’s once again possible to see just where and how design decisions were made, and the reasoning behind them. And we’ve also had great input from our community (often in real time during livestreams)—that has significantly enhanced the Version 12.3 that we are delivering today.
By the way, when we say “Version 12.3” of Wolfram Language and Mathematica we mean desktop, cloud and engine: all three versions are being released today.
What should “just work”? What should be made easier? Ever since Version 1.0 we’ve been working hard to figure out what little conveniences we can add to make the Wolfram Language ever more streamlined.
Version 12.3 has our latest batch of conveniences, scattered across many parts of the language. A new dynamic that’s emerged in this version is functions that have essentially been “prototyped” in the Wolfram Function Repository, and then “upgraded” to be built into the system.
Here’s a first example of a new convenience function: SolveValues. The function Solve—originally introduced in Version 1.0—has a very flexible way of representing its results, that allows for different numbers of variables, different numbers of solutions, etc.
✕
Solve[x^2 + 3 x + 1 == 0, x] 
But often you’re happy to assume a fixed structure for the solution, and you just want to know the values of variables. And that’s what SolveValues gives:
✕
SolveValues[x^2 + 3 x + 1 == 0, x] 
By the way, there’s also an NSolveValues that gives approximate numerical values:
✕
NSolveValues[x^2 + 3 x + 1 == 0, x] 
Another example of a new convenience function is NumberDigit. Let’s say you want the 10th digit of π. You can always use RealDigits and then pick out the digit you want:
✕
RealDigits[Pi, 10, 20] 
But now you can also just use NumberDigit (where now by “10th digit” we’re assuming you mean the coefficient of 10^{10}):
✕
NumberDigit[Pi, 10] 
Back in Version 1.0, we just had Sort. In Version 10.3 (2015) we added AlphabeticSort, and then in Version 11.1 (2017) we added NumericalSort. Now in Version 12.3—to round out this family of default types of sorting—we’re adding LexicographicSort. The default sorting sort (as produced by Sort) is:
✕
Subsets[{a, b, c, d}] 
But here’s true lexicographic order, like you would find in a dictionary:
✕
LexicographicSort[Subsets[{a, b, c, d}]] 
Another small new function in Version 12.3 is StringTakeDrop:
✕
StringTakeDrop["abcdefghijklmn", {2, 5}] 
Having this as a single function makes it easier to use in functional programming constructs like this:
✕
FoldPairList[StringTakeDrop, "abcdefghijklmn", {2, 3, 4, 5}] 
It’s always an important goal to make “standard workflows” as straightforward as possible. For example, in handling graphs we’ve had VertexOutComponent since Version 8.0 (2010). It gives a list of the vertices that can be reached from a given vertex. And for some things that’s exactly what one wants. But sometimes it’s much more convenient to get the subgraph (and in fact in the formalism of our Physics Project that subgraph—that we view as a “geodesic ball”—is a rather central construct). So in Version 12.3 we’ve added VertexOutComponentGraph:
✕
VertexOutComponentGraph[CloudGet["http://wolfr.am/VAs5QDwv"], 10, 4] 
Another example of a small “workflow improvement” is in HighlightImage. HighlightImage typically takes a list of regions of interest to highlight in the image. But functions like MorphologicalComponents don’t just make lists of regions in an image; instead they produce a “label matrix” that puts numbers to label different regions in an image. So to make the HighlightImage workflow smoother, in Version 12.3 we let it directly use a label matrix, assigning different colors to the differently labeled regions:
✕
HighlightImage[ CloudGet["http://wolfr.am/VAs6lxUj"], MorphologicalComponents] 
One thing we work hard to ensure in the Wolfram Language is coherence and interoperability. (And in fact, we have a whole initiative around this that we call “Language Completeness & Consistency”, whose weekly meetings we regularly livestream.) One of the various facets of interoperability is that we want functions to be able to “eat” any reasonable input and turn it into something they can “naturally” handle.
And as a small example of this, something we added in Version 12.3 is automatic conversion between color spaces. Red by default means the RGB color red (RGBColor[1,0,0]). But now
✕
Hue[Red] 
means turns that red into red in hue space:
✕
Hue[Red] // InputForm 
Let’s say you’re running a long computation. You often want to get some indication of the progress that’s being made. In Version 6.0 (2007) we added Monitor, and in subsequent versions we’ve added automatic builtin progress reporting for some functions, for example NetTrain. But now we have an initiative underway to systematically add progress reporting for all sorts of functions that can end up doing long computations. ($ProgressReporting = False globally switches it off.)
✕
VideoMap[ColorConvert[#Image, "Grayscale"] &, Video["ExampleData/bullfinch.mkv"]] 
We work hard in Wolfram Language to make sure that we pick good defaults, for example for how to display things. But sometimes you have to tell the system what kind of “look” you want. And in Version 12.3 we’ve added the option DatasetTheme to specify “themes” for how Dataset objects should be displayed.
Underneath, each theme is just setting specific options, which you could set yourself. But the theme is “bank switching” options in a convenient way. Here’s a basic dataset with default formatting:
✕
Dataset[IdentityMatrix[6]] 
Here it is looking more “lively” for the web:
✕
Dataset[IdentityMatrix[6], DatasetTheme > "Web"] 
You can give various “theme directives” too:
✕
Dataset[IdentityMatrix[6], DatasetTheme > "AlternatingColumnBackgrounds"] 
As well as additional hints:
✕
Dataset[IdentityMatrix[6], DatasetTheme > {"AlternatingColumnBackgrounds", LightGreen}] 
I’m not sure why we didn’t think of it before, but in Version 11.3 (2018) we introduced a very nice “user interface innovation”: Iconize. And in Version 12.3 we’ve added another piece of polish to iconization. If you select a piece of an expression, then use Iconize in the context (“rightclick”) menu, an appropriate subpart of the expression will get iconized, even if the selection you made might have included an extra comma, or been something that can’t be a strict subpart of the expression:
✕
Range[20] 
Let’s say you generate an object that takes a lot of memory to store:
✕
SparseArray[Range[10^7]] 
By default, the object is kept in your kernel session, but it’s not stored directly in your notebook—so it won’t persist after you end your current kernel session. In Version 12.3 we’ve added some options for where you can store the data:
✕
SparseArray[Range[10^7]] 
One important area where we put lots of effort into making things “just work” is in importing and exporting of data. The Wolfram Language now supports about 250 external data formats, with for example new statistical data formats like SAS7BDAT, DTA, POR and SAV being added in Version 12.3.
In addition to all the effort we put into creating new functionality for Wolfram Language, we’re also always trying to make existing functionality better, and faster. And in Version 12.3 there are lots of things that are now faster. One particularly large group of things got faster because of advances in our compiler technology that allow a broader range of Wolfram Language functionality to be compiled directly into optimized machine code. An example of a beneficiary of this is Around.
Here’s a computation with Around:
✕
Sin[Around[RandomReal[], 0.001]] 
In Version 12.2 doing this 10,000 times takes about 1.3 seconds on my computer:
✕
Do[Sin[Around[RandomReal[], 0.001]], 10^4] // Timing 
In Version 12.3, it’s roughly 100 times faster:
✕
Do[Sin[Around[RandomReal[], 0.001]], 10^4] // Timing 
There are lots of different reasons that things got faster in Version 12.3. In the case of Permanent, for example, we were able to use a new and much better algorithm. Here it is in 12.2:
✕
Permanent[Table[2.3 i/j, {i, 15}, {j, 15}]] // Timing 
And now in 12.3:
✕
Permanent[Table[2.3 i/j, {i, 15}, {j, 15}]] // Timing 
Another example is date parsing: converting dates from textual to internal form. The main advance here came from realizing that date parsing is often done in bulk, so it makes sense to adaptively cache parts of the operation. And the result, for example in parsing a million dates, is that what used to take many minutes now takes just a few seconds.
One more example is Rasterize, which in Version 12.3 is typically 2 to 4 times faster than in Version 12.2. The reason for this speedup is somewhat subtle. Back when Rasterize was first introduced in Version 6.0 (2007) data transfer speeds between processes were an issue, and so it was a good optimization to compress any data being transferred. But today transfer speeds are much higher, and we have better optimized array data structures—and so compression no longer makes sense, and removing it (together with other codepath optimization) allows Rasterize to be significantly faster.
An important advance in Version 12.1 was the introduction of DataStructure, allowing direct use of optimization data structures (implemented through our new compiler technology). Version 12.3 introduces several new data structures. There’s "ByteTrie" for fast prefixbased lookups (think Autocomplete and GenomeLookup), and there’s "KDTree" for fast geometric lookups (think Nearest). There’s also now "ImmutableVector", which is basically like an ordinary Wolfram Language list, except that it’s optimized for fast appending.
In addition to speed improvements in the computational kernel, Version 12.3 has user interface speed improvements too. Particularly notable is significantly faster rendering on Windows platforms, achieved by using DirectWrite and making use of GPU capabilities.
Version 1 of Mathematica was billed as “A System for Doing Mathematics by Computer”, and—for more than three decades—in every new version of Wolfram Language and Mathematica there’ve been innovations in “doing mathematics by computer”.
For Version 12.3 let’s talk first about symbolic equation solving. Back in Version 3 (1996) we introduced the idea of implicit “Root object” representations for roots of polynomials, allowing us to do exact, symbolic computations even without “explicit formulas” in terms of radicals. Version 7 (2008) then generalized Root to also work for transcendental equations.
What about systems of equations? For polynomials, elimination theory means that systems really aren’t a different story from individual equations; the same Root objects can be used. But for transcendental equations, this isn’t true anymore. But for Version 12.3 we’ve now figured out how to generalize Root objects so they can work with multivariate transcendental roots:
✕
Solve[Sin[x y] == x^2 + y && 3 x E^y == 2 y E^x + 1 && 3 < x < 3 && 3 < y < 3, {x, y}, Reals] 
And because these Root objects are exact, they can for example be evaluated to any precision:
✕
N[First[x /. %], 150] 
In Version 12.3 there are also some new equations, involving elliptic functions, where exact symbolic results can be given, even without Root objects:
✕
Reduce[JacobiSN[x, 2 y] == 1, x] 
A major advance in Version 12.3 is being able to solve symbolically any linear system of ODEs (ordinary differential equations) with rational function coefficients.
Sometimes the result involves explicit mathematical functions:
✕
DSolve[{Derivative[1][x][t] == ((4 x[t])/t) + (4 y[t])/t, Derivative[1][y][t] == (4/t  t/4) x[t]  (4 y[t])/t}, {x[t], y[t]}, t] 
Sometimes there are integrals—or differential roots—in the results:
✕
DSolveValue[{Derivative[1][y][x] + 2 Derivative[1][z][x] == z[x], (3 + x) x^2 (y[x] + z[x]) + Derivative[1][z][x] == (1 + 3 x^2) z[x]}, {y[x], z[x]}, x] // Simplify 
Another ODE advance in Version 12.3 is full coverage of linear ODEs with qrational function coefficients, in which variables can appear explicitly or implicitly in exponents. The results are exact, though they typically involve differential roots:
✕
DSolve[2^x y[x] + ((1 + 2^x) \!\(\*SuperscriptBox[\(y\), TagBox[ RowBox[{"(", "4", ")"}], Derivative], MultilineFunction>None]\)[x])/(1 + 2^x) == 0, y[x], x] 
What about PDEs? For Version 12.2 we introduced a major new framework for modeling with numerical PDEs. And now in Version 12.3 we’ve produced a whole 105page monograph about symbolic solutions to PDEs:
Here’s an equation that in Version 12.2 could be solved numerically:
✕
eqns = {Laplacian[u[x, y],{x, y}] == 0, u[x, 0] == Sin[x] && u[0, y] == Sin[y] && u[2, y] == Sin[2 y]}; 
Now it can be solved exactly and symbolically as well:
✕
DSolveValue[eqns, u[x, y], {x, y}] 
In addition to linear PDEs, Version 12.3 extends the coverage of special solutions to nonlinear PDEs. Here’s one (with 4 variables) that uses Jacobi’s method:
✕
DSolveValue[(\!\( \*SubscriptBox[\(\[PartialD]\), \(x\)]\(u[x, y, z, t]\)\))^4 == (\!\( \*SubscriptBox[\(\[PartialD]\), \(y\)]\(u[x, y, z, t]\)\))^2 + (\!\( \*SubscriptBox[\(\[PartialD]\), \(z\)]\(u[x, y, z, t]\)\))^3 \!\( \*SubscriptBox[\(\[PartialD]\), \(t\)]\(u[x, y, z, t]\)\), u[x, y, z, t], {x, y, z, t}] 
Something added in 12.3 that both supports PDEs and provides new functionality for signal processing is bilateral Laplace transforms (i.e. integrating from –∞ to +∞, like a Fourier transform):
✕
BilateralLaplaceTransform[Sin[t] Exp[t^2], t, s] 
Ever since Version 1, we’ve prided ourselves on our coverage of special functions. Over the years we’ve been able to progressively extend that coverage to more and more general special functions. Version 12.3 has several new longsought classes of special functions. There are the Carlson elliptic integrals. And then there is the Fox Hfunction.
Back in Version 3 (1996) we introduced MeijerG which dramatically expanded the range of definite integrals that we could do in symbolic form. MeijerG is defined in terms of a Mellin–Barnes integral in the complex plane. It’s a small change in the integrand, but it’s taken 25 years to unravel the necessary mathematics and algorithms to bring us now in Version 12.3 FoxH.
FoxH is a very general function—that encompasses all hypergeometric pFq and Meijer G functions, and much beyond. And now that FoxH is in our language, we’re able to start the process of expanding our integration and other symbolic capabilities to make use of it.
A major step forward in Version 12.0 was the introduction of industrialstrength convex optimization, routinely handling problems involving millions of variables in the linear case and thousands in the nonlinear case. In Version 12.0 everything had to be numerical (in 12.1 we added integer optimization). In Version 12.3 we’re now adding the possibility for symbolic parameters in largescale linear and quadratic problems, as in this small example:
✕
MinValue[{(x  1)^2 + (2 y  1)^2, x + 2 y <= a + b && 2 x  y <= a  b + 1 && x  2 y <= 2 a  b + 1}, {x, y}] 
✕
Plot3D[%, {a, 5, 5}, {b, 5, 5}] 
In typical convex optimization computations not involving symbolic parameters one aims only for approximate numerical results, and it wasn’t clear whether there was any general method for getting exact numerical results. But for Version 12.3 we’ve found one, and we’re now able to give exact numerical results which you can, for example, evaluate to any precision you want.
Here’s a geometric optimization problem—which can now be solved exactly in terms of transcendental root objects:
✕
MinValue[{x^(3/4) + 2 y^(4/5) + 3 z^(5/7), x y z <= 1 && x^E y^\[Pi] z >= 2 && x > 0 && y > 0 && z > 0}, {x, y, z}] 
Given such an exact solution, it’s now possible to do numerical evaluation to any precision:
✕
N[%, 200] 
In case one ever doubted that graphs are important, our Wolfram Physics Project has made it pretty clear over the past year that at the lowest level physics is all about graphs. And in fact our whole Physics Project was basically made possible by the rich graph functionality in the Wolfram Language.
In Version 12.3 we’ve continued to expand that functionality. Here, for example, is a new 3D visualization function for graphs:
✕
LayeredGraphPlot3D[KaryTree[255], BoxRatios > {1, 1, 1}] 
And here’s a new 3D graph embedding:
✕
Graph3D[GridGraph[{20, 20}], GraphLayout > "SphericalEmbedding"] 
We’ve been able to find spanning trees in graphs since Version 10 (2014). In Version 12.3, however, we’ve generalized FindSpanningTree to directly handle objects—like geo locations—that have some kind of coordinates. Here’s a spanning tree based on the positions of capital cities in Europe:
✕
FindSpanningTree[ EntityClass["Country", "Europe"][ EntityProperty["Country", "CapitalCity"]]] 
And now in Version 12.3 we can use the new GeoGraphPlot to plot this on a map:
✕
GeoGraphPlot[%] 
By the way, in a “geo graph” there are “geo” ways to route the edges. For example, you can specify that they follow (when possible) driving directions (as provided by TravelDirections):
✕
GeoGraphPlot[%%, GraphLayout > "Driving"] 
We’ve been doing a lot with geometry in the past few years, and there’s more to come. In Version 12.0 we introduced “Euclidstyle” synthetic geometry. In Version 12.3 we’re connecting to “Descartesstyle” analytic geometry, converting geometric descriptions to algebraic formulas.
Given three symbolically specified points, GeometricTest can give the algebraic condition for them to be collinear:
✕
GeometricTest[{{a, b}, {c, d}, {e, f}}, "Collinear"] 
For the particular case of collinearity, there’s a specific function for doing the test:
✕
CollinearPoints[{{a, b}, {c, d}, {e, f}}] 
But GeometricTest is much more general in scope—supporting more than 30 kinds of predicates. This gives the condition for a polygon to be convex:
✕
GeometricTest[Polygon[{{a, b}, {1, 2}, {3, 3}, {4, 7}}], "Convex"] 
And this gives the condition for a polygon to be regular:
✕
GeometricTest[Polygon[{{a, b}, {c, d}, {1, 1}, {2, 3}}], "Regular"] 
And here’s the condition for three circles to be mutually tangent (and, yes, that ∃ is a little “post Descartes”):
✕
GeometricTest[{Circle[{0, 0}, r], Circle[{a, b}, s], Circle[{c, d}, t]}, "Tangent"] 
Version 12.3 also has enhancements to core computational geometry. Most notable are RegionDilation and RegionErosion, that essentially convolve regions with each other. RegionDilation effectively finds the whole (“Minkowski sum”) “union region” obtained by translating one region to every point in another region.
Why is this useful? It turns out there are lots of reasons. One example is the “piano mover problem” (AKA the robot motion planning problem). Given, say, a rectangular shape, is there a way to maneuver it (in the simplest case, without rotation) through a house with certain obstacles (like walls)?
Basically what you need to do is take the rectangular shape and “dilate the room” (and the obstacles) with it:
✕
RegionDilation[\!\(\* GraphicsBox[ TagBox[ DynamicModuleBox[{Typeset`mesh = HoldComplete[ BoundaryMeshRegion[{{0., 0.}, {0.11499999999999999`, 0.}, { 0.11499999999999999`, 0.22999999999999998`}, {0., 0.22999999999999998`}}, { Line[{{1, 2}, {2, 3}, {3, 4}, {4, 1}}]}, Method > { "EliminateUnusedCoordinates" > True, "DeleteDuplicateCoordinates" > Automatic, "DeleteDuplicateCells" > Automatic, "VertexAlias" > Identity, "CheckOrientation" > Automatic, "CoplanarityTolerance" > Automatic, "CheckIntersections" > Automatic, "BoundaryNesting" > {{0, 0}}, "SeparateBoundaries" > False, "TJunction" > Automatic, "PropagateMarkers" > True, "ZeroTest" > Automatic, "Hash" > 740210533488462839}]]}, TagBox[GraphicsComplexBox[{{0., 0.}, {0.11499999999999999`, 0.}, { 0.11499999999999999`, 0.22999999999999998`}, {0., 0.22999999999999998`}}, {Hue[0.6, 0.3, 0.95], EdgeForm[Hue[0.6, 0.3, 0.75]], TagBox[PolygonBox[{{1, 2, 3, 4}}], Annotation[#, "Geometry"]& ]}], MouseAppearanceTag["LinkHand"]], AllowKernelInitialization>False], "MeshGraphics", AutoDelete>True, Editable>False, Selectable>False], DefaultBaseStyle>{ "MeshGraphics", FrontEnd`GraphicsHighlightColor > Hue[0.1, 1, 0.7]}, ImageSize>{27.866676879084963`, Automatic}]\), CloudGet["http://wolfr.am/VAs8Qsr5"]] 
Then if there’s a connected path “left over” from one point to another, then it’s possible to move the piano along that path. (And of course, the same kind of thing can be done for robots in a factory, etc. etc.)
RegionDilation is also useful for “smoothing out” or “offsetting” shapes, for example, for CAD applications:
✕
Region[RegionDilation[Triangle[], Disk[]]] 
At least in simple cases, one can “go Descartes” with it, and get explicit formulas:
✕
RegionDilation[Triangle[], Disk[]] 
And, by the way, this all works in any number of dimensions—providing a useful way to generate all sorts of “new shapes” (like a cylinder is the dilation of a disk by a line in 3D).
The Wolfram Language has a huge collection of builtin visualization functions—but there always seem to be more that we figure out can be added. We’ve had ListPlot3D since Version 1.0 (1988); we added ListPointPlot3D in Version 6.0 (2007)—and now in Version 12.3 we’re adding ListLinePlot3D.
Here’s a 3D random walk rendered with ListLinePlot3D:
✕
ListLinePlot3D[ AnglePath3D[RandomReal[{0 \[Degree], 20 \[Degree]}, {1000, 3}]]] 
If you give multiple lists of data, ListLinePlot3D plots them each separately:
✕
ListLinePlot3D[Table[Array[BitXor[#, n] &, 100], {n, 8}], Filling > Axis] 
We first introduced plotting of vector fields in Version 7.0 (2008), with functions like VectorPlot and StreamPlot—that were substantially enhanced in Versions 12.1 and 12.2. In Version 12.3 we’re now adding StreamPlot3D (as well as ListStreamPlot3D). Here’s a plot of streamlines for a 3D vector field, colored by field strength:
✕
StreamPlot3D[{y + x, y  x, z}, {x, 2, 2}, {y, 2, 2}, {z, 3, 3}] 
It’s one thing to make a plot; it’s another to give it axes. There’s a remarkable amount of subtlety in specifying how axes—and their ticks and labels—should be drawn. This is going to be a longer story, but in Version 12.3 we have the beginnings of symbolic axis specifications.
Axes work a bit like arrows: first you give the “core structure”, then you say how to annotate it. Here’s an axis that is linearly labeled from 0 to 100 on a line:
✕
Graphics[AxisObject[Line[{{1, 1}, {1, 1}}], {0, 100}]] 
And here’s a spiral axis (AKA labeling on a parametric curve):
✕
Graphics[ AxisObject[ Line[Table[{t Cos[t], t Sin[t]}, {t, 0, 5 Pi, 0.1}]], {0, 100}]] 
And, yes, it works in more ornate cases as well:
✕
Graphics[AxisObject[HilbertCurve[3], {0, 100}, TickPositions > 50]] 
Among many subtle issues, there’s the question of how tick labels should be oriented with respect to the axis:
✕
Graphics[ AxisObject[ Line[Table[{t Cos[t], t Sin[t]}, {t, 0, 5 Pi, 0.1}]], {0, 100}, TickPositions > 50, TickLabelOrientation > "Parallel"]] 
Talking of subtleties in graphics, here’s another one that’s addressed in Version 12.3. Say you’re making a dashed line:
✕
Graphics[{Dashing[{.2, .15}], Thickness[.05], Line[{{0, 0}, {1, .1}}]}] 
The numbers inside Dashing indicate the length of each dash, and between dashes. In Version 12.3 there’s an additional number you can give: the offset of the start of the first dash:
✕
Graphics[{Dashing[{.2, .15}, 0.1], Thickness[.05], Line[{{0, 0}, {1, .1}}]}] 
And something else is that you can control the “caps” on each dash, here making them rounded:
✕
Graphics[{Dashing[{.2, .15}, 0.1, "Round"], Thickness[.05], Line[{{0, 0}, {1, .1}}]}] 
These may all seem like microdetails—but they’re the kinds of things that are important in having Wolfram Language graphics look really good. Like, for example, if you have two dashed axes that cross, you probably want the “dashings” to line up:
✕
Graphics[{{Dashing[{0.1`, 0.05`}, 0.0195`], Line[{{1, 0}, {1, 0}}]}, {Dashing[{0.1`, 0.05`}, 0.0195`], Line[{{0, 1}, {0, 1}}]}}, ImageSize > 200] 
We’ve talked about it almost since Version 1.0. And now finally in Version 12.3 it’s here! Realistic rendering of surfaces as materials. Here’s a knot, rendered as if it’s made of gold:
✕
Graphics3D[{MaterialShading["Gold"], KnotData["SolomonSeal", "ImageData"]}] 
Here’s a surface, in velvet:
✕
Plot3D[Sin[x + y^2], {x, 7, 7}, {y, 2, 2}, PlotStyle > MaterialShading["Velvet"]] 
In Version 12.3 we’re supporting a bit more than a dozen standard named materials (with more to come). But MaterialShading is also set up to allow you to specify in detail explicit physical and geometrical properties of materials—so you can get effects like this:
✕
Graphics3D[{MaterialShading[<"BaseColor" > Texture[\!\(\* GraphicsBox[ TagBox[RasterBox[CompressedData[" 1:eJzsvceSJEuSJNi7e9nj/sL+xVz3OEQ7NDPVVfXqocyMDODIMMbYMUaBEryq 7un/XGbRqKb9gsiLEXk6eVqYqamyKBGbmIiw/N+fzT89/O//8i//4v6f+PrT Tfj/OM5N/K//F/7zF8MdDYz7u/9qePeDe+e/fP4/cPBf/jf8w/n8HVeNn+V2 HJphYEeRmyRhUeKH5jqa5+i+O3HtsWtZYWAGoRVFXpracWQEHo64SezEsZdl OGJHofqv4Xt2GPhZ5kSJnxQ4gjMxiJPwTDdNcQuMY4ehl6VOHPlpGuQZ75sV fpq7aWKGnhF6YVlYGDNLcEcc9HJ+476YFQaM8jKrp0FeeGkm941wIzdLvSwJ yzKu6qRu4roJq4rXphkmP7EdO4hxSZBjvdHE5TiYlRWGOsYMAleWZkZYVwJM LD9244zjpwnw8TNOAOf4eR6VFb7VwnXfMQLXS/O0apOySeo2bmoPl0ShLYD4 eYYp4XI1goOh8ixrurKbF+2c+Oc9/j3+Pf49/u+OfzdLmpZLDvx8Oi26uUNs /YljAf8HUxvZBn4PLA2GUAayBTHgEFVlMZ2ZoY8bWVFgCf74YCjNs3EEIAR5 ScOF/sg2u9W2Wa513wuLIihygOAXWB3mgzFDHMnaLmlbbgbeJVwdzmnTWnHI kblw2CUA+BPX0l0HN8WikroDwgJynLZdOVs4nAOskAY8XsJ2nlgcwwLSICuw u3AcN4WB1E7D9LA6rAhn4l4mtxYhwglBUWAoLir0y9k876ZYPv6K2/myH2j6 JCb+WYL5590sbbqorrAc7J9iNgtKmonbTMbBsD6txr2H8QG+4J/2+Pf49/j3 +L83/nULHHBTDNsu18vdiUuIY2CO+Yxtiz98dwxzeM7YNsFTtqCBv2I+s+3B 9ANyXxKDhvTAI+nQHFiFb4Q+7mKFvul7uuceri/H66sTxVg1LsESYCPcHebA 5ZgATgaSmDD+G5Xl8fG1W25xvpdnQAm0PnFMNbGJZ4PQsU+AmF8UwBNTquer 9fESFpUTRYr71K7ABlB7QD0ABGUBEOw4bparYjq3Aq5dc/iAIWTqyk7zMX9S ZwH0aE2MP13vFrtjWmOH4LEhlnP4nMCVBp5aflhXcV3T7lmad918e8iaqXpi Aezcq1x44iQR7R74GB+T6fHv8e/x7/F/b/xD4g9CBLagNoC/OV7mmwOcCxx0 Eq4Id9wcr8v9ebk/NYs1hrXpnoBx/Olmh/V6CQglF3bLFrvD6enL9fX7+fnb +eUbCDTrOswN0AGK4+MXHJ+Yth2RTAH7cn/cnK+4BCcfn7+0qw2MIoyWgNyB /2y102wXWNFemM9sOdvsMZP5dt+u1kAvLHIsH2sBtu1yszs/YT8YnkfPLolx 9261wfF6vkzbFpxIhysmY+IDPJv5amRamA/sBZRIoNMZHhJmmx12YwRaT+RP sFqeYznr4zWrO7h1at9mgjDAmW33uAqA08nKM9wIq8D+xPn0yKo2rukGYnys EavGEjArbHWABnML/mGPf49/j3+P/zvjD+j4ciyKMPn95RmUBy8MB0GFi92J oAGcpy/b03W+2YdlZdMhIp1hPufnr/Ro8ipp+KYLK9pfXoDn4fq6OT4ut6cw LwzSk49LyL+PX25HowfNAA3BO4Nx57sDDp6evuKS6Won7hLoKYZvdXj6ArRH pjmxbJgAUGB8nIbzMVXsivXh2szXljhlMDGguDx/s4N4aJgeXK2yBCwnzvxp fbjg2rydekmqnhCADwbHjjK8QHdpFCA83ey3p8fD5QU44BbVfIVHBfWSEHfH ZsNf46IGpNiiWTfdnh9fvv/76/f/dXn5jhvhLrAIXwCK11YvV7vLc9nN6+kS WwW83Ky4Q3CmzOoRS6gXK5wJjxKPGT3+Pf49/j3+74k/bhFVtUm/KcLJWB3A r6bzpGpUMCIqa3gcRTvDTOCqGL6vvC0sGbcDn2I+cVnDywD+VhxiFWDkie1+ Hg0HmjE2bSukBzTxHMwWl9w8DAaaaQcR2I0vo9JCsxzD9f0kd6PU8iP1dg7r xaIwW81x8Vc3AZ/SOcLC82ZKBPIqzMowLbw0B/h4YMD2AGWPDOv321vDwyUJ eDNtuqRoYBTMZKiZhgfnMZVgTQR71bOV4QZD3dRdhpPoAOYVpmH64f1E+3B3 dzscYznqPdv6dMV88maGCWC9mAk2Sb1Yl90iBcMWDS6M8yrvZnh4ALECf2xR NVt8Y79hfFgNvwEyvqvpAiyMceQRIuzx7/Hv8e/xf1f8FxtADfB1zwUfrfYX 4BDlZVp14AVbgilwr3AvjI/1OjFmwhi04bsd2eQZg1thZAYBqDkoCrW0B20M nh2ZtumFdhhLsNuebrZY791oPDYdTBVLACX59IlCN85wxIszP87dOFH+y+Z0 Xe3OTpQ48idQsxkGgBqTwXr9NIfdYQX8UAF0PEvMt8ffb28+3N6OLcugC0lW xRPCyLBvBqOBbgJtDMj4S5rAycIcJrY3Ni3N9rg0BoNizBk7BPPEB48KIGhs FTx1dGsQ/Esz34BSJc7egGqjssT+xCbETPCJiyprurRrnTSGR4YnBMzcDpMg LWAsRp2KImunpeAPw5XTBVbB9349/j3+Pf49/u+LP4mgnQYS8sY33AQnTGAC jE++SDMVdmdqE7OkyrCohNdyRbVp07hxSor0XV+cDsnjYmACgIA0cYmPQTwX x4Ebrr2f6FggboHxI8bHEy8HS7ZYBVDF5OH6YZ5AG38FN2Hm4GhgyISoMDQC vhiM6Aaq13RVkNPoQBuUB+6mfzeZmB5fEvpwnaLIZ3JXChLHfcHv8DR9poHx FR8m/zDRh4Y1sR2MJmGRkA5ghNMSN0xtnp8AsaAo46pqF+tqugRuSYHHki6U fYI55N0Uk8cRgIm5wRvFTbG7im6mOZ4TxjRN1eC4ZB3kadtVsyX4t56viH/R 49/j3+Pf4//O+C+BP04DKTCtSGIQWA54Fj4LPK+gLMhifPcVS7atZJ8yZJAp npUXWQk9LCavYv5w0DwAi/FNJtCWmFtI/y5QXo9En7MAflNOso4kObaYztK2 Tdomn82StsXBqCxUFi6+JUAPu5dC7rHmwqw8iAcDGM6VOAv5V0L8mmvrrkvn K2aWrC+Be66oxL3oJ2JHOUKyjIlHIQd0vLFlg4KVE6q+JT8qCyQfGLcGRJiV JJgl5XSu2FM9P8BYYZkDWCwBZsLCk6aWVRcSSII7CT9R8fIUayQFZ1nStFFN lMjdPf49/j3+Pf4/AP8p8z+LXPyRWGXS4r5APqla4l/kRuDD72iXGwAr6UOM XKjoNk4G7b5ZrciFoxMgvNqf95dn1k0wcylTGVDMcfVYyuGSPYknAFGpUKen L6vjmbBXRZCDQ3PyWgpjwdtyJS8rE+cFRkmBP8gOtwD/2kmk6j6s0GdermM9 GBN8s5RDnEGMr+Ls9XyJuZGIZf+4MnlCzbxfOpXYIZbUg4DfwYnVbM7Xcbwk lw3Ab8k6YFVI3s3ydpa1cFErxv1Xm+lmF9DEJQyhwMdQzOONglj2OS/piD/m ADzXx2sgYXpcFUj+WI9/j3+Pf4//++OvmBRMod5u2RJe4X1LVXqQ7C7P+/Mz JwnHKmQylVSovRW7WRLOJtQsc6AJ9tfX68sfcFtMiWioYL2U9UnZhfh6uB2u hY0w58Pj6/X1O1wVvnZLyVlmpHJlMWAkabGhlOAxCws8O11vT09fQXbKuMqs +Ki6D1Uz6LCAjgvEIJj/YnscGLo4kpGKv8OyzJ71XNlXwVuJHOcWrg/nzfEK HpdSDpaHqNRcqUzx8PHzAjjHTR3K/tlfX87PX1msgf9mrCXEOFgCrxIqF1+v AvjyvJEC/Oev/1ZOF7ijKj/p8e/x7/Hv8X9n/APBH6CBHaS44DDb8LuYzulh pQQTLHZ+/r6/vPgJPRFPhlruz6fnb9cvf3/6+m/X1z/21+d8On2rR0sT8Onl 5fvQMCe2DRCiosAdH7/84/n7v+ODS3A+yAs4wzTA//nbv+MWcPoi+Fklq/A2 p8fzy/frlz8ur9+xOlCYonuggeUvtszyrWfLvJkJPnGzWOEWsCNDNvtTt9oC TFUGgg9G2J4eP94/DC2DtdhZCgcKl8w3h+X+hIXD9HDlJIWYzxWw1/pwGRkW RhbTJ2nTABmcvDwwD7mcL5g5IASK7+MjU8L4Xm6+9As+P4CR18cL5nN8+oKJ 4b98T4jnHNkP2/PT87d/axcbOL/YgdhXPf49/j3+Pf4/BH+/KBb7I1YKJE9P 3zDaan9Jqob4Z0mQF5eXP3bnZy/O4qJOWa/dzHeH89PX0/NXlTcLdiu6OTOv UoY2cN/z8zcriOwgissGtJu30/n2AFIDceIzW+0Sin5kYHN8P3//N+AJ+3px CtzyjvhjcMwHvIylYT+4qfB44INnF7sj7l60Uz/mWzj1TgzjA2TsE7hm8Baz psNxVQYOPHHroWFPLMeNGS6BgbDMx9e/gzdxyWJ7CvJSXsdFYEPgszpcxqZt uL56SYgxH7HZvvxDvv/OLDWwpwRfsOrj01eMM11uYUpYKuva3fkJyGPmWAK2 4uH6Us0XcHKxWOB/eHzBPgT+1WwJPIMe/x7/Hv8e/x+Cf92GVcUIOJOImjCr gjRXoWrGtaUUDiBj/pYfRXnF0gwRHcL5Wd2pT5AWUVZFRSUmAL88nh6/eJJS xcSksoSz42W5yrDFxwkTyw/9rJD5JJgqKNJLMieM+dKMwSC+UosYuSjtMMZx ZmHFkcIf8J4ev8K4D5o2NA3D9w2qZ/hM041SO4jVR/Jm6bLhbJAy5q9ZLoby s5xsm+QwB0h2ZNgDzbgdjog/WT5SxR33E013fExAvYKTlU4BGjYbvtv5mtVz BVg43V6egPB8s8dx5rO1LEUBHVfTBZaQ1h3zHFiCMcODBLY08Xn6mlYt4zjt jF5wj3+Pf49/j//7499M06aT90hwryovygAyJg+IwrxkylMUgO+mqx34FEZR FMy8VpFLymTwop0x6bRqw7KCz9Iu16vdCWeGaeHEKeM4DJQzaSrKazfOCIXr MKGL8ZFout0tD5cgK1QRBPaDwxI/voKzw8j0A9Pzdde1Jco/cWyYGK4TwLmf TO7HE+CvqJMTTnJM3nADzfZwF/WCrlttinY+1Myx5Vh8JKiVxNPEdnD5w0QD 1T5MDM11JZcgWB3OzXx9OxzjfGwt5oBJlApIFs0MUHTLTbtYs1BRHNXZdkcn a7ERl3CaT7GlC0CBvQrzBcxnrhRQKavzUinBPuEgq0iIZ49/j3+Pf4//j8A/ J0FEda1U5sC5oAwwl7wNq3BQc20WX5Q1VjQ0LLhIWTNT+atOlqRtC8apZvOM +Uhd1k2Zc4uptp0P+otTfOB/KSVVvsviOyvcomQqF6PkDPHAwcnaKdADtiNL NxlMtylqGnpSmOaAdlV8HIPAcLrvUjbEZd4U+FfzXCsQkaUo9Dn/GtQvVRtU W/Iz+HTYBsnNw2BiuWqDuRJXokJskphBiM3mhCmFRHJKP6V1Y/nBzx8/goLp dTIxgOqp2HJJ3bCeerZoFut6sSrny6hmzL2er7AJc3kaASBRTehwX8kr7lT9 HY4DFjFNCe5Wjy4pP22Pf49/j3+P/w/Av+pYOl2WcFWofSFaE0x2zUvALmpL rHqWbKUQSwZKcdVgfJuhkzquKUMNt4I6rpLKq6q2GT1PgX8iItvEXEItFWv6 olBp7gEBXC4FFFlU0dcD+J/HgwdzAuRHtuGJltHA1CaezexfhuBTIiZ6ejDH xLIGuj4yDcbT+SIuTjiBRLmBTNPlYknxdOuyEt6ZnzIRly6eZJoxwhJxvZg8 vpW8Nk3subDs0DC8KGUFd9MofIKyjOsGDFvMFiBf/FAptRFfG86AJ2urp3O4 YJ4keoXy+g4PKmk7xeZkypYIMfGdZDcDmzOPq8e/x7/Hv8f/h+Av739YzhaF 8Avg17AgLssk34lSSAATUGBKABDuGHw0cIroV8eb4+N8exCoUxWPpr/DNg0U L7XkdZaXSBZuyjSt2fawOT2CggEIrKykllTI2ww9zXfGjnVvTIa2bgb4r92t t7hkYOoqvUrejyVKzc/4Z+rU2DKAP0Ybu3Y5m29PT46I9UlSLrO/JNuWMXos GdDFVYv9g/ljXVTMm85c8SXJvHGscslkZFdy0pJEzgfsOG262bXrjS/lEtxy bYvHj7gR7zKJ46aiXbo58Ye9sqRaUC2QEfmSGc4gcZA1HzmIRqAKsVl12OPf 49/j3+P/Q/CvGqWDhPtuz4+H6yvcECsORTEVnEsw2V8AK3UsHFHxaPFrstPz 18PlJcioKaGQgdMkvRJSFSt5UzqV/ju44+Z0vbx8LyTi40pyFw4yASkTbaXA HVgEH2yLe+Hy/fXl8PiKuVH627HkY6p+QEolG27ayDZ11xF9bweb4fj4ZWRa YE+cCc9R6V2rFgwqvKJKAlXe1Pp46VZb0w+k/YQ3tuUSVX8nOcO4VtVxAENc srs8HZ9epVyRm40SrMV/bjyp3U5Csm0nuiJ5xjyB56+xvH5U5zABWGoYqfIR BVYcBGUuzm+Pf49/j3+P//vjX4g8Bd2Q/eX5+Phq+ZEql46KEnQsxQXfTk9f Mdt2uWYZmpRsBHlxfvq6Oz/bQRKXjTBdutwdlV6r5DU9AxCwHoyiCvcwyOOX v9PjqFuYL66qFZNUX3A+juN7uT9iMkPbeDA1WPNwfcEJcA8N3xf+jcCwy/1p dThjq8CaHdgwy4aWoWoDV4fL5eUbnKbb0UiFaWabHVN5sU+uL+vDebreRVX5 zx5qGW69Oz/hZNMPVeVgvVgqkdUtQ/ZnPAAI2rl0cEuBw+PXv7sxrJlF8uaw Xa1lMk+L/VFZM2SkJlf6q0Dg9PQFTl9SNtIJKAGA69MVsEiq8ON0vaUCSY9/ j3+Pf4//D8GfL5RqEdZg3RzmabrhUDedJIVTttidwMh76rK+LHenarqMqEfN /CsYQumjml4Ak6m3cHP2X/jK5gtiss3xmjWdEfiqaw/Ov758x/l2ECnZohnO f1F5tn/A0MAHMx971sDS4Y7RjsLXQZKBfMOiXB7Ol5c/YKzH1z+O19f1/gxT gjFVCwl1d+D/eTCwAh9D1cs1YIRTBtPM1vt6vmaSGMCRhp67C/EfmczLBaQw JfDBEwW20OFKKVr8hzF0Ol+c8PHpC+Y/tmzNceOKxXfNYnV6ZLEJW1GcrgAq b6cqyVbqOJ4wlJ9QzwROHPABI2Olj1K3gm/s3hzji2l6/Hv8e/x7/N8T//35 OWunfB9VssuA4h3gMwD+AUMnLLj2gzFmaDo4+Gkw1GxXJPj4jgvkAoTx15Fh s68x1pUz8K07HkhKJZfGBQMi8sbMZZ+d5292GPkpIzLiuaRRXVEAMCvutfGH u8+3o6EVslkD8GcJ2/WV/ktWUkBP2sCxRWYY4HyQfsAcWltC8zQx8AdupufT vlGqWmcCWMx5YrlUgg1iy4uiomZ1Xhztzo/L/dlwfBwMJM9W1Dly249xueEG uu05QRyVOD/HekH6sNfQMHXH99McVA6qLboZVoqHBBxhiWJailhf7ki/Blgk rVrmJ+eMNHl5ig1D7dayyeoWjy5Maata1a+tx7/Hv8e/x/+d8efvrgN05YzJ pRjE4BLYxVi6TAaU1/ZCLOFB0+9GI+pXl6XKy20Xm4FmqFIFPytUvitQ0l2P EBV1JMbCcThQy8NJdIeKhjxYqvg4g+NcXQyPaWJbI8sEU6tWlXCvwJ5OGJtB yNQs25BXfK7ueUCVxi0bK4jGNl0z/KlZrqfrveGyaIL5YxJnx+0oGJjkfpxL SUgWZVXcNA777+zq6fJhooNP8SfmG0gGAi7BEwUeQjTb43F2F2qxW8D+9Xw5 0DQY3fJD4C/JVEzQxTTYxw3GKqqyWwBqU3Sr8NCidMVD6q9WquQcwEqnidDw Avypx7/Hv8e/x/9H4M+uNxSOxvhFljQNy67DBLwADgXsgEj3PVe6MOBkk3UN rkibFm6WYkArCD/e3d+OxzifvEz9OteW9sdORAuqyL6IqfrULKqqieMwJbVu XGnBjPMdNmKmrJ8Ud7cqCdYIfbY2aBosFqT8cXh3p41MFXwPqZjkJUymwl00 11FienC4APX9eMQ6vqxkLjFmKKEfhkXEXqqoJBSoMT5+32vaUDdYlyd6rW/p B/hgfKVDXjap5E2lLV8bDnQdHy8RzfC2sSLRJEwBUaC7ACemEFNR4r4wEDaJ y2JDli5SfhzrDdltWTIEItxUdefs8e/x7/Hv8X93/CMpmiswuPyVCqVwT9iA zAvsGFPKwGvsDiMNDpR+tSJZyVaiXp/ybmyfdW3gO2m7oP7kMuuJEnNvxQ7S xSyJq5odyiSuYVHQz48pW1qDm4rZPOveutVTai9wxy4Z+fNocDsZDk1d1V8b IpcnJo5Ukx3p72NJnjC18qwggDcUMOGK3h/lXkVbL2k6pfgt2V+J0kfF+dha 7AGUMMjiiNwrtQfTlELi2BIqz4pDxYyzxzFwxtOFHCSkTCEQQXIl0xepeo08 l1QE3L0G9YfEn4F4+JWSBlDgQozJwpOy7PHv8e/x7/H/MfgzL7R6w0eNJj6I 1MeVqp66XqxIT2WugtdOHIof5GLVWDIZLS/BU6qVfDlbtKsNZqLSmSS0zaQs QE3x0ixV4qUKQyDQrjeb8yO5L6f+EuvvJI8L+Axs/fPkAcz7YEyoDRuFuGO7 3MB1UhlWuJ2IewciwcEuxmboiQ+Vi2R36STJdLOjPvbbG79cPQzY7Nps42NH gSdlHSoRF/w42+7XxwsVYinKSlVtzlYSDESRm+8M1ablFoqDZrmabrZKHlAU /wKlqirFHfQlWZlSNUqfFouql8v59qAWK32re/x7/Hv8e/x/AP4YWTqgMR8p lBlKI55AVSKo3geb03VGvQs2OFMUozFF1pSEWL40syStVJWzGYHPFKbzk+4x J0olyuKmBF/6O9BBi0MSFngzYUn19vx4ff1uR6K8LZ0UhpbOxFpJtb03tDt9 PLQNBvGluRvGPz5+GdvW0DJwMiYjTBqK3jXm5lBbO/R9ulGMs68OJ9yi7Obw /rBYmimJVJRc1huC6Im25APjpqvj+fj4avh+IOXb7OMm+iGBoORmsSiKwz/1 Hc6fecVH5gnnQMD0Pak9CdRkWDDOaUeqqZzS/d5dnvaXZ2n3kIV50ePf49/j 3+P/Y/Cnk1It98fzy9fL6/fLyzd8Y4HwWTTmzXrgFBG1Pn96GGgunR0waTmb T9e72WYPHsF3OZ0r0+hStra/Mq+JQRnPo/JemjCv9XBmH4fr8+HxZbk/4aZg LtgCUz09My/3QZuMLdOKfFE02sOCGGQrn261AQi676j2Ckrf2wpYcy2N0lKM v+T4T4frK9AGIaq+D9KCM8Px7emxnkmzaTZHKzH5owwCO8I0y8MpYkUhuRtX qUkyrywMiU9VrU/X0/MX5n19/fv1y99XpzMeRSaercvLQ5WijPk40qyBerCz ebtaL7YHIInFYj5qbzOvwHMO1+cL87gsPDawlK/q8e/x7/Hv8f8R+It/Mdse diI6vTlcu+UmyisrjFTLA3xjHHxuHga/3Xw2/QBDsbP8/nK4vlwk1RZWiEoK a0wcvgTDcfDLxHJMnwyO+WOGz1//8fr9f73+8e+PX/+xOV4TRsAjxcWqfw34 /W48kvadzLMFo12egc/r4RGQXvJuqoLvOB93xPzh7tkBHxLiqsYaT0/M48U4 oh9+TpvOfmsMxP44+8tTWrVFO6eYXlEAn9X+JHrgj1haPQM+dKbUs8fh6RVD GZ431A1sNkA03e5hr/MLk4r3l5d6vlJ1JXhIwIaBsXC+5rhj23YkfIP9g9MA wvX174AIN8rbKUbm+WGA8yVP2GQcR+Snevx7/Hv8e/zfH3/lX/C+YXg7HP3+ +fZf//a3P/3018+DoejRUcJ6sTvCKPjTL58+4SonTmCUgWF+vH/4cHv34ZbH Pz08KB1UjA/+AgKa7SkRV7Z4S6K4qPwkM1wPvPzp4V5z3azt2L5N8Mf8g6wY mRYGcQQEBvGDcGgYmu0aXjBWebbiGILHQdlxUVs+m69Z9OkYJHKiJKu7op0x Y6pqpVSQ2iA7ofIgLZhsVrWu1GJj4dhLGGFk2Ey1slzmmyXxyDXxNAJ8sB/4 8X0zgufo0TujAGx4Pxn/fnuDrSK4hXAqF1L3YQYhS79dV9p6SjRK0m6ZIWbZ wE30A1nWzSecw+V+MsF9VZc30Rvv8e/x7/Hv8X9v/NnCWPpvAtiPDw8/f/wE VEENNrsh5Liqni/Kbv47oJZUK+BgUO/Ce9D0v/zyy3//y5//8suvH+/vHzQ4 XLy70usG/2q2owaxE2nQmWSY4af7+4/3dyPTiCspbc6S+e54evxadQv2ZQgZ sACeFGUKALt5Nx7fPNzTENTHjuG/tMs1nhNUq4W3Np1vXURj4I+tUk0XeTsL KLVR4gQ8HsDhsvyIdYLARIrd5BVc7sYpjDuybHzbYYTNoPk2xm8XG2ZkpcWb uDczxHzdl+xf1wX+nx7u+AItTYA/53O8wppY8sSyVb6ZyEAlMIHtx7rr82kk CESHMFyfLs1iPdCMieVOQNns8tbj3+Pf49/j/+74Ow7OxHz46ilm6cSDNlGl BG6cvOmUMpqcAvzfb28/D4fAQXNtQO2wW0EIfH759PHzcDAyTcwW+ANYeDoj w8QHhCVRafKOtLBPNBt8pz0YEzhrvgS4k7rBfJKyMfxgaOgqmVYCKw4WMnHt O0m+Gtsmjt8ZY8y2mM5hXCHrWFpeFhI9z9K2qxfrZr7K2zl1xSXgIurZLKkA FQJwXBtWpREw9Qu2oEcmpSJgTJaKBw4OYqpsvpbmYc7OC8B/4llD2xg7JmtS YAjXUftw4tmYT1K3uuvJh3zKDDQRicUEYslno8S3pOaGkmzmJen9eHI3nowt dvlkMliPf49/j3+P//viT74IQ+WCJU37pq3ENsGZrKiQpvP0iTD4QCekmusA CsyEmVfwetIEtgD4mBKzWIXNRe8uYql1kqvIOOxLYSJRH8XIRsDcLRqFzREi SV4NwbaaY0s0P1J5qlFVjxwTZw5ZfOe/hXiSUBEZlg8Liog3eJYhdfxI2iab zrCWuGmUepJS0gPIcND8LBed8Eokld4aQCQNKyxCbrbAECVYNVpYVEBMhezH rhVWLOgYuyb+K+lVoYrXMwEgJETYP9gSFB5ncq8vut+57LEyLPjBrKQVBWyM xRrczI7rRFGPf49/j3+P/7vjPwBfGB6dHSxndbi0q41qwaBqEyQpNwUyIFz8 DvIC50uVtDEwtGI661YbaoqK2qqhUo9C5s1OHNNi5/pUgs4RJTVijM/OyF5G rSdJ7sKFoUp/0n1HyfSBpFTQ3JD6683pcWjphkTeRYXbkgsZWMG1WCCWk3Wd 6GmEOJ/62DmVN5S+KxdeFpL65bEvA5XxSumJQBesgZ+12gaipGpJxzd1FTN7 xQSSwUu4mPcV+Yv9YXd5Grv2yDUlhSwFKU8IPq1jcT6xKjZneyDPlTzhvS7a gEr3FeT7VswYKglxhynKfo9/j3+Pf4//D8Cf3c0iX2oHYuopHS5j21GVAjSK dLe3JLAuGqcBM2l9D/iDgotutj09yhuzXGSRpCjDZw9NDAusOCt5GaWar51f vm1PT0orA3+Cp2NK/R1WioUD/7EwMhsAlYXoIz1dX/+418YDU8fID+YEXIzZ kr+SiFaQb1ZzsH4kBThYgpI/gpUNbqGIiVjENiQOgcofS3x5EphvD9gSTB7L c53iTqaCWpS0IzU95TlOPAe33l+fn77+404b3+tjyQ227o2xPEUEE/EW5SHB lWoO+F8+Ns/+8jKyTGZqSeaAei/Hh5OExXqYIbm7x7/Hv8e/x/9H4D+RAjR2 N0uS/eV5sT2yT6VtU3+7rDp2Cj7jo/JI2+U6ripV9QZz1PMV86xM6pH6KYsv 8m46XW8Xu+N8cwA7l7M582alIAJeDBVHL8+f7h8wvsUGNLlSoj5L0q+S+IbH JB124O0ETMF6+Q4n5cP9HeaPoVgZd7os9kdKmz5/mW/3IF++LitY3YAjx8cv 7WJTzObwlcIipyzq8aImv9ifmsUSdsEGkDK6HPPcnh+pj5dTjs/LU2H8y+Xl q+jHvi4PZ6wIUx17bP2Ag69//MfnweDXm49WHIB/68USK2Le8usfh8cv7Kpc 8s0elxB4xyfO5248Gpo6rAPexxPO8ekVOGBf4arV8Ux+D/0e/x7/Hv8e/3fH //LmqsRxkOfsmLA53A5HH27vwFzAH+td7c8L9rV5PV5fZqudm6SgG811wMiz 7QGXPEz03z/fGp4H72y63m2Pj6LX/brYnZr5ml0yXRs+FEgN5AX+/cRIvU75 I+m/AIRPT98wPqhzutpyfM7fhVOzw9Jevv32+ebPP/9taGhgUsmbPa8PF0C3 Oz9PV7uoZA9Q9WYPpsStq+kyo85GieNgQCwWg4A6d6cneENYlDiSzCubbvYA JKu7UMRRYXq4Y9szm+xwVs9fcRelNCgPDCbGef37fwx0/ZdPHwGp1InswLDn 56/nl+8AP2+mjM4EntrSp+dvWMLtaPjp4R7uKvi3nC3WxyuMgnkud6eoqFRS AV919vj3+Pf49/j/APwT1UGSHWFWO9ZZfP48Mk1X4g4DQ/88GH68v//15uZP P/303/70P+/GY5DvyDbr+RJoDDTzl483N4OBlBtHdpRojje27IFu/PLp5qff fxtaxtDS4MWAdGbrA4b67ebGCiKsV2SIUtC3HUSWH2KQm4eHiWPzpZzvbE/X /fXlpw+///TbryODuqxgYUYxikZdMjKtoW7IS7Ycl4BMgUbesN897CL62AVr 7spGFKVC3CKhmHb5z7ziU7faATTgoF4VOmns44FEOk1jEC9Oxm/5aSHwx2Rg TcP1mBI2eLjTR/C/bkb3mPanh4e//Pbr//zprz/9/vvEdqgT5dkAHy6k7vh3 o9HNcDCy9BE1Q1zgCYt8vLv7+dNHQI0t1+Pf49/j3+P/Y/CPk7ACy4Rwr7Jm CnD+/PPPQMkOGXmn1IZp/Xrz6a+//fbnn3/5+eOHz8Ph2LbU+zcwrOLf329v dc+T90uJ7vmfhyMc+etvv/71918ftMmDqeFDdyPL/8df//zT779OLBtIggpZ hed5dpDAXgNNBzWrFCZ4eXCXqtny99vPN8MhoHZEr1Vk6xonik0vAErACrwP qoVjtTywpM4J4yivwqzMu1ncsrsxzZFX8LOk68FUJUE5Saz6I4Os/TRPqiZt W1C8yhCwwzDKKlwFENSjgvSP3uO54nY4/Nef//rLpw/3+hiLujfHQAOY4Dnh t5vP8C6ZiuC52J/wXqfL7cRyB4bJfWVbqv56oI/v9cmDpg0NA+vq8e/x7/Hv 8X9//EfE31TNJZVahRUEwP8vv/xyN56IoEQsqVM+sAUDgmjutQnMMbEprEfF oSS/G03uRxOwMCiV0qxhqDSaBobxK/jl9ubT8H5kg4LhsOR3k9F/+9f/Af9l oGumBHfgaikVDqZXBWxJYEcMYYPiiXaSyE01DaQmpXkq8sICCqaNJX7K7KZA GtznsxnAhClZfyei2aq1JSCFLcrpPK074F/OlknbBGWOS+rFquxYlA1D59NZ SN3UTIX146qBXWxpOZ11jOnAQHDf/vbht98+fwL/3owelIKf5tsMwdg2dg4e DEyfy4cJPNmN2MmStzzA/DEZUWcKReg7xVax49jp8e/x7/Hv8f9B+NuSbaWE 78auNTR0gCylEwHrwiTrlYUYIbOeYAhmyXquKkNg4R4brvnwbtw4hTM1cajI KhlWIFYX7gaYGgeHtjGw9IGpAfmxZUndRySRelfC94k0RGC7BJHF48IxHyXx jZOxLixQ9ABTyaQqVBSeTlxVqlZoqv9CmBds8QwvrHnLs6UWa1WG8kYuaZqs 7Sid3dTYeLikmM1hkXq2KqYzjCbJw4myAjaALVlYirIN6fIGh/R2NBwYmsoK GNo6bs2wESPskZJ4BT4sReQ+jOHBwV+TOkfmNuMSTADPDFQ+qWtfRD9MKQbp 8e/x7/Hv8X9X/PNcdOd8qtu57HGmADcDRuR96byQVDX8FFcWDhJRqtoYGVRL TWxmaiVeknkZ++bgvvV8mbczlZdrMx7hg3zvjTHBNzWxdSDlCTHbN3jOfHOY bnZM9+VrsUT1U4D5WNrAmg7wskfry+rwDaDWxwvZH0BlwBDI50pwT2VPiagp 4zIAGeCsDueainyJpObmLKOQ0mzhd5aQRFVdTOeqjgNQ5N20Wa4xMZ35aUwM BrYTJgBbhii1WiIkLnEiKoTPt4fN+VFprmIaRuhNXFvlrallSi020648ipAH 69O1XW1UPrBwdI9/j3+Pf4//j8GfJQDSwkAZgtUHbBAWC42y2XHWTg/XL3Sv UoqswkYjy5AULFcKpV1pgpMoHQ8YZbE5tIs13BBcjsHv9NGtNgJb4RJKdtvm WLS1mX2KQQJ/d35a78980yV0z8RdFvcxW5VFGQFrujEOwKdeRxLDWOfnb16s do6nmji4InwngkieGfm+vEnDB67Z6fnr4frKpj8sxM5UPwgm1hJDT7o2hKpQ LpDWbwBnsT/hRnhgEOlvnam/as6iuc2CvkRmy/zhYC96UHAeqb8d+DxTNLcF +UgKUnz1GEB2TlOcDJPhfBXcF/z9Hv8e/x7/Hv/3xD8Q/MOiBL0CBBzfXZ5x 6+l6qwqcXb7siprF+vLyTbPdsUkPCBMuZ4vF9oBBlgxhb2Eg8bbYHBNXLbbU 64NHBnvxNVqS4JzZet+tKNmN0UCgOAjwR5YO/MGP882e4ksBfS6sol1utqdH fJb7EyVS9yfRa6VOCBaC0Y6PX5ww1l2+o/PytF2ttzL/09OX49MX5k1J5Tgg AhFfX/84Pr428005m8PfhAmq+QJrrBeU6Vble57ooLpSnbHYHwEp/DiDRRkW jmD89fF8eHzF4PjGrNKmEd+QPhfue37+brh8f6hkRlaHy+HxBSefnr7tLi/Y MLipzY4MRPvy/H21O92Oxur8Hv8e/x7/Hv8fhT/+BEx2lyfgAL9md3pa7S9p 3alqO9XX/vT0FeN/enjQbMpiwMNa7E5Lfs7T1S6rmXfKF2W2BeqZrnfgXydM LS/SJb+06KaqGBkm65bbcroAyPBuwOMYf3t+XO3PhhcMDQNsBdNjPnOKflPH D7/Lbu6nmH9osYNP3K23l5fveTNlUlZIjYt2ucZ6sUmYJ8ws3BfMOaoq+FYJ 8P/yB+Zfzxhqicoqn073PO0LN9vuiFVP18zLFacPEIWq9UNUVGy16bsYZ3O6 nl++PX/7t9c//uPx6z/Wx2tSt6IQyAYQh+vLWfRaHzRNxWswH2wbPCVgJuvD uZou/ZR2p2BIlj1++fvm9HgzGN4MqL/R49/j3+Pf4/9D8AdpAgTNt1liYNlU tHb8oWmNlZR0FMIVKqZzjKPZ3s3DAEtWb88MP7gdjm7HY9x3YjlDw7L8QF7c +bP1DgiPDAt4TmwW691poyGg9gJNTgaPTxxW2KkmblgsrIk7MugfRmrVQ9N4 0PShbk5sB5c8TDSLDhpTZIE/eDbMioGuj21btXJjI9Esxx2xCjZHrlpMO6qp v3F5/eP89K3sFm/q3BWjMJhhUjYq+B4kOb2hIleaHvvrM/ahG6deQikSqctm soHmuG6UGJ6P+5pexJaaUuXNepPHF+xPfCi+J9pTbpL6UebFqemHA80cGTZM 4Ej99fHptVtssJl/v729HQ3hz2pej3+Pf49/j//74z+itkbgsaUyAPdZenA/ mQwMfeI4SkcuqWqw5+fB8G40xp80l20xYYWxZd1rmgq+DzRDhwMSRZrrwL0K 8xKD3wweMBpcqgdTG1E9lW0U7sZjLIR5VmE0ts07fTzfHevpCuPAxbN8Rl7o mtn6xIWlTJgM+0H0wLHk2sszUOr6cPHiDIOMTIATBlkWFBmIHv8FCWKQpKyB bdZNvSIDn24O17ioo7zOJDQv2nolzBRmVZBSmhXeHxCj9lQSzTa72XY/cWwr 4GaQpg++GfvClebEsrEoUefOYEc7iZd4btlf7DAG/pRaTRJ5JRj6aeEnxZv4 apj4cR5WlZsl09U2yivg89vnz4BIXkJ6TtTj3+Pf49/j/974W9KAXiQ4pNEw VbUjqhX5AWYYlKUrsZUPd3efh8Pb0XhkGANjQk0J16bAUZLZQcziC/yIIp1J U+HItn67uQG5AHMlpg0W030KtJrSxcb0GeUn/pOhywlHE8sF4Y5My6JdGILB cflTjIXL+KyDCDGfNMmaLq9nbpyYXuBEcVAWDM1IrN8KsGOyVKg2aZidlXUd YA+zUlVh5N2MVEtx1CKrWziPqjWPE6fEJ4V7WcMdg3GdiHkFGNaKmZ/myW4E w7JyJM38LGdebp5FZQmuD5LCdENAgQlTZpyBe9fPi6RqYXqwfCxCH0wDyHLd 84Hn77efP7NuMezx7/Hv8e/xf3/8b4cDYBtShYlqq6oGLa6biMrVBeajulKK JpIPfMCDI9MA+ENLZ8heenRKJwLfevvhgbmAmLRpcDEZJtm6Ls5XLemVyKru ubprq3Hu9RHYGcOCjPgKjkZk5hXdH5ieMZeUBXdvOySXKrwUNBqXNQxqyys7 l1m7bMSAKWVtl3fztO3olFHKL2SSVVkDB+CPCyPJy1UJXWnTJjU+TSR1HBw/ oSCSIE8pV4qQs1Wo5+cpvD/8AEpp03BwwY3d3PKUtYRRwr4VCcldchLYi9lh AUgFzGVkuG+uKsEAVtzJuoYJ9/j3+Pf49/j/EPyp/8NXT1Hadd16p9KcRNSo iFjXnNE1k4Qi3Ghkwi8jbvfGWBT2lgK4BRhBpvjNKIwD9rQAIBs0SEqSYuFq tsQymbIrr+lwye1kODA1/JCPobwbZVaQezmdg9dc5qz67LMpokYi5RqpqsAg z70M5khZTJFE+ZR6sKqwzhdaDCXarrK2sPwAPldRAg1Vf13O5tV86Re5UsYm vFT/TkQtPFBKrXHTqCY+RuC2qw38MhJ3TrkngK/Mrd46WhJJZz0FnhkSYjVd 78D1sm2S/0zHFdeSqVxM4pIWEio1q8e/x7/Hv8f//fFnzZq0oenWm9PTl7yd RlXNdpnUzQ4cqbNQlCG4BYoc4aDNN0zB0hy243kwJgNDw+Ca9HTAZwCLOKYR +PgTm+akabfaTlc7O4xUhzUAPjApzYHR8PsBlzsM+jDOzpY9oYrX21Gigvv/ bLXsKxOorgoidhcoFVPgc339AyZLmlaKHWKR7EiY+xRFjDGFb3mwTLjKs9Xh PNscRJFPFsug0ls3Z75w442CSJJ4RZEbeG5xCc7n5sxzlfSr8ngnrsX2EI4p ted0A3Hr/fVlvt4bfsC83JD9KbBS1VeO1Y5S1iHcjR3S49/j3+Pf4/+u+BMW NrKhxBDxX20Pjy9hxm6V0nktTOoKJNWtt1gau9Us18Knnowfrw+X+WZ/Nxqz 87LPDvWgm3qxjqtaWtts4AcBKClbo77EYntcbI5OkPBNnXAo1pLWbdZO4QTh ZNaDiHwHW7BFMey72BwmlsMmZT4rvpn3uzthk+zOT7vL83J/AqGr9m0gOJDj 9fV7u9iU3QJbCOSI6a2PF4qvMsR/qBcr4kYShxOVYQQsIcgKrJcv+uKomM3Y ZIeDP21O13q+DIpMfExKalDf6XQ1XD/MWb4H0JrVenW8bI5XHF9sD5geDuoA 2WXo6vL6x3x9gNOqagkBGqhciT4BUlyLBxgWtvf49/j3+Pf4vz/+jESwc7EZ eV6WgH+X+7MTJliyR7eFskXdcgs/AjPPmq5ZrClwBOikpabUTRxuRyNJIrIB QlK3cJowDVyFP+F8P8vhy0j3mQhwLXcn2NeNU2pl5DnAp/bFYo0zQc15Owvy Usq62a+NVRusy8CK6NaBtXF34Hm4vuDDPNvzC24UFpUq2QZZP375o5wucIuk qtO2xR3PL99O0gcBqM7WuyBnvwk8HjjSb2h7eoryKi4brBfgsJJaRF9PLJ34 sj5cQeXgYjtmt4jVibfWHA8QKREPIHB5+f74+vfHL/+4PH9fbE+wpqordGOM /xXTe9CYSMYmd3GUsT30CouabghpPeN+kGJAv8e/x7/Hv8f/XfGfrxg1oARf DH4sQLUrnK/fjzV4DXGtQgwV05OiJEgLPy3CtAT7qLwslrDNV5+Hw7vxGBDB e4JnMbJMibyPR6alOx6+mcgUhep9FCiYaahhAojComRhtWjWSfGFOTJtO+CL MpXiS/7F+UnBUr44M6Q0m2JNcRblNeYTFxRWDdJcmiwHIH3wL44bbuAn1ETy izwR2dW4qO0gwi1ML6AJ4ACGwZakeYzzOqbOaqz6LIxMA/OR1KySS8747k6C 7/Fif4S9MDLumFbspMyIT16ODItJxZb96eHhZjCkfLc0oYMFscNvHqjOzT7X MVvaeUnmhLHH5N4Mt2CUP6aobI9/j3+Pf4//++OvOQ5VgwIvrisQ7s8fPlBc eqLBKxH9uhhzwHyirMQ8sXaf6y0Um2B1IF/hl1BF3nXPGZosghjqWIjD+guh Zkt0jWAvjKA7PiDCzB2qD1FYD4wsXRsc5qmmhSsv/Zr5arbeA2ScjOPwmCTj K3TixA0T3BFQREXDEry88HImD2xPjzjZ9rHAjClPbPFQ8ht7JsJVKW1XUJQJ 9oWHCMYHemPT0WyXQaLQ1wP2kqNTlmRp2fpSJ0jNpSiA0wSCTqsOH2xI8HUg pR9WGOGmd+PJ7WgIKMa2bUt4aL7dh1lF/djJZOK43j9lBpmgFSVwMPGBXTS7 x7/Hv8e/x//H4K9cGzPw/Cy14xgM8uvNx4GmRwVblcl6GUYHiykiw/GoqqXV AhWZMHmwDwjUJH+5E8c0Qk9eoLGSgsm3rquSe2FlOGiqxE93fVaoMYoRyl9T mAB44uPG7F/vZil9orLCEfA4eB/7gXm8toWpKiFrmiDN8cE0mC1WFsAcDEsS T/K8YasFylyn7C4XV3iWKAE+5qD6KYg8lE8l7cEAt8C9sB8kmpNLZJ8pXhHj 9aXq7/ym493Ogb88h+QS2QnshMpLVJq1bICPJxCwqsus2lJzvfvxZKibrN1j ZB+71NV8R6UcS7qy1+Pf49/j3+P/o/CPypK6RlSTINFgwhhE1Pkqn34NQ8ki K53FVR1LBYTSFAXLMLqdEjEAaEmS1dA26K0IMWF6QEZEs3F5ykI5zDnNMDhm 4jHvqJSAdchVhOyk4+eFm2ZMuI2lcXPgqyq2uKgkiuGp7mxAe0JlJEp2Y1aB 5C+5zNSN45LNd7BJgBUD8VmKYZlgkDPIjkWlEujBcvBIYFLZNaIeuG1R0FWy xUIxperFwywvTj6TtSQwBIyi9L1VuQo2mwpgqQiRAMvqElukthnrCULYRao5 IiU5xRptoC3nB0wM7vHv8e/x7/H/AfjzDVJVKuVSyRFyAslHDYoSDCgi1Uk5 m8NVkbYImcdCA+pIsyhDkkix5LCqoroWydZw7Fr1Yrk8nM2QmhJKEFukR5lG i/8yGVUaKPgMwZDfa8nLFUKkhqovUqhS+ByqQD9MZgZvRYKg4KKbbk5XuEtO 8tbvAIZQ0nnYEsy8rWAU6b/T1Phvs6SaE7eEKPIF7NdZqhYP3HLyWgzGpXWk Lm+63k3XW6XvLV0eQiFfPABQjgODM/hSN5LNW+DppVtt4Jphq1AwXHpG2OFb qi3Tw+KQ6Woei9axOSeuVc6YHjC02L4B0xZb9/j3+Pf49/j/APzx0QNXhcgl lylU7eyl9IxuiBJBdSKQV4lz4D68heAlK4ni0lkCBmTmauipPCjgA0bm+Ylq xxZKqirfbunSbY04FBL6DwOst1lsGJSXQeiYhIHKs5UyPQecO3EduDOOGL2a Lw/XF3ldFsiTA+sdXGmao9KGgSFQkk+J1c02u93pqehmfHIQ7pOTc0E4tVX7 s+CtuRu+t+fH7fmJchyi1A2nUir4MgZ05DkEpmTResZWEVjL+nRZHy7sEORa 2H7UU/KJp8q5wuRHtjl2TOpc+Xii8GCsrJu+yZ70+Pf49/j3+P8g/F12z4nh VoCkQDqL3RGfYjZXyCt2WB3P++uLG6VhXio3p10y7xSXwB3D+dS1zlNlPvwV +K+PFy/KwgK8TCcOJwCE+e7AkoftDv/1/n99djBUt9w6YRIVtXJhwG55OwXO YpoVPClp6Baowo1msT49fdEd716bgHmpH7tcAzTMZHk4HZ++4O4iqZ0E9JtS Sdl6pdNUtzgOfxN0fHn5hkVtjte1LER5UuwEGoYYan95cSJ5JZizOA7nw+LX L98vr9/PL9935ycAqJIKgD/zdc/PE8uRbkGBn6ZAeHO8YN8udidcW8+XLLXz PMXOcyK2EMW/QhSfevx7/Hv8e/x/CP5wedJ8OmNx3GYPfLCKCg6CBKkVRNTl ljoFL87ikseL6Ryn4RKcifHxXyVVSocijdfH6+n5S153EjRPk6bBHYEY1nt5 +S55rRc4R56oagBYkPt0tcXgQVoEOZtdzjb7drlR+VrL3XG23lPIgu+vLN3z FluWSIxM636iGT6rsLEc3BRTmm0Oc3b/2SQV9TQU1WL+KhWq6pawAkxQL1fr /WW5O0k/iFVatSzBYJG1hyWsDqfV/kzlQJtBc4yft91yf8ZNN8dHTKmZr6Ki kh7QcDBjyQd+dcJ4Yjt2xFea2DnwWKerXbfc5N00oVIrPM0AnKsH3ozJt2sr ol+pXMIe/x7/Hv8e/x+DP4vvGCgBw+Jj+RFFUIMYJqBOURIv90dQyRs+Mk8V fzG9wI0yzfEGuj40DDsMVWszrBdQxwVTZCU5KsMHNiq6eT1bZnWXSk4s3R9p eQYSBP/GRYO7+6n4fXkOrveT3HADwwkmlns7HJk++Q5LAPuDNB80nclOlk0d 7JwoqXRf0wuZZJsWuUhtq7q57ekJaLTzNe/ettTrywqm1ya5l2QaoQZ0fFUI /IEPTIwjHM2neoYROFiIZuM0b6AZv93c3I3Gb/3mIqyXJXjYbLjEZEsdtqi7 m4z/9uHDX3/79eePH25HI+a5iSIfXLC5VOrBWJgnHid6/Hv8e/x7/H8Q/pSP gGvjpHFUVjiCVfhxxonFWdLUHruPbQApwU8LeCVYr1Kf0D3XYeqpLyVpzCal t5Vn3YbnAwfLp9SqEqzAUMC/aGZBUiRlG+WVvHBjKB+8CXJMqw6XwO5UNxV9 bD8p1JJxfKgbmDCWPLR0OH3wzlSxw81gQP1VyZhy4oQd2aJUd307iPJ6yoLo LKsXK1BtNV0w0FNRao/nlwV+qOYL2D8T25aEKEZkiimrDoeGeT+ZDA2d0h98 5UgRPyuIgT9u+jDRsUuDHBssaJfs7INNolMq3ISfxU6jrnk7Hvz2+ebD3e2n wQNTc/XJ0DY014Z7C08Qk8SmHZmGCDH1+Pf49/j3+L8//hQ+1QNXYjESxUgz RZEYnA2LJRbDdmNhgqWBrdKmU3pHhnRnc+MkLhvSpbhawBlol9MZpof52GGM e+G4n1PiA9DBHHBecD5r3N4aELNdTlK0qlVBSEEMJkfhwYAeShSDedmFx7Z1 16Uudxrjpn/99ddPDwMl8a26KquoSlTWfprj4SFruqybRhKCp1RgN8e68BF1 qUxVHcZVjf8anmuxW3QiLacZxwmyXPAxYRpsM1DqxLPtt/yxHJuE3ZbTTOmW BAWfXrBJ7sea6qcD/Aemhs8DPvrkdjy800ZjmyEYjhOrzORgoGv408gyVDfq Hv8e/x7/Hv/3xP9uPGL/R8+GXyD4M+YCALOuowQ3U5sSFX0O8wKr9rMC/kvE PgUSPYkZhsYyqUfKTgfTpG3CMo+qouhmql4jrmvgL4EbEGWm8qNUuYTgT3HX oCjBjFJMXcCaOEFlc6nXU6rTJeP4oYjjiXLp/Xg8NCyPqb+E3VGZAMzIyvEY wI/E3yPRYsWN8m6GJwcQrhLlFplxPBhQaVBkBpl/FZD3cxXH5x4IwonjaI79 nyDk0xmIG1ZTGbyYjApg4XJsV81xBobok1vagzFR6FGN1jZZOUKNPotQezaj 8yxU1HGa6r/Z49/j3+Pf4/9D8BdpUDufTpvlGqMFlKoulHg1Q8xxIJmxaYRb 17VqyoA54/yOeaqpKk/DwbRr33rZpzHMVMxmWdux/U03JQnO5hifetRp+pYr lTEpl8LdgRcqE5Qkx4BNE6JyugCG7OkQeFKjwaoNR4xuS5oWkc9ylx1tZNuQ TDk3TuYNw3/eKE2lBK9WWn+SRpXCryznizcpWom8KB0/NSszpGYg30yKgTTP reaL3fWZZYlFrtpSKHFXudaBD+tJhd3Ese8Nulrz7SFrW/wYOSZoFz8GojTO b0eeeXxXsrN6/Hv8e/x7/N8bf3xYESYV07i8Xa1XhzNGkI4wuG9iSr8DKw5V 3xmLHJQqUgMI893+8PgiHk0pyVG+Kp0gAnkqDc5yKVhr07YJyrxh3OSat1Np NxNL8mooUkihKgM3Ap+LFfElIDzbHnAyxVe5QCYv6axo8A1Jl9V5ToRBFHT4 hrnL6VwiPrlyxyRLlk18PAHKlQK6mK2Fckx1sT9hSg/aRCXfusy/pSmpDSgF KYBFJaGBMQHUYne8vHz3olQq9VJVmUjyTZmFazJnWLa0a91qQwC+uzzxPeHg HoDfGaN7Y6xqLnRMOGA4Bo89E8/q8e/x7/Hv8X9//HXBf2CxA44V+c1itdqf 7DD2UhYFY7bTzW4nzeXPz1+358dutVE1CDAN86bO1z34KK/hN4GjcbBeLhf7 4/p03ZwehX061b+A/pqq4zg/TVdb5tMyszdJ6qaYkpQxMqCTsE6oGv1g+bh7 0c1HhmWpIHUcFdNZPV/i0yw3+Mb4joCjmhoUs0U1WzxouhMn8AGBpDD+Sqmq Lg6nZkVtcFdemuGv890Bzw8PmsYOmGUZlxVlxhdrLAHzXx7P3WoLZ82MSNCq TuT6+kckiQGR+F/VbDldbw/XF4ADtDEgnhxgNZZaePb++oL5/OXXnz+PB3C+ cIvZZocdTj3b5QrUjw3jpNGD2ePf49/j3+P/I/BPoqFlgBHAF1ivyrNNikZE ikoMfnx8PT19OT99xV1gnXK2UPXaruiRbs6P5NO0AGI4H/PfXh4Pcsn+8gxC l1pjBuWpj707bI6XFtDNVlFZgeZYYbFishNmtdqf69kyyNnRzPQ9GAK4dcvN QDeHhgkTwGS4dn1ksdvycJ6t97CO1DWz6g3eDaCuF0sRg2LVNqDAf2Hc1eEE 3sf5LfXD6QlSOiNLad/pbMSIua/eB8JnZJrWcoPjwLbsFmFehWUlTXaoH7g5 XsOstPyQ6qnijaoiEVzVzFdhVrEfaBSq54EN84p3v3z69PH+FhbxmQmwxDQo Y95NpdVpNrIMzLzHv8e/x7/H//3xH9vmvT7WfQcUPJe6OZALm9RL8ipZNaUs HhhWgvJd3nTwp9h9JksX+wPOT6q2aKbAU9yurOhmOBOXqz44SdngCPX6spT+ 1+EK8HGc2bnSgiEqKidMnCjxkwLfTsBXaqLXGgB/LAr8O9QtzSEDYl1j2/lw d//p4eHPv/78rz//7c9/+9vQ1MeO9WBMFGi642mWZwURPCwvFwGogEliXpxS NDsrqfJEpcFQ0TH4V3NYe86Sc8k0cJOUEX/LZcZXmGDtokMYsHBjscL4nwdD jXqqmZLaGFvO3XjyeTjCxO5GI130BuGdrY/nZr6+G48Huj7QtbFjThzzbjLC f+8m48+jhw/3n/F50Cc9/j3+Pf49/j8C/9s7fTSwdHhhYIR2tYX/hQnDy1CN KalxlEk6Uz3FTNKqSZnX1MHbwvyX+wvF7vKautyiTZE0THyiTKv4KfiA8rBM v8jyrgOeAKFo5xgKyEsBcoY76o6PlYLXNNtT3XnAd2CrvJ6ODedhoo8MU9X3 TWzr82Dwy6ePv3769POHD3/+5ZffPt9MHOteH4ENMebtaDzQDIyGfQIvMpRS C9MLWT+elW6Y2GEkb/+idr2xgvDD3ecHbQIYJXJE2UBsJGwbWFCznYCrEzUq ycsC49+NNIAMiOKqgSsHPwuXjC0bkwTUQ90YmqaEhwKAGeYlkbcs5vHytaE3 MDVyrja5GT7cjgY3owfgP+zx7/Hv8e/x/xH4s1Gya95qQ9XRXmNDHIel1oxT UF9aCeiJGHUVl9SvjtvGyymXVEznQVpiXSRQ6UqvouoJoaiVDip+MDJes0ta WLCJA+zF/NucJ9tS4s1Iesr6buCm8nIZE2Frg/huBGobgNTYuSaJNdcWXaPA 9IK7yeRuNAYaI9MY2SZjIoH/4e7u4/097JhIlpSSVMJasHNUfhf7I4eMlQPn kWF8uLsFGn7KHC03S+RFHwsJRZA28KUFDx5C3lKwskx3g4ntsmubhPulEzQb QGOlbpzBanAJGRgS0VrTZ5HF2ObzA35jcDwqMG/Zd/HYc6+N4XwNLWPU49/j 3+Pf4//u+PPbmAwt7d5kdBg/Jq5tUxw7DyTEIK3HEk8U9pK2jel8VWGR2wlD zwC8nM6LdpbCKOzXVgdvLNzgv2zQU+MHLqmVfrVfML1WNVlgxXfCJg7WW54t xbFpRJJdykbMorYEb2VsskFPVLLpA/hLwvSwRSKGS5kxlabS6MGWNN1woBtj 06JaeF2DClVKAHxGKrLWjRKbVS2BJq4FQseWo26GqFGBT8m/dcO8LNcxRQaQ 7SSS2ImYmYB9yF1UNlFRMq4kcrKesLPovta+6HIoF5JCfB4bzOm8RSjZAi62 BCYw8Wz4jHjs6fHv8e/x7/H/UfjfgYJtA+CPbGPMHpo2a8qov8qiZkyjnM3x oahpzaCJmidVuHOyEtaVT2cp82yn+IFpwDubbw+gM9A3PKBI5TuJpDYRY4JT Cb9GiiZizDDvpnFZ0QS5akacSDsDj+KrnqN6Jdsx/CaG5jFDmBW8j3HcOFaK fyrJVvVrkPxbtktIuFVosm61TZvGEyuI7neu4kHUxGM1RyAyTalaF+4737I/ MhY+knJpPIGo92m2ahWUJRErSrAVWSfCpgxVXc0XkvEVq4xfXGKEnshxq6cF 32bmsEo5C+C3Ai4p07MGpt7j3+Pf49/j/6PwfzAnt5MheG0iro0hHykrZhqq GfmYzGp/CQvVtoCq1ByQlXepqj7zy1wlWYFA8d9msdpdnhTCvtQpvKlb8xOz jC6J/1P6VfVlLroZPLh/KtpFinl1aWQPBDgxsJjLPCucAPBnmz07JmQ5G9yw jQ5ZEtSG05QsKnlcKu9gytWBOnuY/3+OL7myRF71XNY8V2UL2xI9px7Ico0f mk/rw6wMnQi5CymzENtLE1VFiB/NcoUl2CGfRmx2iLCJYfA2YebZegweSf8g 2kIlp00cG3sJO7/Hv8e/x7/H/0fhr/luWjdwo8BT1N/en7r1FjwrDdRYeoaT d5fntOqKbh5W1N8DY+Kc9ZF5UNPtXvS6M7U61b9me3r009yJ2B8NC8R3OVu0 q+1qd+7WO7AVTxYGlCzffTNfs/NypgofIpXaBNLEmUBbyrHfJg/3CizfLNZw ygzPlzqIgIpM3bRerDCrdrmW14AJ2Zkv2Yr14TJd74NUVESSOCpLDFtOF+p8 /E6bFtTpif4qMF/uT+2K/SCCvKDMlO/CmsAHp6mebridLzWGytXCyfgMNANO nNqcOL+YzjATbN3peguCNljlx5oLWJDjLzdjC36fQxN7To9/j3+Pf4//D8Df s8GJYEyAM98eV/szvvHXpGrBF4raQF6b07VsZ9V0kbB4OWWe6ma/2p/wjSUA vaSiWMdbXtNijSVHeWV6YZDkisrBsDitW+LkVVI1VN5OhIvjCDjAOoYbWH7E 7pzS1hOLzRr6WZjJxAYLu0KUILJQ+V+a40l8HPuE4ZVG9LpZB3F+4vzrVkrn qC6+PT8ttses7trFGshg8kAAmwqLXR24XlwodRmJ1MQBfyAA/o395K15KIyL 8/mcMJ1js1XzZVq36hECJ+DW2FSYj257qnxbSYgv92fcd7E75e3MZPLYWwoZ EVusR6b1oGmGxxY8Pf49/j3+Pf7vjT/7F3jivARYCBgzTAsnTFnCADQCqYOT Ogh2TKjarJ4KhUUTzwalYkWxUkwq6rRswFYgPhBc1mCBZ/Ap1bPdkBIZIm0H D0VJfGu2q1kuCE690epWG8zwfqKBUiU5Cv4RefZuPLkdjX7+8OG//vf/96ff fjMor0STsQNyNzcoskpJQOJQZJhYmJVekjGzK6/CrAII6qXfUp4ocCbmHzPE g0cFnt/N12U3k3ywqdLlwzwxvujBLm3q/vlhUcFxM+URgpGXvGRGcTvHVXFZ x02N9eK5Zbbej0x7qJuGHygBECUGO7acgW7g+N1orLuuGcKjtDAZnI/jwB8s rKSlevx7/Hv8e/zfE/97wd9mp+NApCQSL8lBmrhQdzwrCKU7Z6JayeDWwJk6 q8AzibEEytmVjcx/hg+WIKHzGGsEJVlB7DDZNWY9hZTUUcsoybwos3z+Cb+p Xx1HoLMoqz4Ph1iCuqklrdZ037ufTD7c3v3026+fHh5AwS7bZYbwy4K8HOqG 7vpuyPCHKuVgI84QI7OFBFYR5tR6BZ4lZbcbjC/8noPZPYm2wAWTR4IN0M6b adZMcRCmz7op/oR9hcXikQPeltJ6YuFGmgMErJr5ADmdvqBkd7l2scFuuRuP gZsMLgIgUTIyTYX/x/v7oWEwScCzMXhad9iEE8ueOK7T49/j3+Pf4//u+I8t W3NcCWGElD+SqmcvScG8hhfYQSR6d7GoklZenKtuNRJ0TvXAUyVpWTtVA4JD uTR5McVMqiSX0gym7LryVkocqxRDSZ818pqKy1NhNU7GpoWbwuWR/KjoLVvJ dw3P17AfXBe7QiVc4QQzCJh5+7bet1d/dhTAfcMIph8CH4/eE0uhJZBUAB+4 PJgMJizNGiJ6hdNZPV3CCkU3B/6JmIZKg0VVtnPWSsO1ZB1HpQI3vuw6Vpdk VVp18MKYk1AWuNf9eDI0WMqtksqYTpBQAApbAn7iQNMGOr1dU0m2Ronp4eHE N3w+afT49/j3+Pf4vz/+ph/goBOxrz1TjBjmcFw2QU6VYJ3NPFi+EGPnzaSQ uoNG1UeISGlAPeq6gbMTlSx2Aw8q6MDCqWq1VrHVmmIZJWfHuDydtVK6MEeq KzHfXCUZ78u/5mqxcnImV2FRsdLiFjZkbAWM9qBpGNmTV2cqtjJ2TMrceTQW BrckIM4GCrb9oE0AbM568EqF/mHKtO3UDGN2jmjUKzXGmNopeLmaLovpPG4a V86HQTFtXJKyDl0kysuCDdp87BCP/qZIf0g+sKd6Q/uSpaC7zsg2dM9RaVfw JdmO2cF/bVzrRGGPf49/j3+P/7vj79jS4wDf8FaK6RRTBR3QIxPnS5USqDbN IRGuEgk9KOnpUNJ0ffVhUmtovZUehBJGLzFJ+kfSZw2OWDmdC0EzSOGxyILp T8ybFcEixX1SyFDivvBuCib05irRV0lhS58FXGLbSWSG4dBkfzSAA9jz6XS5 O7HA2aGiuBH6qg4OFDy09TFW7VPlO65bpe+tyiUkTYs9dFTirrwqhEFZfpg1 fKiQxg01i/iqSuaTwVIRdchL1W/O4Uz4blBonaC50pGhW28wgspJwB4YiRC3 LlKu/OHD8wrxIMFnnh7/Hv8e/x7/H4E/qw9YTJE1i/Vss4MVMG3JFApUEQRL zxj4YCxGldcFwo+YfzVfFu0saahEodJrVTTZZGCdr9HYvq0qA4nL1Isl8Mmb qV8UqvZBF9J/G5+Gi6XwWeafxEyOmi00x1XyRzaHZZ6t1LvhdjHmpkokxiLB V88Xq8N5bFlSUpEwVxZ859mGqAviNEsKzCnKIeqyWddV8moO/4Wv5PyTYS0K azPQIx0lOvpfMv+im2F8uG+RiNByGrwqkhJCltphVuxPIXWL2DZL0feWrUg3 EBN4YKkjJbgnnqJjVz1L9Pj3+Pf49/i/O/6Oole1wGa56lZbO0jMQCqO4wj3 olzqYoWhFrsjaMijDEUkflMC9ilny3q2gp+iXpqlTZNPSVi473S9S5vWks7O qgpjsaMOalq2YVEJHWfqtMP1dXO8qtlKawZGgpTaKpZ8NxrbYSR8TcQwjdPz 1/Pzt/3lGWhgvVyXqQ1to5zNl/uzFYSmH6rMLtHfxvyXGAqmVJ13XFFYwo+0 bTHhKCvhWqqKPJ/t4Rg9Ac+qd4lSaZiFUmeh8C875u4CZGwwplo1NcZhvXlV qXeP6hECJsNisaUtX9wr7jc/5hPODHgyj2s642tJiXz1+Pf49/j3+L8//sCH YtryBgl8ij85AXXwVMSZlW7r/Yy6rNft8Vp0cz9lCbMr2hcYk4mvi7X0teeb K8yknC1AyjjIVNvFOq1b1lnLSzNAtzs/SRCf/ZcFATIg7DLb7KvFiutiUKYQ pybGOPirZnkT02XLZinKYOnHcjPfHICnE0Yjk9LcE9cCqWFF3XrnxanmeIbv Y3VJ3WA+sEu9WGNXsKFbyYpp5QCCW7O285M8zmuc6UnSbyXJwMvDab47lPNl JJIgKrW4mi82p0esCx+Vr4v5Y8fCz8LOwQeXM1xV5GwhR/5lqwXTj6jjKm8d 29Vmvj1gsTgZwJbdXJpBJD3+Pf49/j3+743/dC5xDQpH2GHIlNpuxuQl8hdf c+EqL8mtIHLj1PRCw/WDpGC0IstgL7gVfCXVzqK8jks2NVbaGqAzwIsPqLmZ rUBb0sczwFSb+QqQ8hLqb+dUIopi3NEO4EwxGB1mBUhfxS+qBfHXXX+oWzhB tf7BfcHIN4Php8Hg15tPv32+uZ+M9cAB/rA+TMymyZZj+IH5T7s4UUwGTzI2 gy7ZDFrxrxIMCbPSj/Eo0DF+VFAP3PACfP9/7H3XciRJkuQXntzdkpmdnu6u QoEkDc45S86RCVqsZ3Zv//NUzVB99wWolxBJgaASER7uai5lYW5qajWTL3S1 AFl0lmL232T/oAPrUOq3TA1VuLFdw8SNU1MgohR5xaoT7Nv5Gu8zydCw2NUo z0wEjLY1tpyx7YxMe2TZQ9Pu8e/x7/Hv8f8J+JvEn6xUcZEUqatq/NONMulr n/hFJimMFE7KcAMMFWYlU+rirURitMibGcW3U4qUMleSZSxSKNuiYf4af02r Lqa8Epw1u611qx1GCJIik2S3sFUrJ4zHjg2jw5RZM1P5OxU1NRwf/hSzEr0L EfHLi+HUvBoMlFI1MA0MbokyEpys5YdulLJrJxt6+nqYhiXgS/j9op0Jz6qV 0KnF6wEWZfsRqWLimgGCFco2K8ku1gIN6ZWDF4Ja+vgQf7y6YD/gS58lG5Hh +hjfi1NsXVIU2kbqyg94Fr4ZWy52EaZtBh5bRUynnwZDWGFqe2Pb7fHv8e/x 7/F/f/ylxYwXUmK6RCAmWeN06vg6mp+S7OTKgRK1psmbpdQ259PORNoaJmPz BS8moVTTIsKzCuFwmblu56xTE/1tFcpDBFd2SynZIzvrhygfeVnSYY3FFGnz /1r8hHmJSfIIK8nJd6or+EG8LYi0KcnDHkzPepCUYqrSCgGToQt2bKzUERFU eGHN8pBg0C3h34GnUMXIs8W+GlmO6IfnUjfHyeBKgF+0C2ZnygqeWtDO4Kbh f2erPdsM4cu2DaTaju3b8gqThO9WoQ9p5dN6aQ6EKcFtO176pjfFlE2c6KZl P6Ae/x7/Hv8e/5+Ef1TVby0yJRfDsgW6YLq5kJp1uba5B+AYNgWehKgV9dRY CplnrKfI+VBmJWKSkUTyuqRUUcPstoxfSOo84e0VXVuMMK0q1S4q9Cr5fbY2 TrSoAS6vqcO8iLIqyArRPmrdN92/tzM0Rkx1I3qnwVhITYzdonBkmYi/4Ewp eRFSlI/HfUKaBfgMkQqWyOEpeFuAsw7SXKTCa8yQLYfKIp/N8MSorknQlZAt lBI/fNmtdzBiKVpMkoinriwuYPK9ZMsJbc0grYtYcjj1PHjhqKyl9UOgVGGS 2cpa7Nvj3+Pf49/j/xPwTypeKVkGuMJYlEtzDALwo5KSqp5wigigkGxFVbuQ ojNSmPAIqUeYJ3VLhYpu5kvzhZoZ+UxJuQoUftGceKAIS3Mc5TVhRXk3E3kl hz1uCl7sJWxSYCdR3GD8VtHAyJQqqkpcr0/XFDmuHHuWjsBP4IpcKivd8CUA bzc77bCMe6UjW651f+I6WfFHtu1sls0YZxEBrjeXTArbDNFZSyUF+wQVBWCX JnQLaVFUiNVSvZLji+T4Wx2KcBuYjnlTr80R3Hk/aMb4U1iX9L89/j3+Pf49 /u+Mv3hJFbs2AzaIgXfAhOVgLRc97QpLK+eLcrGiqJGUXWiTSluFrOMQH7+Q PgsSR2D+ytdCqAWQVUxbebYcPwy1ypvzpH4dCxaa5bpZbR0p+rAi30lCcYI/ SLmkb7GtJ8BJu1bLQHC9n2RcZp7LLTx/k2wOScIjx4AvRvxls5Na0q63h8tz 3pAl9ec2E7+feFI6gQ8iu3TWwtD4Eqso5gssR2Anr1h1U4WaG/5/u47xoC9q tIAolLNHdvaR/D6fIqUiAJY85Jw29WUTYnyWK+K1R2JYWXWPf49/j3+P//vi XxN//OfPZyEKYDUZK93gktyMsZUGF81y0662bpgmknTG9Xi6JOvnWctaPDbr YdF0rkHNbLvf3T/W81Wz2EiRNT24ypZWJMRuq8VKSadai9dRBHtt+L6fproZ 4Aq77e74+AI7Nuu1pEvSSPVO4wjT7uBPswpBH9wfIi9spGq5wsjLw2mxP7I9 dMFOamx2lsS789Pl+Ws1W+KtADNR3pR62zcKLnDI2BKCnpS9eBhkIeLL2xn2 lSPtO1mssVzPd4fl/tiuN7LTsBOYt5pvD5iPEySAFOMgQoSBClKzdrSjHNzZ UeRJvwmb85eNmuQIZkWv2+/x7/Hv8e/xf3/88Sw4iLCgxLQkFOQ4qKz9LH8T kcuy5f7UrXeWFwZCvpKzo7Jebgryl+ZFt0AEFxUM1kLpv7zYHcTfzZKSJczs 0Sl1EEKFXXXrLb5kpkZ63+ApwA0RjROldhj6ItBRLhbr4wWDLI/37WYLb8Vg EPELDwMjmAPrjYqa4ns8v2JoA9MDpflmP98c8AJQiMgSwUyTzf3D5eUr98N8 TQpuzfM94i9sYWwt0gMor1dICoktG9iCs+5wfdJwvQj3sKMOl5fV4X59OK8P 91i1dB0i/tgqMPrYcgzX1/4RmPB8d1zugNseV3op8XelKBt/xVahgAl5AlTq MHr8e/x7/Hv8fwL+hBe/2xE7GqfCmx0a9tXd0PIj1dlANAGPAxeMeCdMS0DH 5EgNKCi7jaAGOAdUbY01leCkiHc22/sH+BeEbLQCTJYlcK+GF9gBGapjy546 XpDlWpjWif624fmWHzBzwZwLcyXC46WfcqLE9ikPAoS12wKMSIZYlOGCkJn0 nE8XZb8or4t2XlAqHN6ThX6w/mJ7KNk/Yo2FkHMroklk5FatF2e/31wDOjzR l9NCPAJWw5TgsmEvTcqwNGO+zmrqzWK9IT6y5QBps97M1vtPg+HteMIx6yZi gXk6sT1d7PVoPLEdLSrElsOrCLY6k1Ypdggr9Xr8e/x7/Hv8fwb+GZyLkm/Z RrnuTC+c2h5Wh7lRjxRRworTlqYGJF+pHoXmYuKyeeNfRSn+VMyXmq3AkoM0 pzR3u8iaDpOceLYbJ5EwuHA9IA2l2xrmw/7LdTuybLgk4Kl1FjBZ3s1hYjdO WQwShD6VVxGgBYiYMB+MT/JYTvU/NQEgwvWqa+dEMd4WEuXZNrh+C/xnqx11 YmeIiWotlGZzH9u9mxpenKZyQAf8jcBlbfhioyEbYPGZrEmzpoVREFTqlsPT UzEZzye7peEG+GAJWIt0ry4x86FB5hXwhxXwSqPRKF8YyiopqeMKK/T49/j3 +Pf4/xz88xJ+R1vGaMFyLs1o8KC8nWfdDBEZHkHN1UzEtCWkEh4sdblFIhVu JU9KuFoeZ6VdGwhfN61ajIA4SPoaFGxtFrKRJb1qWQVFCf/FU7g8Fc2NlB0f goh4toy2PGEoUTEjz4GndOQJXFVezahoAQRYBJdlmvexhdcqwKZj2zY8jw0j yByo/ILzgVOGCVgbwnkSZzsKGffFMZvQJSlGA9RYr6ZLsqrDPklLdibFsG95 +apCyEZqcTMTKppUHVIzKhtMzaFps+Wc9CEKMgqGYMJWGI4dB4/gowG1uHhc b3ms2iNK3bzHv8e/x7/H/53xt4OYAUU3jySb4CSkv2bzGQ/WZgu6427GpEwJ /OtMQi1MMtOshHBlVX0O/1TZJfivtKVGEwDEP7V+mUdeTSPJfWq66l9JSZJD M5t8VMdlQjy1wyjMCu1r7yYRLovKgr41LySxHmu/Y/hHR2SL4NEkiUOqgKpt a3pIz9CYUu+oCu5RYIRZ9VRaJ/Cwrir/VOEAVo7o9eF6UnOZoEmETtAwzpJ6 cLh4rS4RvhYZv3hpYQ6dmRQmaCQ1H8GJw+mTt0x910iqs3m9kBBIBo7kZE8R CLKCKZiqx7/Hv8e/x/+n4Z92HZxOKEETQq2UbQiauKlEZZrjh6KAjYcqURbX ix5FWsznmobmyHWZMnejpRZSJS0Cd9KwGPjznEp5vFINHYtEaiJ9Z3zpj+Cr rB+rPCQH5KVxt9lhSlJqIQV30n/TSZi1wfVSAB5J0hw4sL4P26Zerk02Pkil di9TfqyUbJNnGwttAF9KfXSC+ZeLBTm6ESlnQiogu1hareVCkS1+VJE0Ur5X Yfw/DUe+gQSb+Keys94C0kbO3zi3Qkm/cqaXCD8hVwFAvirUnAkMTe2+Hv8e /x7/Hv93xr+lM8pnHZ1mnjbrdbtmXjtrGVYwyVLm+LCoOUs8KZRjkxq2v8Si qI+NYMQMWG0nTComF/QXCTHoalmGzOI1zqGcL1iXkeVwxCLu7bHuQAIrI/SF nevzBaDrlNe6Ppw3pwd4QFEIJK9JVWEBvpiAhF41WSh58OX+uDld4Ka1Npyu mZIgb8V6cn3IXTHrBJOEvNnFEn6Wx3pJqKLffKNIY20AiluY929q7R8Be60O Z/aPQ+TIDqTERI8ERRhctMHh0EXcG9+khLG2o1inxyJxOuVI/bWgKk6/x7/H v8e/x/9n4C+Z9EwJrphYtVx5CbMSDCvSmDoVNeOXmGXIXfynxDQrjqPZdjff HZ0w5hIKerFiNms3W7HjptvuyJKSSEcb6zSrNfwXIiCYwJbwbbY9ALHD+Xl3 fsQHA2oTnJCSp/nqeF6fLl6chQW1OOC46UBZHDGHX5YC7UzLNLAEDDjfHpaH +8HU9NIc7w/4KyxeLZfCm93XyxU+fNMgryxRNW9cwGaaJY/XBEMWcTA6EwFt rdHzRTrVk/22PV38lH1IOYjCMiOVN5c2DUruNYT0C3yKxSIoy+vhCFtCGkYQ TyDGsm7RkpXXCdYb9vj3+Pf49/j/FPxD8kjp46KqYGIlyaK8wjV4IsYEpIhc yLNdLLJ2HlVvERaeDnjhv7w4jYsGLslNKcfarDbAoREV62bJn6k0r8R6sXx+ P1vGBcu64ZRlRY+Hh5fT4+vu/nG+OWiLBGnBkMA0MAr5V+HbQVYpnR0QJIrK 9wrBXd500iROea3LZr25mxpjy5EQsl7sj7vL8/7hZXt+XO5Pq90Jt4g4KsND XEzR7KqjGAgivpxhlxaSYNdhJjx5EzJVmJMPAP9+fvnip7lI+VXKNEBACiMy hhW1JcP3pEaPVY0U9KibieOOLJuTTCOMiSUDNzxauWTSwJQ83h7/Hv8e/x7/ d8afXcYKhhj4K2YVV6UdRBg/rdu04ymcpiGoiVq1+AXe8IcOHqzTUgcjTpVM RbEjdq7MKHad5G/kLjapn1FlAn5msZxt9lQ6LRqmVNKErTMT0e6LMxjFjRKq oYahhifAH6DZQTy2HTuKtDkyw5+8xGTa1aacLTF+UJQOozPER7DOThRlI+WJ Yecw6Juvk6rBl5aPoKhgAzUW3MVsmrDZYT+0JOUuUynEY1alqPJ2BluXnYiv kodMHaf57nB5+Tq23IFhAiKprWMsBnPfTsYfbm9/v7m5GU8oxxp6RuAhvsPa nSCZ2p4VMPfEnpthrPrbBqm5zsR2KdkE/JMe/x7/Hv8e/3fFf+p4AFCkgTIr ZsNiTBIgEPN2lnTsVoDJcDlVy1YFaSH6crUkLOA4Ggxo+j5DDBHTZvUxRfyy IGOxHu7C7zAxAhNxVcuRZQFnK4xErDXSky58I/rVGVytFQRap7aEu5zhesf0 w4nrhiUPwSSxUsJY7XLbrXZJ2eJBwVu/npX2a1Dry9sCs/DVfFkIY5bKqBU1 txEHYUuUC7ZCwyCz9b5bbrE9koZF6GSg1SQbUKy1meFZ8L92FDA/tVgD59vx hH0WREDDZyiXTV3303BwPRrBEEPLEE2PkImeqoP/HVu2biEnCfFc0w+Ghjmx vZFpGa7v44WH+lc9/j3+Pf49/u+Lv+c7EbPY2ayzKJ0dsa4tzthnoZ2RTFuQ ocTq7Haelk1S1NoKzQx9/AlAjaVuAiYww0BFVqeBK8kFqtUBeSdOpPRMGxyz YxpAtqPY+aFQZEU+FflgX+naIwkUnq1J6r+SJjUW5qz10ZZk4aOiZEEc+zvM JUGTiWAUZQMNN6B4LPePkIHLPGkbuFf406LlB+bI5/Ns1mrJCUxcURV8riLb keisEroalpoBf4yvdRPaLQj444P5UDAqivRAUijEXNrQNGALX0rtyCsIAyD/ aTgE4Lh4SuZY5KUxmWNxCtNgq+N1pce/x7/Hv8f//fGH49MZAv+ARNYK88yq Dn5NqFZMtQNSVVUVxblGxS6cOITrRFQysi0XCMfSWUB152KGcuRZibvEL5iM TWU/b+I5U88Vqm2oInj4Rs70qrDScomaHXxqduFkHXRGUu7AMKjOlLHcQ+lb rPsgeaChvnfF0zyMpr2MqR8esU8QdcWbJqRrjoMyUzIYecL4LBbA3xeCFlVB 5iuWiszmkjGvVJpP1yuSfUVQFeLimVW5mYxuxiPgz85ricrxJV6eSIuHGNNT S8kRIjcY5g9/jVtUmRwftoSTtxfRX+XImEaPf49/j3+P/7vhH/7AP6kpFi3F ZZTRg9vSErN8xuI7tQ4dk/hEUm0pmh2rcCuGMkKKDqlblDYKYSCNmJVkpUlt GAt+dmibY9eeeDYMIYrTPr4cuRbz5rtTKNxXLdBQ3T9PeLM/0vc5Jim6FqS5 tuutqGSQWEVGkxCx1KC4koV7zSxjPwiuCP8s5nOpm6DyEgsxOpZas76jKrKu ReBWzJZAO5vNVGc7Lku/4DbgCOKRVUh86jksJKciq0ennGdG4GJwjEbumUyV Wa3QVxlbmVuICEvjU0AkTN04Fo4Wm038aE7R49/j3+Pf4/+u+EuRmnjM0E0i lR6VFgwZIxQWU3eRJt/niyCTRjOiTURUhUrK7jbUl5aeMuIWgTaPvBZLeExg O/bskWsOHZPdMAMyVHEBDAG3i2mYAbtk7i/Pp8dX6hFpzwKZhvhZ9rVRx6qN G/SCVPU3cjZHUNauGbgYRwXuMLKr3W0qSvZhqHq1pihrx7LBt1eO8o0wrFrf uJIrlRcAFmszXltIWzSSY7XtgtT3JaYkVoCtNtxhP4UoqFcU8budTJS7q73e SOXC/EVjkCUhsijCm7516mGYyTKNuMe/x7/Hv8f/Z+HPQyHJd+usWEMtktER W/PQ1TarNWKE32+uHQlMXIlN5rtDt92lbdesNnnXqdPBB9Orl2s4sonjTlwX 3oqINS2im269Wx3ut/ePs81OPJdv+C6mcXx42Z+fLS90YzlGq2oMvr1/2Jwe Vofz5v7Srjb4/sd5HfMgs+3ekWS9z442flJTT5ViquvNbHdAnOVLWOTLeqm/ tzvGZY05aMsDNUEi1dMRv4kdtlTgetU5smaEEVwlNoqwFQFCt+H8F/vTbLsD dMCZcWUc1KT4bq4Gg5FpOdKWgnIf8wWpVust1lItFraEq1qFgZgRuI1th4eN dOVOj3+Pf49/j//PwD+SQIzBl2QlKE9XL9aMTaTZMeY23x0B4G/XnwbGVDUu sEDKUB/PyrPFLW4cj2wTrtYIPQRHuOBuMhX1ORM+OqFgxRxXzjeHxfZIRY6q YaZGMhQYBziLfp3P3HpdY6Xr4wXfw2QAv56tMFUWPicqmtQCT1xpeKF44RwT IDK743J/ryrZqfByMTj7By2WCPHyZo5x8L3ir+LhcM2U73uTe0KolZuRD8zL +QL28mLGfVJJ18y2h3a9I4l3fw/vH1GinKEfUAXOWPKn4fDj3d0P/GtsQvaD 2J3waZdbSnAjSEwZggENXGAJH8xN6JSDHv8e/x7/Hv93xx8rIj+2KrTjPEVW s8qP8zAt4XS0rq3bbHHL7XgyNC2PI6RenvlpPrEcOFnD8yeOdzuZ3kzHQ9uY +HbWUrPudjz+7frqw+31wJwyCrPM69H44+Du71cfbsZjeDfR304RNwFnQDd1 fHzCrJD6ZYxfGF6AW375+PHj7R0exMnLksOihCndOLV8uF62sJRoiNyqvCEf GDfCO8M0rINIOH/YUSlkPJfrurAmowD/tMPYDmKR/osxLF48tAcc8EnK5u3L rpOjs9SN+GGcmFX8XfJKsA52CEb77foaH6bUpR4QT0+ErmAH0chypi4papqm xwUwukhzO15CpfEe/x7/Hv8e//fHX7qAtaEcTOGXKK9yKbUgVbXmkZQZBpgw YMfgN+MJVqfPlZxLSOYVxrEBr+PEVEmCS8VT4G2nrgd/9LcPvyofdexaA9O4 m04/3N4MpkYAnIuKLjIKtZJiaFiYaiSi3Jq7xwWmH+C5v9/cwPRuQkEklVfC +wBmThDiVHVctZAtzCs8F5sBoR/bMUjdB/x1tVjjerbszFlIjv0mVd6VF2Vw snguDIEp4U9+kTFmTGJsQsR3lBCfL1RziQaNyQeAcTEUXl0wvq+TyfLfbq6v R6ORZVkBoGZePpZ+FkGSYz+MLBtT/bOFnJum2M8IwYh/0/X49/j3+Pf4vzv+ rvRZaKgvlCTCR2oRfCE+wrOowlHVhu/SywThzWgC3OjXJBmtORGeyDHMIXE3 yDEZ9rvHn7wkMeiUJ5+GAw3BNPnOtsiOZQYBDIoASkdg9FdUU8ejlAcmLI2M ebol6ey7KfcJHkGnzJKNUEzAej0nZA8dqn9kGeaJj0+fnhu+7yQJ9bGlQbNq dMCZOkGM60VVTx6RhAijWFdS1PTOdaeEq2ngUuhJ6kG0CQVP/yS5L0Olhu8h bpJ+CrXw00JMD8EmTD9xHLxv8D3EdYzA42lb1eDiqedxCcLL5W50HBgLt2if ix7/Hv8e/x7/d8Z/YJhv9XQN9UvJICqyWDvLkw1VChk1ecutZwyI7DBU/6uT lFlFIljBTmfKtgLO+MX0/avB7fVwOPVcBHEDa2oJdJibNp3E/H8oV4eS4E7g 3WAUzb+bgcdexmky8XhGJ1TeXHTtKNxHnpVAjbsCCnFnmCTnk0TCBEsDUcnG T1YFUlo8DvMC4EuxRq5S2JxkRPJYQqotJcdzio0UVhyotw3SEsZlkTU1tKM3 0T+J9Xx2Ao1VKgQzxFsKXwNEDxyw35nTO1mvEgm01w+LDaMIfx25liGzxUuC DxOXTY9/j3+Pf4//e+PvyPt/3UgD4oSNbMgpzRnIFIWUIaR0LoFvhiRZ4Yle JnkEOZeDY8pnc6VvUXqUeZzCDHzgT16W741s43o0uJ2OcQ38L7wV1miINX1B 0gh8+lOOz1/YlUCaJrMnTuiLyNJaVy0VHBRfFcqWp98Adk8IunRqoc+KvOVa RPno1mUJyZvflH+ywKSqtX8c/hSUrDdRvq7k3KnLrbwslmxQlrALRZwE9xpC LZASvEi2WSRvHVimi5cKeFtHZPqEgRyMHAu7jtra3dz5US3Cyguf9C1sxemP TZVUtTTx6fHv8e/x7/F/b/x5RsTCCgQpKR5XzpY/SFk2RmBQI3RTLBl+E98I XzdRPe3F7rg+XuB0WHrsWlNGaimcESKskWPe2VP8grtupiP4HXiocr5c7k4I vghg4PNKz2YhRsiSNFjB/kG+xRrx0MXutDqc1Rb6sXmxR0YubUHMdXVaAIK1 16uNE0sFXJK8cYOjUAi6rPgAAlJjWGv5A7yn9D5QOY5C+bRClApUQMkVRRGK jecZpir1fZkbU0Zp6jtTAUfZtuQSS65frYMdOOJ+q5rVZmzbcOVu+tZCAi8w sA5McGch+vJDduTp8e/x7/Hv8f85+DPXkDFCybtZ0rQ2SUGJMosQl1FEjl04 W5GtTtkEk/EX6xE0b46gDOPjofCwetIl/c5SKaBOJr6L72EO1d9bbk8jEwGY r9XKzXKNQbbnx/3laX26lLM5+a7iMfH05e4IE2jEJ1UYlOBrV5v57oCfcP3s zsN2yZ4nfe21nM0KwqRiu7SJa2O9WjaovRUwOHCTlm0UmwqkqJwd5WoqCsIn 6maTLH+slRH40MvLU/ANXPzIwvxdK4owjorNYlNRina+TJsGt8PJcsm2Kf3a iuvRyA7YEgKPpgkiKTyUvSF7z+/x7/Hv8e/x/zn4B74oS5DXqvGX4fom8Ano E1PpuSaCqw09dV5orIQ/YQntetssN8w72K54w0C9ZyZ2xHwwWzdJ78wJPA78 JtDeHh8mtju2WXyHaGtzenh4/f7w+g2f48PLbL2PygrIAApghb9uTpcwK6eu 54vCBvaAFFls6wXFt5knyqiMqkkZ1fpgB2Qp5TPZo40KG5ok4raRmj6tpLZZ chJHdV12i7RsyddlJx12Xk7qmpEg4tAMwWCmVee65KydTxz3bjoF/lrfwW7L RUWybpL6SWGHMRw09pvaC3O+Gg7HFkst/ixXB7Z2GLFgMElJQmPA2OPf49/j 3+P/3vgjeoordo2xwtBnd8jCDqKhaeIDP8KYJQg/3N6SfDUa/35z8/vNtSle G58OOCzXV4Php8HQ8DwNMcauAw/FUuswNtwAaE8cR0zmAv/d6XFgmJg/IH0b PwymjgePDL98Mx7jXjpHCWr25yd45yirWJqXsM+yJv1ZyxDEbMqQFNgtlkg5 wcQT3/Zwrx9SJJyi2dIZMwgN31fl8Civ8AkFW754pHHc1Fkzq0WCT5MveTfH NmiXW3ySsiHhtqQ1VXADWxH2xfxHNtbo8eRNMukf7+4GU3Pq+BMb4SHzUD/K wMtPw9HdxMA42MOe8HLxxnI7mQwMY+r6WB2eohyGHv8e/x7/Hv93xR9TKuBu aj2e4tJ81iOwtJnujGHIp+Hdx7vb28n0bx8+4EFmwC6WFnm5M/gjIHY1GGBA URmKJp59S8aUTZFtP5o4HgmrSYLZlvNFt9phnoOpwe9FlQifqStkMNMif9W0 grzUmujV4R7Xu3HKlhBxqniKbEXlp/nUcZ0oFilvacoph3g8rPMCQ/4kunxv ASOQJPJpCUPg9pCqsDziw+9Fs9AWDPDsqteRNDX9e8c+QWFa4GfMcjlfJpCN TZstdWwLzzVoAh4hwgrYRaZHNjKm5ItOCE/bYqA3vJtMsV7sSX0oKQ2uJ186 XpLFJd5tqh7/Hv8e/x7/98Rf6y/w/z9CAJfdYVw3ZuscN0wRRCCy8NJk7FAx b+hYt5Mx/CP9pue9ZSXIj82B2IfbG5jAlJANFzM9DW+eIn4pvSjVhsgU9Kgq RHAAH0aENd8O1kSqlMQk3596nn4Zk81FHYwEE2Nck7lx5pE3RdIU1ksfDRcf RYgZyXoiXYqF0nwx8ANMaeq6ZIWVxZ9pF2UaJFUHZxdILl6YWllcNLBONVsU syWeG8rWCqhDOBcRv1nIVmtM02PwiesABCzB9EkYsOMIoMHVCqkgYSoqThHM Sr/ObEKxPhdvMjfjCUsCpUmcpuD57hEw8YQv2ceB/Ie4x7/Hv8e/x/998U8C ao2y5E2zyYCd0UqaaQ6CZKHAxVPGkmGXzEjk/5CkA3pj27oa3Eo84lNkO+Lp GS4GJvBu2nlHSypM+sdwZFmI1/DTZJ0a1fP41zznEoTfRXAoxErCEsaXQrlS izvYzl4U7UQKL7BY5paFbF6WC6WKWRuGkFGsF7OrpiRTWMrBhg74ptHzNNyi pSJM32dsMEfrsA91NnYsQBHVtQoliUBHIYJRBA2rG1kmPqTdBgRT1FkLQMoH JamrrYjEvtpmGvtH+tMJzyHBTnMRLbKQnNMotN1zj3+Pf49/j/974y+S18JQ fWO9OqxioO6EkF3pcVjgUORwrMxH+65BOpOvKQ9DhE+l6XAk+W74UEdT2EzH JDFu1NyHKyHYG2cpUGfELD8msz5emtXakN40Co5OSRMWImfBCagINr1zVRWz mZ7dSV2GpGZInaKgk5NG2iQ6pNp264reUapa3OLplHKgS1BxV4zJXslNHQkd V82KEajXSt1vPlqXxk/AgkQp9yMTTPWmquV6IlUnrEAPXFl7oqeUuIZD4d2j KmV81ndTxJtm4puDS3x6/Hv8e/x7/N8f/0zotb4m1lkj4BFkcVjEUNTzWDcx slk1hgkMbWNom/+P2krGEW+RcINq22xw0LaIUODIOCvJ12vcBKeJ6Zn0uax6 ILB59vD6fXf/KDreofYssJNQ6yymvkc/G4WuFLuJzkaUtbNuvfuzTafW/TkC phVxMhiHfNo3PdXIy6QyQtqoOdIejpsk8C32DwqETOsyHc/LWFWnWXXqkLQd IZLN4Mh+0KYSul45rkxh9OX+Hia4mYxZThKHU6IkbSZEYFarRbSYhfrhaSz3 hnjJwfJ1J/T49/j3+Pf4/wT8Y+pvs1JsNm9WW+BcdOwmozVrmPwUkDRtMV8M THNs2+Il47hp6uWq2+woPbra5G1nS2ZBPIuTC2X3djK+Gt4KE4ntNcvZfLk/ bo6X1QGzXZPNK2LUcECXl2/78xObrJGe5AGE+Xa/2J8295fd+Wm5PxXk5fIl QWvryvmyXq5Fwa9gE0yWRaTSWKGUljoUzQawQn/FBotEPSkzvTAqWGY49hxD 3hA0HMspyl3r3lNXHkntedHOq9lSSufYTqjb7jFzQL3Yncr5QusB5e0lwQzx /cAwPw2HmB5fP1jExylh60rsxmnITFi3qHywuKzTmmKwgn/Z49/j3+Pf4//+ +Gvygi0DukXezbOmS5oulPMuJrV9FzMsF0szYNd40w+kg0AND7jYHVf7+9lm j+iGfjzy6Xp8B24Ln4nrXo9Gd+YUj4CxcPHx4eXpyx+Pn//YHB8Q7zCYku4G wB/jXA+Hd8YEk8diAfvh4Xl/eTo+vh6El6uiT1x1GFQw/XrHyUeJtt3hSttG 1ZOkf0T749Qu1/AHOJteABN4aW5Lp6G3s0cmYnheJ/09M/9HdTnwz4n/Kqlb KdCuAUK32mEm8P6is5Fp0h/osVXE8TK2mZrROvS3ZFNZpmxmt5b0uugEin4U da6AdrvI6o7E3ZRt5nr8e/x7/Hv83xn/qGRWmsFREMRFw0x3FFN/lTqoTF6b voflVIsV8B9ZzGvzuVLa4FCztIxFYtqU/sgSbvgwYrPcuHFyNzUGloEozBUl PcxwbNnCvzVGpiWiH8zmPHz+3q62nwaDm/HodjpmJV1RJAW5ryNcb5q3kwlM z4I+OdSqF2v4Ozza8qOp52Ec4l81LLtICzJdizrKWRMRNzVlPZigKaaOfzee OkH8xuOKkpFpCzl2islQCi8rVJcD7puaSHmNcVScSmWUDI/Jfbwn3E6mU9f3 JXhEJLU5noH/xPHwJ1b/NS2eG1eAJQaeaTXjjZ7PfqB1ZbO9Xc4mp7NVhhCP lICGYV2Pf49/j3+P/zvjX7EAmVmSLANuYV4FaV40M4pXF1RDAtSYfzVfOXFC hpVPf6dkVxUXxQzFiWeax8F6824GiIK0MIMQIZsVhuoHh6bx8e7216tP12OW coylhAF47i5P8EQAf2I7A2NK+VbRVjJc79erKwV/bDnAR0lTGB9OH2gDauKQ 5XqaB0MkBZvmkGSbV7AgXgze/lTWE8sF1IYbULUv5qmdn+b459UdycPsmxCz a6dHsb5ISjwS5SGHZSVRVSDsKSabDM+ber7or1aYf7Nal7MlrDl1PLwSwJ9q vh4mwDb2SB5LgRICOpHyYJELQt1mucU38MKU7+7x7/Hv8e/xf3f8y5bl1UxM YPDQV4W6nNTTTnVNGRpI+sBNWKPHMj0R3yOZisqrxVt2uyyZPWf3+URk5Srp axBbgRYa089aMfMvMApclZTamUqOzWcI9wo4QazODhkc6WmVE4cTSvnFXEKU YANQB0NyQ5RFLfjBn9QPMurRI7iigt+EX0vwqduortldNE4GU4MtHvxIWrll rNpAFCaCgZjS1HFsSYjDXiIGFRhegElqvKl6s2/nZhXL5aSIrxA1qjgWldqh aWMy6vc17+MKecxnKr8ByNjnIktSuBkbdAJ5bP56Ti/c49/j3+Pf4/9T8Mck ZahI+Eh8RMTytFiz7VJS4YikNsG3JT0tIVggutmJpkU4kziSf/JMzBafC7+D KEnVkyau80NDG1jh+kR5qrydBQsk9LL5TsbKBTh9E36/5q4QLqvCm0mRmqe5 70hS5H+qXiuFTOVYsZ1kV7QIhaSbWyqAR3Cy9KdFKap3VPbWJehibWnx4HBp oZxJFnDBtC+FvjnPQKahdGLRJy98doVm3Rw+uD6rEU91aTNTHVemWgQf5oaq UpqyZbpkhmANQrBl2S2Jf9Hj3+Pf49/j//74L9K280QdupjPi9nSFSlROL6p 595Z05Fj4veBbQiHKtQiskBYo3FdlfMFuU/CYrUFf+0vQ625mG2Xw6IiTUsk qRE0teutEfgRRV8l91Hmak0tRkBglXYdNwOfEq1Pl0wy+xKRpTLJUIheNuDS RDkWGwlR1suSrJuxLyfnIKJJtfJpmVXxpCYOEJGFVVas705iGEh3miUsLCo4 Sf6Fsq4RT8lSac0sxSZcVLVYFjPqaUvmPeGeEelvKQbx/JzCU29yVdKyAV64 XCzCqpCyCzGfpIqkJRCzPKnUdwj+WY9/j3+Pf4//e+PfdNJBjKSgbr1dH85c AnyTFFOw+NpVoSEbC2dhmiwczzXZH2G52J+sgKRZlY8wpNxAtVKZuxFGk83k Mo+tTo+v94+fecxVVsJHTUiULdgKRyWsmbaua0xYI7j7p8+z9Z562kKLlWIQ Syc28R3tekOSVVmqk22Wm+39A4Ijl7Ie9H26K1SgTzWd2F0CrlD8ZrvelPOl yIPEU+kZwSBUSuqULSw9Goo/XwDm28PqcM/ItBChP17D9wSVsdXlRw2bqand i9lsuT8hmFV5W60Q12JA6ePA9H3wJvrd49/j3+Pf4/+++EfEHw5RKwIA/u7+ Ybk7se0meU1cEZ64u39cHy/r47ldbYWhGoredTDfHbBedrTMC1W0WB1O5+cv j5+/X16+XV6/bU6XfDbT+jJAcf/0Bd9P2Kk5lerscn28310ecQsuvn/50m12 MIp4tBTOHfgvNgf25WT5HgPDZrGWpg/n5f7YbbZATxU2NJ/SrXeHyzP2A8kA ZOomePpss8P3zXKtTRa0cYMeEgLPdrkZWTbmo4eHeAEo5gu8JCx2B+xGlm+n 8ieyuQosZ3v/iKAPYZ3u21wQBjiL/RF3AXAGWTwGJLsY+xPXS4a9SxpWgmN8 rBGrxhIwK2x1gPYjoox6/Hv8e/x7/N8Zf0BHsdA4xuRVBLucLfElXOHqcCZo AOf5y/78uNwdo6rW1gzwHZjP5eUrI5qCBXe4His6PrwCz9Pj593903p/jopS 9FrZl5P+9+kLSblTE24I0RkrGg4nfHl+/opb5puDkGBTUS6tTs9fgPbIsibU 62axBsbHZbgeU8Wu2J4e2+XWlqAMJgYUDy/fnDAZmpaPUKuqAMuZM3/enh5w b9HN/TTTNwTgg8Gxo0w/NKjvylzMfHfcn59OD6/AAY+olxtq/cmJGZ6OzYa/ JmUDSGNh5O4vT6/f/+vz9//z8PodD8JTYBEEYpFEbc16c3h4qWbLZr7GVoFf bjfcIbhSZvWEJTSrjVZk47Wkx7/Hv8e/x/898ccj4rrhiRP+/394weoAfj1f pnWryYi4ahBxlN0CM5GuAYFGW1gyHgd/SoZq1SDKAP52InJDaT5xvE+j4WBK 3pT0HQ4nvovZ4paru8FgajlhDO/Gw6isnNqu6QUqkc1WNXI6h/ViUZjt1PXw V+F3MTjCwot2TgSEZBtlpZ8xh44XBmwPuOyRaf92fa15c/hNJr7LFkbBTIZT y/QRPGZaXQh7NYuN6YVDwzI8XysjImFwWUF0O5n+fnNzPRxjOXrOtj0/Yj4F 8+ZzrJeJeHZY25JJCw9btrgxKVirHotwB/DHFtXZ4mci0k+wGmlXsyV+1nMW kmAceYWIevx7/Hv8e/zfFf/VDlBTR8j34I82x4eAitOVtCRrHKHaIrzCszA+ 1usmqRZNm4E3ozd5weB2FFthCNcsJRJc2t10TDFty7H8yIl4toYQY77bY703 o/HYcjFVLAEuKWBMFHlJjm/8JA+SwktSjV9258fN4UJFU/mTkMHYrBmTwXqD rEjIwqqlBQ91nPAusdzf/3Z99fv1tZB7fWVY4Q1hZDpXg9HAsIA2BmT+hf1D Dzn76fhjy5467IajdRaYM3YI5okPXhXgoGMhcc22cPCv7XIHl8qoqmnhauOq YsViyZlIvUadt7Ns1rlZgogMbwiYuROlYVZKRV7Byr6Old1S372q5iusQnVZ e/x7/Hv8e/zfE386go51AXj/x0+ECW6UwgTkr8JfZLmm3aUqLaMStdRrI7pR V5u1rZdkdJGBF0jQgXlqYoJE2ZS3BKzLI1kXuOHe24mBBeIRrHGrK194s1nb YRVAFZNnWXRZCG21gm8SnY1S6wGljzMPBmOGgXpMV/8pFQiXB9/N+G4yYRce CvdlKtyEmcCJ47nw74g0RVWDR3yY/N3EGEpLBdaPMC1CvQ7cBTN5Uebw+pSV KWWV1HW32tbzNXBLy4a8ZdknMfWp5pg8vgGYmBuiUZYENk05W0xd340SmqZm bbiwDopMSlTgf5vlhviXPf49/j3+Pf7vjP8a+OMy7QJvSw6CDSXzCjELIq+w KqV6InmTGxLPq5KkbwJNPMhKGWGFKkbEagsAi/G1cE+kRxHfhRr1SPY5D6Xp mLRLZlainC+yrku7tlgs0q6jXEYlrdMiXzXrVMdb66+nnssqhoJpF5YNSp6F /ldS/CQMex6DryRTyQ7ZVxTiw+sE/DVbJIiT1Yae0grH18JwDUL1J7WS8jwU PjAeDYgwKyGYpdV8qd5T3x+E7lsAWCyB6iXUAGlk1aUkkhBOIk5UvzzHGumC 8zxtu7ghSqJ20uPf49/j3+P//vjPyf8sC4lHEmXS+izBa9K6I/5lYYYB4o5u vZOu8YHUJiea3XakCu/NamUhPprNDjbHy/HhxctTYS7lyoAix9VnKYeUsBFP 9nQWKtT5+cvm/iIqSWUoTXPo1zIYK5Qqv1gUkCptfwb84ezwCEd69ziyB2wy ft2Ja9+ZE/xkKYcEgxhf8+zNcq2CeLp/pOZCoCbvt9LSQhgRE2Y99XJTL5Y8 jpNSC9kA/CmsA2yqUlQKF3k3kz5BSbfZzXeHkCauYAgFn9Ic0t8hkX3OW2bE H3MAntv7x1DS9KGogvf49/j3+Pf4/xT81ZPCU+jplipav/XlkT47h4eX4+WF k2Qttq/K1Sy1ILwUoNa+CVLmQBMcHz8/vv6BsMWKtFg7VKnqt7ILifXwONwL G2HOp6fPj5+/I1ThsVtGn2XFb40VvDQWWixNzD+RH+vPt/vz81c4OzWumhUf tnL2HW3xwCZo7NdG9izmv9rfD0xDAslY8++UxWazNk/2VfimB865RdvThXrg 0lHa+yEqoqXW2lIhKErgnLRNJPvn+Ph6efnKYg0psgOwGAdL0P4OIgDOOBHg y/tGBvBfvv5nNV+xrVuW9vj3+Pf49/i/P/6h4A/Q4B2kuOC02PFnOV+qOCrD n7K8vHw/Prxq52JfhlofL+eXb49f/vH89T8fP/9xfHwp5vO3erQshT99eP0+ NNmbnoIeZYknPn3558v3/8IHt+B6OC8R3wuB/8u3/8IjRLmiQiyDP+3OT5fX 749f/nj4/B2rgwtTdw80sPzVnizfZrEu2oXgk7SrDR4BOzJlczzPNntttSC1 exFG2J+fPtzeDW1TxVHZcHm1We5O6+MZC4fpEcoJhZjvFbDX9vQwMm1XOgRh yVnbAhlcvD6Rh1wtV2QOiAPFz/snUsJ4LrdcByXfH+CRt/cPmM/98xdMDP/k OSHlwbkf9pfnl2//2a12CH6xA7Gvevx7/Hv8e/x/Cv5BWa6O91gpkDw/f8No 1MeuW+KfUzX64fWPw+XFT/KkbDLWa7fLw+ny/PX88lV5s/Bu5WwpHZmZ2sBz Ly/f7DB2wjipWrjdopsv9yc4NThOfBabQ0rRjxzeHD9fvv8n8IR9/YSy1cWM +GNwzAd+GUvDfvAy8eNhAD+7Otzj6WU3D5JCeijzTAzjA2TsE4RmiBbzdobv tQwceOLRQ9OZ2K4nzZ1hICzz6fM/4Ddxy2p/DotKjuNieEPgszk9jC3H9AI9 JMSYT9hsX/4pP/9Blhq8pyRfsOr7568YZ77ew5SwVD7rDpdnII+ZYwnYiqfH 13q5Yjc3thDKTk+v2IfAv16sgWfY49/j3+Pf4/9T8KcodO2LHJAwrOowKzRV zby2lMIBZMzfDuK4qEtpSYNgBNfnzUw/YVZSrZqSrcyb7y9P56cvvlCqSEyq KgQ7fl4owxYfN0rtIAryUuaTYqpwkX6au1HCQzMmg3ikRiG7vHKiBN+ThSX9 DoA/4D0/fYVx76bToWWaQSA6rgFpunHmhIl+hDfLkA1Xwylj/lOb+qhBTt0k TAbmgJMdmc5gal4PR8RftJi0uONWxFoxAT2Ck5WyBQM2G352yy2r50p44Wz/ 8AyEl7sjviefrWMpCtxxPV9hCVkzI8+BJRgLSnnnKfF5/prV1F8qugWj4B7/ Hv8e/x7/98e/nYv+M6W2o7L24xwgY/KAKCoqUp7iEP5uvjnAn8Io6oJd6V+D QCmXwctuQdJp3bGlQpJ06+3mcMaVEcX3MuZxmCgnaUoUU3NC4bkkdDE/Es/3 h/XpIcxLLYKIKGeKuIlHcE4UW0Fo+YHheY5k+SeuAxMjdAI4t5PJ7Xhispsz XScnnBaYvOmFU8dn+wM5oJttdmW3HE6tse3afCVoVOJp4ri4/W4yhau9m5hT zxMuQbg5Xdrl9no4xvXYWuSASZYKSJbtAlDM1rtutWWhogSqi/2BQdZqJyHh vJhjS5eAAnsV5gvJZ64VqIzVeZmUYJ9VJDYmnj3+Pf49/j3+PwP/gg4ibhpV mYPPhcuA51IdaXw59RwWX1QNVjQ0bYRIebtQ/qpLxbkOHqdeLHPykWb5bE7O LabazQK4vySjJDV7Ypa2kppEIjsuKxG1TjVPjQAn7+ZAD9iObEPl+4zANSNf CtPYzl7z4xgEhjMCj7IhHnlT8L9T37NDEVliaxsM3sD1S9UG1ZYCtkLDNkiv 7gYT29MN5kleSXTwUiuMsNncKKOQSEHpp6xp7SD824cPcMGMOkkMqJhYKQu2 Ipotm8WqXW2b1aZaruOGOfdmucEmLORtBIDEDaHDc4VXPNP6O3wPWMQ0FXy3 vrpk/HQ9/j3+Pf49/j8B/3rG0mnpWUztC9GaINm1qAC7qC2x6lnYShGWDJSS mv3FHKZOmqSp2YKhaajjKlRerdpm9jwD/qkTCZG1LCXVwj6YGEo19zzp4ykF FHlcM9YD+J/GgztrAuRHjumLltHAmk58EcoW4W4iJnp6MMfEtgeGMbJM5tN5 EJek0itNw0DSdLlYuniGdTlbQrBhXC18Y2GaiTY41ystJCrJH5HiZfgeLDs0 TT/OWMHdtopPWFXajbpcrOB88YtSamMeGy6AJ2ur50uEYNr9OZLjO7yoZN0c m5OULRFi4pnkbMEWDHx16fHv8e/x7/H/GfjL+Q/L2eIIcQHiGhbESdcYT6SQ ACagwJQAIMIxxGjwKaJfnezun5b7k0CdaT6a8Q7bNFC81JbjLD8VFm5GmtZi f9qdn+CCAQjbLsj4mvK2In8auGPXvjUnQ8ewQvzTmW33uGVgGUqvkvOxVNX8 zB/UqbFtAn+MNvacarHcn59dEesTUi7ZX8K2ZY4eSwZ0Sd1JUx52dqBi3nzx Zy9mXKNcMhnZE05amsr1gB2XzXeHbrsLpFyCW67r8PqRtBJdpknS1rTLbEn8 Ya88rVdUC2RGviLDGU4czpqvHEQj1EJsVh32+Pf49/j3+P8U/OtWdZDw3P3l 6fT42ZcO9aKYGknDNZ6DcaWujW80Hy1xTX5++Xp6eA1zakooMgiapAH9W2/6 N6XTJJHgKNydHx9ev5eS8fGE3MXGCrmaIDZCb2ATfHhbtvsJg+Pj6+npM+ZG 6W/Xlo+l/YBUJRth2sixDM8VfW8Xm+H+6cvIsuE9cSUiR9W7FkNnml7RkkDl TW3vH2abvRXQs1sUG5dbtP5OOMO4V+s4gCFuOTw83z9/lnJFbjZKsJZ/bjyp 3U4jetuZ6IoUOXkCL18TOX7Ua0gAlhpGqnzEoZ2EYVVI8Nvj3+Pf49/j//74 lyJPwTDk+PBy//SZTTOlXDouK7hjKS74dn7+itl26y3L0KRkIyzKy/PXw+XF CdOkasXTZevDveq1Cq/pBYDA68EoWriHQZ6+/KP40dwzqesNSaqvuB7f4+f6 eI/JDB3zzprCmqfHV1yA8NAMAvG/MTzs+njenC7YKrDmDN4wz4e2qbWBm9PD w+s3BE3Xo5GmaRa7A6m82CePr9vTZb49xPVbkIUH4dGHyzMutoJIKweb1VpF VvdM2V/wAiBoF9rBDTg8ff2HdmSL5eSw22xlMs+r471aM2KmplD9VSBwfv6C oC+t6PHhdgHg9vwIWIQq/DTf7qlA0uPf49/j3+P/U/DngVKj3c2Oj58xT8uL hoblpmwfvzqc4ZGP1GV9XR/O9XwdU4+a/CsYQvVRLT+EyfQUbsn+C1/ZfEFM trt/zNuZGQbatQfXP75+x/VOGKts0QLXvyrP9g8YGvhg5mOf7d4QjtGO4q/D NIfzjcpqfbo8vP4BYz19/uP+8fP2eIEp4TG1hYQ+Hfh/GgzsMMBQzXoLGBGU wTSL7bFZbmNpnSzRZXp4IP4ji7xcQApTAh+8UWALnR4pRYt/MIfO4IsTvn/+ gvmPbWfqeknN4rt2tTk/sdiErSjOjwCq6OZKspU6jmcMFaTUM0EQB3zgkbHS J6lbwU/s3gLji2l6/Hv8e/x7/N8T/+PlJe/mPI+q2GVA/Q7wGQD/kKkTFlwH 4RgztFx8+XEwnDqeSPDxjAvOBQjjryPTYV9jrKtg4ttwfTgpJZcmJRMicmLm sc/OyzcnioOMGRmJXLK4qSkAmJe30/HvN5+uR0M7YrMG4M8StsfPjF/yigJ6 0gaOLTKjENfD6Yfk0DqSmqeJgT9ws/yA9o0zbZ0JYDHnie1RCTZMbD+Oy4bV eUl8uDytjxfTDfBlKDxbUeconCDB7aYXGo7vhklc4foC64XTh72GpmW4QZAV cOVwteVsgZXiJQHfsEQxq0Ssr3ClXwMsktUd+ckFM01+kWHDULu1avOmw6sL KW11p/3aevx7/Hv8e/zfGX/+PpsBumpBcikGMbkEdjGWLpMh5bX9CEu4mxo3 oxH1q6tKebndajeYmlqqEOSl8l2BkuH5hKhsYjEWvkcAtT6dRXeobOkHK82P MznO1SWImCaOPbIteGptVYnwCt7TjRIrjEjNckw54vMM3weqNG7V2mE8dhia 4U/tejvfHk2PRRPkj0meHY+jYGBaBEkhJSF5nNdJ27rsv3No5uu7iQF/ij+R byAMBNyCNwq8hEwdn9+zu1CH3QLv3yzXg+kURreDCPgLmYoEXUyDfdxgrLKu ZitAbYluFV5aVFc8ov5qrSXnAFY6TUSmH+JPPf49/j3+Pf4/A392vaFwNMYv 87RtWXYdpfAL8KGAHRAZge9JFwZcbLGuwRNp09LLMwxoh9GHm9vr8RjX0y9T v85zpP2xG9OCmtkXMdWAmkV1PXFdUlKb1pMWzLjeZSNmyvpJcXenJFgzCtja oG2xWDjlD8Obm+nI0uR7RMUkPyWZCk+Zeq6K6SHgAtS34xHr+PKKXGLMUFI/ TIuIvbSoJBKoMT5+v51Oh4bJujzRa32jH+CD8VWHvGoz4U1lHY8NB4aBj5+K ZnjX2rFoEmaAKDQ8gJNQiKms8FwYCJvEY7EhSxcpP471Ruy2LAyBGA/V7pw9 /j3+Pf49/u+OfyxFcyUGl79SoRThCRuQ+aGTYEo5/Bq7w0iDA9WvVicrbCXq 9Wl04wSsa4O/k7YL+iePrCdKzL0VO0gXszSpG3Yok7yGTUG/IKFsaQPfVC6W +eytWz2l9kJv7NEjfxoNrifDoWVo/bUpcnli4lib7Eh/H1t4wtTKs8MQ0VBI whWjP8q9irZe2s5U8VvYX6nqo+J6bC32AEqZZHFF7pXag1lGIXFsCeVZcaiE efYkAc54u5AvCSkpBCJIrjJ9sdZrFIVQEfD0Bq4/Iv5MxCOuFBpAiRsxJgtP qqrHv8e/x7/H/+fgT15o/YaPjiYxiNTHVVpP3aw2dE9VoclrN4kkDvKwaiyZ Hq2o4Ke0lXy1WHWbHWaidCZJbZOUBagpXppnKl6qGAKBbrvbXZ7o+wrqL7H+ TnhcwGfgGJ8md/C8d+aE2rBxhCd26x1CJ2VY4XEi7h2KBAe7GFuRLzFUIZLd lZum892B+thvJ36Fvgw47Nrs4OPEoS9lHUrEhX9c7I/b+wcqxFKUlaranK0Q DESRm2eGumm5hZKwXW/mu73KA4riX6iqqlLcwViSlSl1q/q0WFSzXi/3J12s 9K3u8e/x7/Hv8f8J+GNk6YBGPlIkM5RGPKFWImjvg935cUG9CzY4UxczJUXW EkIsD81soZVqOZsZBqQwXZ4Nn5woJcrioQRf+jswQEsiOiz4zZQl1fvL0+Pn 704sytvSSWFoGyTWCtX21pzeGOOhYzKJL83dMP7905exYw9tExdjMuJJI9G7 xtxcamtHQcAwinn2zemMR1SzJaI/LJZmSmPNkst6Izh6oi18YDx0c3+5f/ps BkEo5dvs4yb6IaGg5OWJKIojPg1czp+84nvyhAsgYAW+1J6EOhkWjHPasTaV U93vw8Pz8eFF2j3kUVH2+Pf49/j3+P8c/Bmk1Ovj/eX168Pn7w+v3/ATC0TM MiVv1odPEVHry8e7wdRjsANPWi2W8+1hsTvCj+BnNV+qaQwpWzs+ktfEpIzv U3kvS8lrPV3Yx+Hx5fT0uj6e8VB4LtgCUz2/kJd7N52MbcuOA1E0OsKCGGQv n9lmBxCMwNX2CqrvbYesuZZGaRnGX3P859PjZ6ANh6h9H6QFZ47v9+enZiHN ptkcrcLk72UQ2BGmWZ/OMSsK6btxl06SvLIoIj51vT0/nl++kPf19R+PX/6x OV/wKjLxHUMOD5WijPm40qyBerCLZbfZrvYnIInFYj66t8kr8N3T48sDeVw2 XhtYylf3+Pf49/j3+P8M/CW+WOxPBxGd3p0eZ+tdXNR2FGvLA/zEOPhc3Q1+ vfpkBSGGYmf548Pp8fVBqLawQlxRWGPi8hAM38O/TGzXCujBMX/M8OXrPz9/ /z+f//ivp6//3N0/psyAx+qLtX8N/PvNeCTtO8mzhUd7eAE+n09PgPShmM01 +Y7r8UTMH+GeE/IlIakbrPH8TB4vxhH98EvWzpy3xkDsj3N8eM7qruyWFNMr S+CzOZ5FD/wJS2sWwIfBlL57nJ4/YyjT94eGic0GiOb7I+x1eSWp+Pjw2iw3 WleClwRsGBgL109db+w4rqRvsH9wGUB4/PwPQIQHFd0cI/P6KMT1whO2mMcR +ake/x7/Hv8e//fHX+MLPjeKroej3z5d/+t//Me//PUvnwZD0aOjhPXqcA+j 4E+/fPyIu9wkhVEGpvXh9u7365vfr/n9x7s71UHF+PBfQGDq+CriyhZvaZyU dZDmpufDL3+8u516Xt7N2L5N8Mf8w7wcWTYGcQUEJvHDaGiaU8cz/XCsPFsJ DOHH4bKTsrEDNl+zGdMxSeTGad7Mym5BxlTdSakgtUEO4srDrCTZrO48qcXG wrGXMMLIdEi1sj3yzdJk5Fl4GwE+2A/8BIEVI3L0GZ1RADa6nYx/u77CVhHc IgSVK6n7sMKIpd+eJ209JRsltFsyxGwHuIl+IMu6+YZzeridTPBc7fImeuM9 /j3+Pf49/u+NP1sYS/9NAPvh7u5vHz4CVbgGh90QCtzVLFfVbPkboBaqFXAw qXfh302Nf//ll//57//277/8/cPt7d0UARefrnrd8L9Tx9VBnFQadKY5Zvjx 9vbD7c3IMpNaSpvzdHm4Pz99rWcr9mWImLAAnhRlCgG7dTMeX93d0hDUx04Q v3TrLd4TtNXCW5vOty6iCfDHVqnnq6JbhJTaqHABXg8QcNlBzDpBYCLFbnIE V3hJBuOObAc/nSjGZpgGDsbvVjsysrLyTdybDLHACIT963nA/+PdDQ/QshT4 cz73j7AmljyxHeWbiQxUChM4QWJ4Ad9GwlB0CKPt+aFdbQdTc2J7E7hsdnnr 8e/x7/Hv8X93/F0XV2I+PHpKWDpxN51oKYGXpG86pcwmZwD/t+vrT8MhcJh6 DqB22a0gAj6/fPzwaTgYWRZmC/wBLCKdkWnhA4clWWn6HWlhn04d+LvpnTlB sBZIgjttWswnrVozCIemoWRaSay4WMjEc26EfDV2LHx/Y44x23K+hHHFWSfS 8rKU7HmedbNmtW2Xm6JbUldcEi6ins2SCrhCAI57o7oyQ1K/YAtGZFIqAo/J UvHQxZeYKpuvZUVUsPMC8J/49tAxx67FmhQYwnN1H058B/NJm87wfPnQn5KB JiKxmEAifDZKfAs1NxKymZ9mt+PJzXgyttnlk2SwHv8e/x7/Hv/3xZ/+Ioo0 BEvb7k1biW2Cc1lRKU3nGRNh8IFBSKeeCygwEzKvEPVkKWwB8DElsljFm4ve XcxS67TQzDjsS2EiUR/FyGZI7haNwuYIsZBXI3jbqetINj9WnmpcNyPXwpVD Ft8FbymeNFJHhuXDgiLiDT/LlDp+Sbs2ny+wlqRtVT1JlfQAMgK0IC9EJ7wW SaW3BhBpywqLiJstNEUJVkeLyhqIacp+7NlRzYKOsWfhn0KvijRfTwJARIiw f7AlKDxOcm8gut+F7LEqKvnBrKQVBWyMxZrczK7nxnGPf49/j3+P/7vjP4C/ MH0GO1jO5vTQbXbagkFrE4SUmwEZOFz8HhYlrpcqaXNgTsv5YrbZUVNU1FZN pR5F5M1OXMtm5/pMks4xJTUSjM/OyH5OrSchd+HGSOlPRuCqTB+clCbNTam/ 3p2fhrZhSuZdVLhtuZGJFdyLBWI5+WwmehoRrqc+dkHlDdV35cKrUqhfPvsy UBmvkp4IDMFaxFmbfShKqrZ0fNO7yOwVEwiDl3CR9xUHq+Pp8PA89pyRZwmF LINTnhB8WsfmfBItNmd7IN8TnvDREG1A1X2F830rZoxUQtwlRTno8e/x7/Hv 8f8J+LO7WRxI7UBCPaXTw9hxtVKARpHu9rYk1kXjNCSTNvCBP1xwOVvsz09y YlaILJIUZQTsoYlhgRVnJYdR2nzt8vptf35WrQz8CZGOJfV3WCkWDvzH4pHZ AKgqRR/p+fHzH7fT8cAyMPKdNYEvxmzpv9KYVpCfrOZg/UgGcLAElT+ClU1u oZhELGIbEYdQ+WNpIG8Cy/0JW4LksaIwKO5kKdSipB3r9DRynPguHn18fHn+ +s+b6fjWGAs32L41x/IWEU4kWpSXBE+qORB/Bdg8x4fXkW2RqSXMAT2X48tJ ymI9zJC+u8e/x7/Hv8f/Z+A/kQI0djdL0+PDy2p/zz6VjkP97aqesVPwBR/l kXbrbVLXWvUGczTLDXlWFvVIg4zFF8VsPt/uV4f75e4E71wtluTNSkEEohgq jj68fLy9w/g2G9AUqkR9EdKvSnwjYpIOO4h2QlKwXr8jSPn99gbzx1CsjDs/ rI73lDZ9+bLcH+F8eVxWsroB39w/felWu3KxRKwUlQVlUe8fdPKr47ldrWEX bAApoyswz/3lifp4BeX4/CITj//w8PpV9GM/r08XrAhTHfts/YAvP//x358G g79ffbCTEP63Wa2xIvKWP/9xevrCrsoVT/a4hNC/f+Z8bsajoWXAOvD7eMO5 f/4MHLCvcNfm/kL/HgU9/j3+Pf49/u+O/8NbqJIkYVGwY8LudD0c/X59A88F /LHezfGyYl+bz/ePr4vNwUszuJup58IjL/Yn3HI3MX77dG36PqKz+fawv38S ve7Pq8O5XW7ZJdNzEEPBqcF5wf9+ZKbeoPyR9F8AwufnbxgfrnO+2XN8zt9D UHPA0l6//frp6t/+9h9DcwpPKrzZy/b0AOgOl5f55hBX7AGqJ3swJR5dz9c5 dTYqfA8PiMViELjOw/kZ0RAWJYEkeWXz3RGA5M0sEnFUmB7h2P7CJjuc1ctX PEWVBuWFwcI4n//x3wPD+OXjB0AqdSIHeNjLy9fL63eAX7RzZmdCX7f0+eUb lnA9Gn68u0W4Cv9bLVbb+0cYBfNcH85xWSupgEedPf49/j3+Pf4/Af9UO0iy I8zmwDqLT59GluVJ3mFgGp8Gww+3t3+/uvqXv/71f/zL/74Zj+F8R47VLNdA YzC1fvlwdTUYSLlx7MTp1PXHtjMwzF8+Xv31t1+Htjm0p4hi4HQW2xOG+vXq yg5jrFdkiDK4byeM7SDCIFd3dxPX4aFc4O7Pj8fH17/+/ttff/37yKQuK7ww sxhlq7eMLHtomHLIVuAWOFOgUbTsdw+7iD52yZq7qhVFqQiPSCmmXf3gFZ9n mwNAAw56VOhmSYAXEuk0jUH8JB2/8dMi4I/JwJqm55MSNri7MUaIv65Gt5j2 x7u7f//17//7r3/562+/TRyXOlG+A/ARQhpucDMaXQ0HI9sYUTPEA56wyIeb m799/ACoseV6/Hv8e/x7/H8O/kka1fAyEcKrvJ0DnH/729+AkhMx806pDcv+ +9XHv/z667/97Ze/ffj903A4dmw9f4OHVf/72/W14ftyvpQafvBpOMI3f/n1 73/57e9308mdNcWH4UZe/K+//Ntff/v7xHaAJFwhq/B83wlT2GswNeCalcKE KA/hUr1Y/3b96Wo4BNSu6LWKbF3rxonlh0AJWMHvw9UisFqfWFLnRklc1FFe FbNF0rG7Mc1R1IizpOvBXElQbppof2Q46yAr0rrNug4uXhkCThTFeY27AIK+ Kkj/6CPeK66Hw3/9219++fj7rTHGom6tMdAAJnhP+PXqE6JLUhF8D/sT0et8 vZ/Y3sC0uK8cW+uvB8b41pjcTadD08S6evx7/Hv8e/zfH/8R8be0uaSqVdhh CPz//ZdfbsYTEZRIhDoVAFt4QDia2+kE5pg4FNaj4lBa3Iwmt6MJvDBcKqVZ o0g1mgam+Xf4l+urj8PbkQMXjICluJmM/se//i/ELwNjaklyB6GWqnCQXhWy JYETM4UNF0+001QeOp3CqUlpnmZeWEBB2lgaZGQ3hdLgvlgsACZMyfo7Ec3W 1paAFLao5susmQH/arFOuzasCtzSrDbVjEXZMHQxX0TUTc01rZ/ULeziSMvp fMacDgyE8O0/fv/1108f4X+vRneq4DcNHKZgHAc7By8GVsDlwwS+7EbsZOEt DzB/TEbUmSIR+s6wVZwkcXv8e/x7/Hv8fxL+jrCtVPhu7NlD0wDIUjoRsi5M WK8sxIjIeoIhyJL1PS1DYOEeG64FiG68JEMwNXGpyCoMKzhWD+EGPDW+HDrm wDYG1hTIj21b6j5iydR7kr5PpSEC2yWILB4XjvmoxDcuxrqwQNEDzIRJVWoW nkFcXWkrNO2/EBUlWzwjCmvfeLbUYq2rSE7k0rbNuxmls9sGGw+3lIslLNIs NuV8gdGEPJyqFbABHGFhqcs2pcsbAtLr0XBgTpUVMHQMPJppI2bYY5V4BT4s ReQ+TBDBIV6TOkdym3ELJoB3BiqfNE0goh+WFIP0+Pf49/j3+L8r/kUhunMB 1e089jhTwK2QGflAOi+kdYM4xZOFw4moqjZGhqulJjaZWqmf5n7Ovjl4brNc F91CebkO8xEBnO+tOSb41lRsHUp5QsL2Db673J3muwPpvjwWS7WfAszH0gbW dMAv+7S+rA4/AdT2/oHeH0DlwBDIFyq4p+wpETVlXgYgA5zN6dJQkS8Vam7B MgopzRb/zhKSuG7K+VLrOABFMZu36y0mZpCfRmIwsJ2QAGybotRqi5C45Imo EL7cn3aXJ9VcxTTMyJ94jvLWdJlSi03alU8R8nB7fuw2O+UDi4/u8e/x7/Hv 8f85+LMEQFoYqCFYfcAGYYm4UTY7zrv56fELw6uMIquw0cg2hYLlSaG0J01w UtXxgFFWu1O32iIMwe0Y/MYYXU9H8Fa4hZLdjjUWbW2yTzFIGBwuz9vjhSdd 4u5J3GVxH9mqLMoIWdONcQA+9TrSBMa6vHzzE905vjZx8ET4TgSRfCsOAjlJ wweh2fnl6+nxM5v+sBA7134QJNYSQ1+6NkRaKBdK6zeAszqe8SC8MIj0t0Hq r85ZNLdZ0JfKbMkfDo+iB4XgkfrbYcArRXNbkI+lICXQ1wB65yzDxTAZrtfk vuAf9Pj3+Pf49/i/J/6h4B+VFdwrQMD3h4cXPHq+3WuBs8fDrrhdbR9ev00d b2wxAsKEq8VqtT9hkDVT2HsYSKItNsfEXas99foQkcFePEZLU1yz2B5nG0p2 YzQ4UHwJ8Ee2AfzhH5e7I8WXQsZcWEW33u3PT/isj2dKpB7PotdKnRAsBKPd P31xo8TweEbnF1m32e5l/ufnL/fPX8ibkspxQARH/Pj5j/unz+1yVy2WiDdh gnq5whqbFWW6tXzPFx1UT6ozVsd7QIo4zmRRho1vMP72/nJ6+ozB8ROzytpW YkPGXHju5eW76fH8UGVGNqeH09MrLj4/fzs8vGLD4KEOOzIQ7YeX75vD+Xo0 1ut7/Hv8e/x7/H8W/vgTMDk8PAMHxDWH8/Pm+JA1M62207725+evGP/j3d3U oSwGIqzV4bzm5zLfHPKGvFMelDk2XM98e4D/daPM9mND+KXlbK7FyDDZbL2v 5iuAjOgGfhzj7y9Pm+PF9MOhacJbwfSYz5Ki39Txw+/VbBlkmH9ks4NPMtvu H16/F+2cpKyIGhfdeov1YpOQJ0wW7ivmHNc1YqsU+H/5A/NvFky1xFVdzOdH XvaFm+1wj1XPt+TlStAHiCJt/RCXNVttBh7G2Z0fL6/fXr795+c//vvp6z+3 949p04lCIBtAnB5fL6LXejedar4G88G2wVsCZrI9Xer5OshodwqG5PnTl3/s zk9Xg+HVgPobPf49/j3+Pf4/BX84TYAwDRyWGNgOFa3dYGjZY5WSjiOEQuV8 iXGmjn91N8CS9fTMDMLr4eh6PMZzJ7Y7NG07COXgLlhsD0B4ZNrAc+KwWO9m OhoCaj+cysXw4xOXFXbaxA2LhTXxRCb9o1hXPbTMu6kxNKyJ4+KWu8nUZoBG iizwh5+N8nJgGGPH0VZubCSaF3giVsHmyHWHaccN9TcePv9xef5WzVZv6tw1 szCYYVq1mnwP04LRUFmopsfx8QX70EsyP6UUidRlk2wwdT0vTk0/wHMtP2ZL TanyZr3J0yv2Jz4U3xPtKS/Ngjj3k8wKosHUGpkOTOBK/fX98+fZaofN/Nv1 9fVoiHh26vf49/j3+Pf4vz/+I2prhD5bKgPwgKUHt5PJwDQmrqs6cmndwHt+ GgxvRmP8aeqxLSasMLbt2+lUk++DqWkgAInjqecivIqKCoNfDe4wGkKqO2s6 onoq2yjcjMdYCHlWUTx2rBtjvDzcN/MNxkGIZwfMvDA0c4yJB0tZMBn2g+iB Y8mNX+RwqdvTg5/kGGRkAZwozPOwzOHo8U84QQySVg2wzWdzv8zhT3enx6Rs 4qLJJTUv2noVzBTldZhRmhXRHxCj9lQaL3aHxf44cR075GaQpg+BlQTiK62J 7WBRos6dw45Omqzx3nJ8cKIE+FNqNU3lSDAKsjJIyzfx1SgNkiKqay9P55t9 XNTA59dPnwCRHEL6btzj3+Pf49/j/97429KAXiQ4pNEwVbVjqhUFIWYYVpUn uZXfb24+DYfXo/HINAfmhJoSnkOBozR3woTFF/gljg2SpqKRY/96dQXnAsxV TBtezAgo0GpJFxsrYJaf+E+GHiccT2wPDndk2TbtwhQMvpc/JVi4jM86iAjz ydK8nRXNwktSyw/dOAmrkqkZyfXbIXZMnomrTVuys/LZDLBHeaVVGMVsQVdL cdQybzoEj9qax00y4pMhvGwQjsG4bkxeAYa1E/LTfNmN8LCsHMnyIC/Iyy3y uKrg68O0tLwIUGDClBln4t4LijKtO5geXj4RoQ/SAPLC8APg+dv1p0+sW4x6 /Hv8e/x7/N8f/+vhANhGVGGi2qrWoCVNG1O5usR8tCulaCIFwAd+cGSZAH9o G0zZS49O6UQQ2G+/+PBcQEzaNHiYDEm2nofrtSW9iqwavmd4jo5za4zgnTEs nBGP4GhEMq8Y/sD0zLlkLLh72yGFVOFlcKNJ1cCgjhzZeWTtshEDppR3s2K2 zLoZgzJK+UUkWVUNcAD+uDEWXq4SurK2Sxt82ljqODh+SkEkQZ5SrhQhZ6tQ PygyRH/4BShlbcvBBTd2cysy1hLGKftWpHTuwklgL2aXBSA1MJeREb55WoIB rLiTjSkm3OPf49/j3+P/U/Cn/g+PnuJsNpttD0pzElGjMmZdc87QTAhFeNDI QlxG3G7NsSjsrQVwGzDCmeJ3ZmFceE8bALJBg1CS1AvXizWWScquHNPhluvJ cGBN8Yt8TI1u1Kxw7tV8Cb/mkbMasM+miBqJlGusVYFhUfg5zJGxmCKNizn1 YLWwLhC3GEm2XVlbWH6ImKusgIbWX1eLZb1cB2WhytiEl+rfqaiFh6rUmrSt NvExQ6/b7BCX0XEXlHsC+Gru/9veey3JkSRLot93RVbkPtyzu6en+6ABFEkW nHOenBUF6Z7pufunq2pW6N0vKLy4SAokKzMywl3dBRYWpqaqTx09qaSznwL3 DAWxWh8viPWybYq/6biSWpLKRRKXWEgoNcvgb/A3+Bv83x9/9qyJDc10PD19 /bMe11nX0y6TutlJIH0WGjIEt0SDIxK07YkULCugHc+9s5o5Fk5uiacDXjOs SOA6SYyvaJpTltPhvD5c/DRThzUAPnMpzYGz4f09fh6w6MM6Oy17Uq3X+1mh xf0fVsuxLoG6KojYXaIqpsDn9Y9/Y8mKYZRmh1wkOwpyn7KMNab0jQdLwlVd HR6eN6cHUeSTybKo9ObmzAduvFCSCYlXFLmB5xk/wfHcnHWtpF/l8a5Cj/YQ gSu950wDcenr6/ft8erECXm5Kf0pMFP1lWO3o7R1SOzGDjH4G/wN/gb/d8Wf sNDIhhJDxP9wfvjyPa3oVinOa2nRdwhS0/GMqdGtZn+UeBrJ+fPjw8v2dL1d LOm8HNOhHuGm3x3zrhdrmxPyIAAlbWvUl9idH3enxyAp+KROYijmUvZjNa6R BOFg9oOIfAct2LIc67s7Pay8gCZlMTu+yfu9PGGTXJ6/Xl6+7a9PCOhq34YA h+D4+sdf4+7UTjtsIQRHDO/4+ELxVZb4H/rdgbgxiCOJqnAGTCGpGsyXD/ry rNlsaLLDk389Pb32233SVJJjUlKD+k5Pr04YpzXb9wDacDgeHl9Oj6/4fHd+ wPDwoQ2QQ5auXv749/b4gKRVewkBGkK5ij4BUvwWNzBsbDf4G/wN/gb/98ef lQg6F7tZFFUF4u/++hykBaYcMW2hbNG0PyOPwMirYRp2RwocATqx1JS+iYeb xUJIRD5AKPoRSROGgV/hKxwfVzVyGXGfyQDX/vKE9Q3zkloZdQ3wqX2xO+JI hOZ63CR1K23d9Gtj1wb7MjAjpnWI2rg68Hx4/Y4XebbP33GhtOm0ZRvB+suf /27XO1yi6PpyHHHF5+//ehIfBKC6OV6Smn4TuD0IxG/o/PQ1q7u8HTBfgMNO ahF9fWLrxJ/Hh1eEcsRiP6dbxOGJl7aCCBCpiAcQePn+15c//v8vf/6vl29/ 7c5PWE3tKwxznP+fGN69RSIZTe7yrKI99AGTWp8Iab/hfpBmwNjgb/A3+Bv8 3xX/7YFVA0rw5YiPDULtAcfbd0sLWUPea4mhIz0pK5KyicsmLVtEH+VlsYVt e/g8n98ul4AI2RMyi4XnSuV9uXA9O4jwL4lMWarPoxCCSUNNC0CUNi0bq0Wz Tpov3IXr+wkflCnFl/EXxxcNW/nyypHWbIo15VVW9xhP3lBYNSlrMVlOEPQR f/G5EyZxQU2kuKkLkV3Nm95PMlzCjRIuARLANDkzaD7mdZ9TZzVXn4WF62A8 Qs1qOeWKz+6k+J7vro9YL5wZVyw7Oimz4lO3C8cjqdjzP97ff5rNKd8tJnRY QezwT/dU56bPdU5Lu6iogjSPSO6tcAlW+XOKyhr8Df4Gf4P/++NvBQFVg5Io 7zsE3F8+fKC49MpCViL6dTnGgPFkVYtxYu4x59toNMHsEHwlvqRaebejYO6y CWJuYyIB+y8kNHuia4T1whnsIAZEGHlA9SEK6yEii2tDQJ5q2YTy0G/YHjbH K0DGwfgcGZMwvtIgL8K0wBUBRdYMbMGrm6gmeeD89AUH+zEmWJHyRIuHlv9i z2T4Vcm1ayjKhPVFhoiID/SWbmD5IYtEaWwn9JJjUlZUZTvG0idIzaUsQdKE AF12E17YkIjXibR+eGmGi94uVzeLOaBY+r4v5aHt+ZpWHfVjV6tVEEY/ZAZJ 0MoKJJh4YV0s3+Bv8Df4G/x/Dv6a2rhJFFeln+eIIL9++n1m2VlDqzKZL8vo iGIayPB51vVitUBFJgwe0QcB1GX8CleB66SRPEBjJwXJt2Go5F6sMhI0bfGz w5gdaqxipPJtiSUAnniFOf3rw6pkTtR2+ARxHHEf+4E8Xt/DUFXImktQ1nhh GGSLtQ0wR4RlEC/qeqDVAmWuS7rL5R3uJVqAjzGon4LIQ8VU0p7NcAlcC/tB qjm1VPZJ8cpYr2/V3/lNx3vcAn+5D6mlspP4BZWXqDTr+QAfdyCIqiFZta0V RnfL1dx22bvHyj52aWjFgVKOha4cGfwN/gZ/g//Pwj9rW+oaUU2CgQYDxklE na+LmdewlCyy0lXe9bl0QKimKKIMq9slEQOAnpCs5r7DbEUCE4YHZEQ0Gz8v 2SiHMZcVTo6RROQdtVKwTjmLlE46cd2EZUXCbS7GzUmsXWx500kVI1J3NqC9 ojISJbsxqkT4SyGZunne0nwHmwRYsRBflTgtCQY1i+yYVCmFHkwHtwQulV0z 6oH7HgVdhS2WylKqFw9ZXhx8JXMpsBBYFNX31nYVbDYtYGmFSIBld4kvUtus 9SQp1kW6OTKVnGKPNtCW4xMSgw3+Bn+Dv8H/J+DPJ0hdq8qlwhEKEuGjJk2L CCgi1UW72SJVEVuEKmKjAXWk2ZQhJFJMOe26rO9FsjVdhl6/2+8fnt2UmhIq iC3So6TR4k+SUcVAIWYJhvG9F16uBERqqMYihSqNz6kW+rFkbvLWJIgQ3Ezr 09Mr0qWgePM7wEKodB62BJm3HRZF/HeGHn8Oe6o5cUuIIl9Cv85WLR645eSx GBaXqyN9eevjZX08q763uDykEnxxA0A5DpycxZd+EDZvg7uX6XBCaoatQsFw 8Yzw0zeqLelheUq6WsSmdWzOVei1G9ID5h7tGzBsWWuDv8Hf4G/w/wn442Un oZbIhcuUqp29tJ4xDVER1CBD8GpxDNKHtxK8sJIoLl0ViIBkrqaR8qCADyIy jy/Uji0VqiqfbtnitkYcGin9pwnmO+xOLMrLSZiYpInybKVNL0DMXYUB0plA Fr3b7h9ev8vjskTuHNjvEIppjtKGgSFQkleL2W1Ol8vT12ba8M5BYp8cXAvC pa/2Z8mbuRv+PT9/OT9/pRyHKHUjqZQOvooFHbkPwVKyab2iVQTmcnx6OT68 0CEo9LD9qKcUE0/lXGHwC99dBi51rmLcUURYrGpav8meGPwN/gZ/g/9Pwj+k e06OtAJBCkFnd3nEq9lsFXmNDofH5+vr9zAr07rVNGfck3eKnyAdw/HUta5L XT58C/yPjy9RVqUN4jKTOBwAELaXB7Y8nC/4M/q/fHZwqml/DtIia3pNYRDd 6nENnGVpDsikxNAt0caNYXd8+vqnHUR31gqRl/qx+yNAw0j2D0+PX//E1UVS u0iYN5VC2fqDSVM/4nPkmwjHL9//hUmdHl+PMhHNpOgEmqY41fXle5DJI8Ga zXE4Hiv++udfL3/89fz9r8vzVwCopALgT77u87eVF4hbUBKXJRA+Pb5g3+4u T/htv92z1S6KNDpvidhOFP8aUXwy+Bv8Df4G/5+CP1Kesl5v2Bx3ugIfzKJD giBFaoWIutzSpxDlVd7y82a9xWH4CY7E+fGnSpUyoSjz4+Pr07c/636SonlZ DAOuCMQw35fvfwmv9QXJUSSqGgAWwX19OOPkSdkkNc0uN6fruD8pX2t/edwc rxSy4PMrz46i3ZktEgvXu1tZTswubEwHF8WQNqeHLd1/TkVHPQ0NtRi/UqG6 aY9VwBL0+8Px+rK/PIkfxKHsRrZgsMk6whQOD0+H6zOVA30WzXH+epz212dc 9PT4BUMatoes6cQDGglmLnzgP4I0X/mBn/GRJnYOMtb14TLtT/W0LqjUikwz Qcy1k2hD8u3Ry5hXakpo8Df4G/wN/j8HfzbfsVCCCIuXF2cUQU1yLAF1iop8 f31EKHnDR8ap9Rc3SsKssoJoZttzx/HTVK3NMF9AnTekyAo5qsILa9RM236z r/qpFE4s0x+xPEMQRPzNmwFXj0vJ++oasT4uaidMnCBZeeHNfOHGjHeYAqI/ gua9ZZPs5PnUwa6JktJ93SglybZsapHa1r6589NXoDFuj7z6OFKvr2pIry3q qKgsQg3o+KgQ+AMfLDE+4dliqmc4SYCJWD4Oi2aW89unT7eL5ZvfXIb5sgUP mw0/cWmpQ4u629XyPz98+B+//frL7x9uFgvy3ESRDynYVjr1sFgYJ24nDP4G f4O/wf8n4U/5CKQ2QZlnbYdPMIs4rziwvCqGPqL72AmQEvyyQVaC+ar6hB2F AamnsbSkkU3KbKuuphOPBw5eTKlVFazAqYB/M2ySoinaMas7eeDGUj7iJoJj 2U34Cdad6qaijx0XjU4Zn89tBwPGlOeejaQP2Zk2O3yazai/KoypIC/oyJaV dhj7SVb3azZEV1W/OyDUdusdCz0dpfZ4fNvgjZovYP+sfF8IUazINGt2Hc4d 9261mjs2pT/4yJEifl6SA39c9H5lY5cmNTZYMu7p7INNYlMq3EWeRafR0L1Z zn77/OnD7c3H2T2pufZq7jtW6CO9RSaIQWLTLlxHhJgM/gZ/g7/B//3xp/Cp nYRSi5EqRllpiMTJaVgstRjajaUFpoZoVQ6T6h054s4W5kXeDgyXkmoBZ6Dd rjcYHsbjpzmuhc/jmhIfgA7LgeQFx7PH7c2AmHY5RTOqVUFKQQySo3BjwAwl yxF56cLj+3YYUpe7zHHR//Hrrx/vZyrxra7KWlXJ2j4ua9w8VMNUTetMSvCU Cpy2mBdeoi5Vaddh3vX404lCj27RhVhOs46TVLXg42JpsM0QUleR77/xx2ps Erotl5XqliQN716wSe6WlvrpAP+Za+F1j5e9ulnOb63F0mcJhufJlZmczGwL Xy08R92oDf4Gf4O/wf898b9dLuj/GPnICwR/1lwAYDVNlOAmtanQ6nNaN5h1 XDXIXzL6FEj1JGcZGtOkHimdDtbFOKRtnXVNM220XyPve+AvhRsEykr5Udou IfhT3DVpWkRGaaZusJo4QNlc+nhKnS5Zx09FHE+US++Wy7njRaT+EvZAmQBk ZNW4DeBL6u+ZaLHiQvW0wZ0DAq6KcovMOG4MqDQoMoPkXyWM+7XW8bkHknQV BFbg/w1Cvd4gcGPVlMGLwWgBCz/HdrWCYOaIPrln3TsrRY9qtL7LzhFq9HmE OvJZnWejoo3D1H/T4G/wN/gb/H8K/iIN6tfr9bA/4mwJpaobFa9miTlPhBlb Zrh036spA8aM4yfyVEttT8OH5TS+edmXOZap2WyqcaL9zbRmENxscX7qUZfl G1eqIimXwt1JlOoStAyOCU0Tsna9A4b0dEgi6dFg10Ygi+4LTYvIV3VIRxvZ NgymHBsH84bhjwuVpbTg9ar1JzSqEnllu929SdFK5UV1/HRUbkrNQD6ZlAWy orDb7i6v39iW2NRqS6HirvLbADlsJB12q8C/c5hqbc8P1TjizSJwEXbxZiZK 4/w3kHueOBR2lsHf4G/wN/i/N/54sSNMOqbx8/FwPDw84wziCIPrFq74HXh5 qr4zHmNQqUENIGwv14cv3yWjaYUcFWvrBBGoSzE4q6VhbSzHIWnrgXWT13pc i91MLuTVVKSQUm0Dd5KYkxXxJSC8OT/gYIqvcoIkL9nsaIgdocvaPCbDSRQ6 /IvlbtdbqfjUmo4JS5YmPpEAFUoDXU5roRpD3V2fMKR7a6Xk25D8Wy4ltQGl IQWwKAkNERNA7S6PL9//irJSOvVK7Uxk8C3JwnXJGZYtHXo31hyAX16+8jnh 7A6A3zqLO2epPRc2BpywHIPbnlXkGfwN/gZ/g//7428L/jOPDjheFg+7w+H6 5Kd5VLIpGKNdny4XMZd//vbP8/OX6XDSHgQsDXlTz69XxKO6R96EGI0P+/1+ d308Pr2enr5I9JnUv4D5mvZxPH9dH87k05LZWxT90KwZlHFmQCdlnVSNfjB9 XL2ZtgvH87RInWfNetNv93gN+xP+xfkDAUdNDZrNrtvs7i07yAvkgEBSIv5B VVV3D0/DgdrgoTw0w7fbywPuH+4tiw6YbZu3HWXGd0dMAePfPz5PhzOSNTdj gNY+kdc//p0JMSCT/Kvb7NfH88Prd4ADtHFC3Dlg1dhqEfnX1+8Yz3//9ZfP yxmSL1xic7pgh1PPdn9A6MeGCcrs3jX4G/wN/gb/n4F/kc09BxEB8QLzVZ5t 0QwiUtTi5I9f/nj6+ufz13/iKliddrPTfu1Q9EhPz18YT8sGiOF4jP/88uVB fnJ9+YaALr3GLMpTH/vycHp8GQHd5pC1HcIcOywOJDthVIfrc7/ZJzUdzdw4 wkIAt2l/mtnu3HGxBFgy/Pb4yGa3/cPz5njF6khfM7vekN0A6n63FzEodm0D CvyJxT08PCHu4/iR+uHMBCmdUZVc3/VmwYp5rM8DkTOSprU/4XNg2067tO7S thOTHeoHnh5f06r14pTqqZKNapMIfjVsD2nV0Q80S/V+4ERe8eUfHz/+fneD FYnJBNhjGJQxn9ZidVotPAcjN/gb/A3+Bv/3x3/pu3f20o4DhOCt9M0huNCk XsirjKolZfEQYaUoP9XDhHyK7jNVubs+4PiiG5thDTwl7aqaaYMj8XP1wSna AZ9Qr68qmX89vAJ8fE52rlgwZE0XpEWQFXHR4N8g4SM10WtNgD8mhfg7tz0r YATEvJZ+8OH27uP9/X/8+sv/98t//sd//ufctZeBd++sFDQ7iCwv8pIMGVZU iwBUQpJYlJcUza5aqjxRaTDVcIz4awXsPWfLuTANwqJkxd8LyfhKC8xddAgT Nm7sDjj/59ncop5qpVIbSy+4Xa4+zxcY2O1iYYveILKz4+PzsD3eLpcz257Z 1jJwV4F7u1rgz9vV8vPi/sPdZ7zu7ZXB3+Bv8Df4/wz8b27txcyzkYUhIoyH M/IvDBhZhhpTUuOoEjpTv8ZIym4oyWuakG1h/PvrC8Xu6p663KJNUQwkPlGm VfIUvBDyMM24qeppAp4AoRm3OBWQlwbkCle0gxgzRVyz/EjdeRDvEK3qfr10 gvuVvXBc7e9b+d7n2ewfH3//9ePHXz58+I9//OO3z59WgXdnLxANcc6bxXJm OTgb9gmyyFRaLdwoZf941YZp4aeZPP3LxuPJS9IPt5/vrRVglMoRZQOxkbBt sIKWHyScnahRCS8LEf92YQFkQJR3A1I55Fn4ydLzMUhAPbeduetKeSgBmGnd EnnPI4+Xjw2jmWsx5lqrT/P7m8Xs0+Ie+M8N/gZ/g7/B/2fgT6Pk0L2x5upo b9EQJ2CrNesU1JdWAT0Ro+7ylvrV+ThENeWSmvU2KVvMiwFUXOm1ql4Qil51 UPGGlfGeLmlpQxMHrBf5tzUP9qXFm5X0kv3dwE15uayJ0Nogv10gtM0Q1Ohc U+RW6IuuUeJGye1qdbtYAo2F6yx8lzWRJP5we/v73R3WsRCWlEoqYS7YOcrv oj9yylo5cF44zofbG6ARl+RohVUhD/rYSCiCtEksFjy4CXmjYFWVHSYrP6Rr m5T7xQmaBtCYaZhXWDWkhCwMiWitG7PJYunz/gHvcXLcKpC3HIe47bmzlki+ 5p6zMPgb/A3+Bv93x5//Oqu5Z925rA7jzSr0fYpj14mUGMR6rIhEYa8Yx5zJ V5c2tV+w9AzA2/W2GTclFoV+bX3yFoUH/EmDnh5v8JNe9avjhvRaNVlgx3dB EwfvjWdLcWwuIoNdSSNmUVtCtrJ0adCTtTR9QPySMj3WopCFK8mYKksxevCF ppvObGfpelQL73uEQqUEIGekIms/qNisWgKtQg8BHVuOuhmiRoV4yvjbD+Rl hYErMoC0kyjyICMzAfuQu6gdsqZlXUnkZCOJzqL72seiy6EpJIX4IhrM2bxE KmyBEFsCA1hFPnJG3PYY/A3+Bn+D/8/C/xYh2HcA/sJ3lvTQ9NlTRv1VNjVj GO1mixdFTXsWTXScVOGuGZUwr3q9KcmzXeMNhoHsbHt+QDhD+EYGlCnfSSS1 iRgJTi3yGmmayDHCelrnbcclqNWMuBA7g4jiq1GgXsl+jryJpXmMEMuKuI/z hHmuin9KslW/BuHf0i6h4Fbhkk2HczkMkayC6H7XWg+iJh67ORKRaSp1Xrju 9kx/ZEx8Ie3SuAPR52m+WgVVRcaOEmxF9onQlKHru+1OGF+5Mn7xEyeNRI5b 7xZin8xhpZwlyFsBl7TpeTPXNvgb/A3+Bv+fhf+9u7pZzRHXVpLaOPKStmLS UN0sxmAO15e0UdsCqlLzhOy8K7X7LG5rJVkhgOLPYXe4vHxVhGPpU3hTt+Yr Zxtdkf8t/aq+zM20QQb3Q9Eu08hri5E9EODAEMVC8qxwAMDfnK50TKhqGtzQ RodREqENh6ksKuO4dN5hKQ8P1NnD+P8+v3Blibx6LltRqGxhX6rn1APZH/HG irn6WFaWTiS4S1BmI3ZUFtpFiDfD/oAp+CnvRnw6RPjEMHkbMHm2EYtH4h/E tVBy2irwsZew8w3+Bn+Dv8H/Z+FvxWHZD0ijEKeov319mo5nxFkxUGPrGQ6+ vHwru6mZtmlH/T1ETBxzfCQPan2+il53pbNT/5rz05e4rIOM/miYIP5tN7vx cD5cnqfjBdGKB0sEFJbvddge6bxcaeNDptQmBE0cCbSlHftt8EivEOWH3RFJ mRPF0geRUJFpWve7A0Y17o/yGLBgdOZDtub48LI+XpNSVESKPGtbnLZd7/R4 vC+HEaEzEv1VYL6/Po0H+kEkdUOZqTjEagIfHKaebrhcLD2GmmrhYLxmloMk Tjcnjm/WG4wEW3d9PCNAO+zyY88FVpDn35+WHvK+gEscBQZ/g7/B3+D/E/CP fMREREyAsz0/Hq7P+BffFt2IeKGhDcHr9PTajptuvSvYvFySp3q6Hq5P+BdT AHpFR7GON17T7ogpZ3XnRmlS1BrKEWFx2LTHwYeiG6i8XUgszjPggNVxwsSL M7pziq0nJlsNzLMwkpWPKBxKoEQgSzX/soJI6uPYJyyvDKLXzT6I568cfz9K 6xzVxc/PX3fnx6qfxt0RyGDwQACbCpM9PHC++KH0ZRTSEwf8gQDibx4Xb+ah WFwcz/uE9Rabrdvuy37UWwgcgEtjU2E8th9p+7ZKiO+vz7ju7vJUjxuX5LE3 ChkR2x0XrndvWU5ECx6Dv8Hf4G/wf2/86V8QSfKSYCKImGnZBGnJFgagkUgf nPRB0DGhG6t+LSEsW0U+QipmlKtiUtOX7YBohcCHAFcNmOAz4inVs8OUEhki bYcMRSW+LT+0vBABTp9oTYcTRni3shBShRyF/Ihx9na5ulksfvnw4f/5f//b //ztN4fySlwyOiBPW4ciq5QEJA5NhYGlVRsVFZlddZdWHUDQh357uaPAkRh/ zhIPbhV4/LQ9ttNG+GBr1eXDOHF+0YPd+9T9i9OmQ+Lmyi0EKy91S0bxuMWv 8rbPhx7zxX3L5nhduP7cdp04UQEQFYNdesHMdvD57WJph6GbIqP0MBgcj8+B P6KwSksZ/A3+Bn+D/3vifyf4+3Q6TkRKooiKGkETP7SDyEtScecs1EoGlwbO 1FkFnkWOKVDOrh1k/Bu8MAUpneeYI0KSl+QBya45+ymkpY5aRkUVZZUX8yu8 p351niGcZVX3eT7HFPSinlit2XF0t1p9uLn9n7/9+vH+HiE4pF1mirwsqdu5 7dhhHKYsf2grB404U5yZFhKYRVpT6xV4tpTdHnB+ie81Insk1RakYHJLcALa 9bCuhjU+xNJX0xpfYV9hsrjlQLalWk9s3ChrgIBZkw9QM+lLWrrLjbsTdsvt cgnc5OQiAJIVC9dV/H+/u5s7DkkCkY+Tl/2ETbjy/FUQBgZ/g7/B3+D/7vgv Pd8KQilhpJQ/kq7nqCgReZ0o8ZNM9O5yUSXtorxWtxopOpd2EmlLWjWu9YSI oZyaPJgik6qopTWDlN1QnkpJYlXiVOKzxrimdXkqrObF0vVwUaQ8wo/K3thK cehEsYX9EIbYFUq4wgFukpB5+zbft0d/fpYgfcMZ3DgFPhGzJ7ZCSyGpAT5I eTAYDFjMGjJmhetNv95jFZppC/wLWRoqDTZdO27ZK43Ukn0cnRZuYtl17C6p urKbkIWRk9A2uNbdcjV32MqtpDLSCQoKQGFLIE+cWdbMZrbrqmRrVrgRbk5i J+adhsHf4G/wN/i/P/5unODDIKOvPSlGLHMEIU2QSxWs88mD5QMxOm8WjfQd DNofISKlCfWo+wHJTtay2Q1xUKFDFC7Vaq2j1ZpGGZWzY12eyVorLsyZuhLz yVVR8br8ttbJysGV/AqTylWLW6IhayuIaPeWhTNH8uhMayvLwKXMXcTFwsk9 KYjTQMH3760VgK3ZD95p6R9LWY6TjjCnc8Sgj9RYYxrXiMvdet+st/kwhHI8 FhTDxk9K9qGLRHnb0KAtxg6JmG+K9IfwgSP1ho6FpWCHwcJ37ChQ2hVySdox B/jTx2+DLDX4G/wN/gb/d8c/8MXjAP8iW2nWawwV4YAZmSRf2kqgNs0pEe4K KT2o9HQqNN1YXyS1pt5b60EqZfQWg2R+JD5rSMTa9VYCNIsUEZssSH8ib1YE izT2SSNDi+siu2lI6K2V6KtS2OKzgJ/4fpG5aTp36Y8GcAB7vV7vL09scA6o KO6ksfbBIQTPfXuJWcdU+c77UfW9tV1CaFr00FHirjwqxIKy/bAaeFMhxg09 m/i6TsZTYaUy6pC36jcXcCR8NihhnaCF4sgwHU84g3ISsAcWIsRti5Qr38TI vFLcSPCex+Bv8Df4G/x/Bv7sPmAzRTXsjpvTBauAYQtTKNEmCLaesfDBWoy2 1yUSHzH+brtvxk0xUIlC6bVaTXZZWOdjNNq3dW0idZl+twc+9bCOm0Z7H2wJ +m/n58Ll0vgs4y9ykqM2OysIVf7I52nJs5V+N1wux9i0RWIpEnz9dnd4eF56 nrRUFOTKIt5FviPqgjjMkwZzinKIumw1TZ08msOfyJWCHxHWo7A2Cz3iKDEx /5LxN9MG50f6lokILYfBX2XSQshWO4yK/hTSt4htsxd9b9mKTAMxgHu2OlKC exVpOA71XsLgb/A3+Bv83x3/QMOrTnDYH6bD2U8KN5GO4zzDtSiXujvgVLvL I8JQRBmKTPKmAtGn3ez7zQF5ij40K4ehXjNg4brr46UcRk+cnbULY3ehDmrZ jmnTSTiu9LCH1z9Oj686WrFmYCVI1VYx5dvF0k8ziddEDMN4+vbP52//ur58 AxqYL+flWnPfaTfb/fXZS1I3TpXZJfrbGP8ep8JSqvNOKApLeFOOIwacVS1S S+3Ii2kPx+oJ4qw+S5ROwyqVPgvFv53I3QXI2GCkWg09zsN+867TZ496C4El w2Sxpb1Y0ivutzjnHc4GeJLHtd7wsaRUvgz+Bn+Dv8H//fEHPhTTlidIiKf4 Kkiog6cVZ3a6Ha8b6rK+nh9fm2kbl2xhDkX7Auck8XV3FF97PrnCSNrNDkEZ H5JquzuW/cg+a3loBuguz1+liE//ZUGAERDrsjldu92B82JRppGkJsd58K3l RSs3pGWzNGWw9WN/2p4egGeQZguX0tyr0ENQw4ym4yXKSyuInDjG7Ip+wHiw Lv3uiF1BQ7eWHdOaACK2VuMUF3Ve9zgyEtJvJ2Tg/cPT9vLQbveZSIIotbjb 7k5PXzAvvJSvi/FjxyLPws7BCz9nuaqpaSHH+EurBTfOqOMqTx3Hw2l7fsBk cTCAbaetmEEUBn+Dv8Hf4P/e+K+3UtegcISfpqTUThuSlxi/+JgLv4qK2kuy MC/dKHXCOCkaViuqCuuFtIKPpMZNVvd5S1Nj1dZAOAO8eCE0D5sDwpb4eCYY 6rA9AFL+hPrbNZWIshxX9BMkUyxGp1WDoK/1i25H/O0wntseDlDrH1wXEfnT bP5xNvv108ffPn+6Wy3tJAD+WH0sMU2TvcCJE/fHugRZzgheVDSDbmkGrfFX BUPSqo1z3ApMrB811AN3ogT/diy+MNQCZNFZyui/Sf+gC/tQurdKDVW4sV2T PMgKRyCiFHnLrhPs2/Ue9zP53HbpalSVDhJGz126/tLzF463cL254xn8Df4G f4P/T8DfIf5kpUqIpEhd2+HPIC3F1z6P6lJKGAWClB3EOFVSNiypS7QSidG6 6ieKbxcUKWWtpCzZpNAMdc/6Nb4t2jGjvBKCNd3Wxt0JZ4jzupRit7BVWz/J lr6HRcdSlv2k8ncqamr7EeIpRiV6FyLiV9Vzy/k0mymlaubYOLkrykgIsm6U BGlB104aekb6MA1TwIeI+/UwCc9qkNRpwO0BJuVFKaliEpoBgpvINmvILtYG DfHKwQ1BJz4+xB+3LtgP+DBiy0ZqBxHOH2YFti4pCkMvfeUXXAufLN0AuwjD duKQVhGW9Xk2xypYXrj0AoO/wd/gb/B/f/zFYiZMKDHdIBGTqnFh+ZGeLSpI dgrkgRK1psmbpdQ2xzNMIm2NJaP5QpiRUKplEeFZJQi4rFwPa/apif62CuUh g2vGrbTskZ31Q5SPvCxxWGMzRdH/H4ufpGowSD7CyivynboWcRB3CyJtSvJw iKVnP0hBMVWxQsBgGIJ9DzP1RQQVUVirPCQYjFvEd+ApVDHybLGvFq4v+uGV 9M1xMDgS4NfDhtWZpkWkFrRLhGnE32l3ps0QPhyGWLrtaN9WtRgkYrcKfYiV zxAWFRCmBLfnh8Wb3hRLNlmum5Z+QAZ/g7/B3+D/k/BP2+7NIlNqMWxbYAhm mEuoWVepzT0Ax2kL4EmIBlFPzaSReWI/RcWLsiqRkYwkktcNpYp6Vrfl/LWU znP+vGVoy5CmtY2uiwq9Sn2f1sa5NjUg5PVdUtVp2cZlLdpHQ/Cm+/f2DI0Z U9eL3mm8FFITc7c0WbgO8i8EU0peJBTl4+M+Ic0CfKZINVvkcBXcLSBYx0Ul UuEdRkjLoaaupglXTLuOBF1J2RJp8cOH4/6ERWxEi0kK8dSVxQEsvje0nFBr BrEuYsuhFYaIwmnTifVDrFRhktmaTtbX4G/wN/gb/H8C/nnLI6XKgFCYiXJp hZMA/LShpGoonCICKCRbUdWupemMFCZcQvoR1nk3UKFinCIxX+hYkS+VlKtA 4Y3WxGNFWMxxlNeEGVXjJPJKPj1uah4c5jQp8PI063H+QdHAmSlV1DY4Xq+u JXIcuQxdPQNfcSByqex0w4cAfDic1GEZvxVHtkr7/iR0suOPbNtpKifmWUSA 862kkkKbIQZr6aSgT1BdA3YxoduIRVEtq1bokTy/SI6/9aEIt4HlmDf12grJ XfiDZoyvkq5h/DX4G/wN/gb/d8ZfoqSKXTsxDWIQHTBgebBWiZ52i6k1602z 2VHUSNou1KTSUyHrLMErqsVnQfIIjF/5Wki1ALKKaSvPludPEu3y5jipX8eG hX6773dHX5o+3DTy80SC4A9SLulbtPUEOMU4aBsIjo/yktOsKvkJn79JNYck 4YVvIxYj//LopJYP++Pl+WvVkyX19zaTuJ+H0jqBFzK7Yhqw0PgQs6jXG0xH YCevWHVThZqb/F+7jvlgJGq0gCiRZ4909pH6Pq8irSIAljzkimsaySbE+dmu iNseyWFl1gZ/g7/B3+D/vvh3xB//+fNayALYTcZON4SkoGRupclFvz0Mu2OQ FLkUnXE8ri7F+nU5sBePZj1smq40qZmO59Pja7fe9ZuDNFkzgqtsaUtC7LHd 7JR0qr14I0Ww93YURUWhmwGhcDyerq/fsI79fi/lkiJVvdMsxbBHxNOyRdKH 8IfMCxup3e5w5u3lYXO+0h66ppMazc7y7PT05fnrP9tpi7sCjER5Uxpt3yi4 wKGkJQQjKb14mGQh46uGCfvKF/tONmts9+vTZXu+DvuD7DTsBNat1scLxuPH OSDFeZAhYoFqUrNOXEd5cOelaSh+Ex7HLxs1r5DMil53ZPA3+Bv8Df7vjz+u hQCR1JSYloKCPA5quqis3kTkynJ7fhj3JzdMYiFfybOjptseavKX1vW4QQaX 1kzWEvFf3pwuEu+mvGELMz06pQ9CqLC7cX/Eh6zUiPcNrgLckNH4aeElSSQC Hc1ms78+4yTb6+NwOCJaMRlE/sKHgSmWA/NN647ie3x+xdQGSw+U1ofz+nDB DUAtIksEs8gPjy/P3/7J/bDek4Lb8fke8Re2MLYW6QGU16ulhETLBlpwdiOO z3vOF+kedtTl+dvu8ri/PO0vj5i1uA4Rf2wVLPrS9e0gUv8IDHh9um5PwO2M I8OC+AfSlI1vsVUoYEKeAJU6bIO/wd/gb/D/CfgTXrz3UjoaF8Kbndvep/u5 G6Wqs4FsAhEHIRj5TlI0gI7FkQ5QUHYbSQ1wjqnammkpwS+Q7xyOjy+IL0jZ uApYsjJHeLXD2IvJUF26nuWHcVlpY9oo+tt2GLlRzMoFay6slQiPl3HKT3Mv ojwIEFa3BSwiGWJpiQMSVtIrXl2U/dKqq4d1TalwRE82+mH1N8dLQ/+IPSZC zq2IJpGR2w5hVn64vQF0uGIkTwtxCawahoSQjfXSogxbM9b7sqPeLOab4CVb DpD2+8O0P3+eze+WK56z61M2mBcrL9TJ3iyWK8/XpkJsOdyKYKuzaFVgh7BT z+Bv8Df4G/x/Bv4lgouSb2mj3I1OmFheiNlhbNQjRZaw47DF1IDkK9Wj0FpM 1vRv/Ku0wFf1eqvVCkw5LipKcw+bsh8xyFXoBVmeCoMLxwPSRNzWMB76L3fD wvUQkoCn9llgyapxjSUOsoLNIHESUXkVCVqMjAnjwflJHquo/qdLAIhwvOra +WmGu4VcebY9jj8C/2l3ok7shJyo00Zpmvt4wb1lh1lRyAM64G/HAXvDNwdN 2QBLxGJNUfYDFgVJpW45XL2QJePzyXFrBzFemALmIu7VDUY+t8m8Av5YBdzS aDbKG4amzRvquGIVDP4Gf4O/wf/n4F81iDtqGaMNy5WY0eBC1bAuxwkZGS5B zdVSxLQlpRIeLHW5RSIVYaXKG4RaPs4qxiEWvm7RDjgD8iDxNahpbZbQyJJR tWnjukH84lO4qhDNjYKOD3FKPAdmW6EwlKiYUVXAUxx54kCVV0sqWgABNsGV pdZ9POG1CrDF0vPsMKRhBJkDbVRzPAjKWAL2hnCcxNlLE+Z9WUYTurzA2QA1 5qvlkrIdsU+Khs6kOO1bXb5tkbKRWtxPQkWTrkNqRpUzy5k7Hi3nxIcoLikY ggG7SbL0fVyClwbUEuJxvBuya48ojWuDv8Hf4G/wf2f8vThjQjGuU6km+Dnp r+V64oO1acNwPE4syjTAvysl1cIgS61KCFdW1efwp8ouIX4VAzWaACD+1P5l PvLqeynuU9NVvyUlSR6aeeSj+gEL4oWXpElZq699kKc4LG1qxtaqlsJ6pn7H iI++yBYhokkRh1QBVdvW8pA+Q2NJfaQqeEiBEVbVC7FO4MO6tvlbhQNY+aLX h+NJzWWBJhc6Qc88S/rBEeK1u0T4WmT84qaFNXRWUligkdJ8iiCOoE/eMvVd U+nO5vFCQiAZOJUne4pAXNYswbQGf4O/wd/g/9PwL8YRQSeRpAmpVkEbgj7r W1GZ5vkTUcDGRZUoi+NFj6Ko12stQ/PMXVOwdqOtFtIlLQJ3YlgM/PmcSnm8 0g2diURqLr4zkfgjRCrrxy4PqQGFRTYeThiStFpIw534b/o5qzY4XhrAUyma Awf292HbdNu9Q+ODQnr3SuXHSss2ebaZ0AbwofRH5xh/s9mQo5uSciakArKL xWqtEops/aOLpJf2vRbn/3vhyDeQZBN/KjvrLSHt5fkbx1Yr6Vee6eXCT6hU AJC3Ch1HgoWmdp/B3+Bv8Df4vzP+A4NRNY0MmlXR7/fDnnXtcmBawSJLU+HF puYyD6VRjiY1tL/EpKiPjWTEidltJ0wqFhf0jaQYDLVsQ2bzGsfQrDfsyygr BGIR9w7ZdyCJlZ1Ews6NeAMwjspr3V+eDg8viICiEEhek6rCAnxZAhJ6dckS qYNvz9fDwzPCtPaGMzRTEuStWU+OT7grplEwycmb3WwRZ/lYL09U9Jt3FEWm BqD4Cev+faf+EViv3eWJ/nHIHOlASkz0kaAIg4s2OAK6iHvjk4Iwdl6a6fDY JM6gnGq8FlQl6Bv8Df4Gf4P/z8BfKumlElwxsHa7C3NWJZhWFBl1KjrmLxnb kMfsb4lpdhyn0/G0Pl39JOMUakaxepqGw1HW8TAeT2RJSaajxjr9bo/4hQwI S+BJ+jYdL0Ds8vT19PSKF06oJjgJJU+r3fVp//AcZmVSU4sDgZsBlM0Ra8Rl adAutU0DU8AJ18fL9vI4s5ywqHD/gG+x4u12K7zZc7fd4cU7DfLKclXzxgE0 02z4eE0wZBMHszMR0NYevUikU0PZb8eH56igDylPorBMpPJWYtOg5F5bSL/A p95s4qa5mS+wJcQwgngCMbZ1i5as3E6w39Dgb/A3+Bv8fwr+CXmkjHFpW7Ow kpdp1eIYXBHnBKTIXMiz3WzKYZ22bxkWrg54Eb/CrMjqHiEpKCjH2u8OwKEX Fet+y38LMa/EfDF9fj5ts5pt3QjKMqPXy8u3h9fvp8fX9eGiFgliwZBjabAo 5F8lbw+yGnF2QJIoKt87JHdVP4pJnPJat/3+cG/ZS9eXFLLbnK+n56/nl2/H p9ft+WF3esBPRByV6SEOpmh2O1IMBBlfxbRLG0mw6zASPnkTMlVSkQ+A+P70 7c+oqETKr1WmARJSLCJzWFFbsqNQevTY1UhBj65f+cHC9TjIIsU5MWXghksr l0wMTMnjNfgb/A3+Bv93xp8uYzVTDHyLUWVt48Upzl90QzHyKZyWIaiJ2g54 g2j4QwcPqzNQByMrlExFsSM6V5YUu86rN3IXTeonqkwgzmy20+FMpdO6Z0ml yGmdmYt2X1ZiUYI0pxpqkmh6AvwBmhdnS8/30lTNkZn+VA0GM+wOzbTF+eO6 8ZmdIT/C6pxEUTZVnhh2DpO+9T5ve3zoRkiKahqoseEuo2nC4YT9MJCUuy2k EY9Vlbqthglr3YwivkoeMnWc1qfL87d/Lt1gZjuASHrrmIthue9Wy9/v7j7c 3t4uV5RjTUI7DpHfYe5+nFte6MasPdFzM8lUf9smNddfeQElm4B/bvA3+Bv8 Df7vir/lhwBQpIFKN6NhMQYJEIj5MOUj3QowGE6nHWhVUNSiL9dJwQKBo8cJ nShiiiFi2uw+pohfGZds1sOv8B5LjMREQtV24brA2U1SEWtN9UkXPhH96hKh 1o1j7VPbIlxOON53omQVBEnDh2BSWGmwWMP2OO5OeTPgQvGbX89O/Rp09eVu gVX4dr2thTFLZdSWmtvIg7Almg2t0HCSaX8et0dsj7xnEzoZaB3JBhRr7Sdc C/HXS2PWpzZ74Hy3XNFnQQQ0IqZypRUEn+ezm8UCCzF3bdH0SFjoaUfE36Xr 6Rby8wTXdaJ4bjsrL1w4rh1EEW54qH9l8Df4G/wN/u+Lfxj5KavY5TS6lM5O 2deWlfRZGCaSaWsylNidPayLps/rTq3QnCTCVwBqKX0TWAIniVVk1YoDKS5Q rQ7I+1kurWdqcEzHNIDspZn/Q6HITSMq8mF9xbVHCih8tial/1ZMalyMWfuj XanCp3XDhjj6O6ylQFOKYBRlA+0gpngs94+QgZsqH3qEV8TTeuALy1Gt1+U0 aMsJlrilKvhaRbZT0VkldB1WagL+OL/2TahbEPDHC+OhYFSa6gNJoRBzanPH xlpE0mpHXkESA/nP8zkAx8EWmWNpWGRkjmUFlgZbHbcrBn+Dv8Hf4P/++CPw 6QiBf0wia4txlu2IuCZUK5baAamqqoriXK9iF36WIHQiK1l4bgCEM3EWUN25 jKkceVYSLvEGg/Go7BeuQt8KA6HaJiqCh0/kmV6btNou0dHBp6MLJ/ugS5Jy Z7ZNdaaS7R5K32LfB8kDPfW9Wz7Nw9nUy5j64Sl9gqgr3vcJQ3MWN6WSwcgT xmuzAf6RELSoCrLesVVkWkvFvFVpPp2vSPbVcVtLiGdV5Xa1uF0ugD+d13KV 48vDKheLhwzD05WSR4jcYBg/4jV+osrkeNESTu5eRH+VZ8YwDP4Gf4O/wf/d 8E9+4J93FIuW5jLK6CFsaYtZNbH5TleHgUliIqm2FM3OVLgVp7ITig5pWBQb hSQWI2YlWWlRG4uFODv3nGXgrUIPCyGK0xE+XAQu6+anh0S4r9qgobp/ofBm f5TvKwxSdC1Icx32R1HJILGKjCYhYumC4kg27vVTST8Izgh/1uu19E1QeYmN GCNbrdnf0dblOCBxq6ct0C6nSXW2s6aJam4DnkEisgqJW6HPRnIqsoYMylVp xwFOjrOReyZDZVUriVTGVsaWIMPS/BQQCVM3y4SjRbOJH+YUBn+Dv8Hf4P+u +EuTmkTMJMhTlR4VC4aSGQqbqcdUi+/rTVyK0YxoExFVoZLS3Yb60uIpI2ER aPOR12aLiAlsl6G3CJy579ANMyZDFQdgIRB2MQwnpkvm+fnrw+t36hGpZ4EM Q+IsfW00sKpxgx5QqP5GRXMEZe06cYDzqMAdzhyou01LyT6cqtvtKco6sm3w 7ZajeSMMq9Y3juRM5QaAzdrM1zZii0ZyrNouSH9f7khhBdiq4Q79FNK421HE 7261Uu6uer2RyoXxi8YgW0JkUoS3eHPqYZrJNo3M4G/wN/gb/H8W/nwoJPVu HRV7qEUyOqU1D0Ntv9sjR/hwe+NLYhJIbrI+XcbjqRjGfneoxlGDDl4YXrfd I5Ct/GAVBIhWRKwfkN2M+9Pu8nh8fJ0OJ4lckR0FGMb15dv56asbJkEmj9Ha Dic/Pr4cHl52l6fD4/OwO+DzH8/rWAeZjmdfivURHW2ivKOeKsVU94fpdEGe FUlaFMl8qb93umZNhzGo5YEuQS7d0yk/yXxaKnC+GhzZM8IMrpU1SrEVAcJ4 4Pg354fpeAJ0wJl5ZRZ3pPgePs1mC8f1xZaCch/rDalW+yPm0m42nqSr2oWB nBG4LT2fDxsZyn2Dv8Hf4G/w/xn4p5KIMfmSqgTl6brNnrmJmB1jbOvTFQD+ 183nmW2pxgUmSBnq65PybPGTIMsWnoNQaychkiMccL+yRH3OQYzOKVixxpHr w2VzvFKRo+1ZqZEKBc4DnEW/LmJtvesw0/31GZ9jyQB+N+0wVDY+5yqaNABP HGmHiUThCgMgMqfr9vyoKtmF8HJxcvoHbbZI8ap+jfPgc8VfxcMRminf9yb3 hFSrctIImDfrDdYrzJj3SSddPx0vw/5EEu/5EdE/pUQ5Uz+gCpwx5c/z+cf7 +x/4d9iE9IM4PeA1bI+U4EaSWDAFAxo4wBU+WJAzKMcGf4O/wd/g/+74Y0bk x7a1Os5TZLVso6xKigZBR/vaxsMRP7lbruaOG/IMRViVUVGtXB9B1g6jlR/e raxbazn37FXklQM16+6Wy/+6+fT73c3MsZiFuc7NYvlxdv/rp99vl0tEN9Hf LpA3AWdAZ/kRXklZS/8yzl/bYYyf/OPjx49397gQBy9TTuoGSxlkhRsh9NLC UrIhcquqnnxg/BDRGUvDPoic48c6KoWMz+XGMenIKMCfXpJ5cSbSfxlOixsP 9YADPnnTv304jvLorAhSvpgnli3fS10Jq4MdgrP9180NXiypSz8grp4LXcGL 04XrWwEpalqmxwFYdJHm9sOcSuMGf4O/wd/g//74iwvYkMiDKbxJq7aSVgtS VTs+knKSGAMG7Dj57XKF2el1peaSkHmF83iA1/czqiQhpOIqiLZWECIe/fL7 b8pHXQbuzLHvLev3u9uZZcfAuW4ZItNEOynmtouhpiLKrbV7HOBEMa774fYW Sx/kFERSeSXcD2DkBCErVMdVG9mSqsV1sRmQ+tGOQfo+EK/bzR7H07KzYiM5 9pt0ebdhWiLI4rpYCAwJX0V1yZwxz7AJkd9RQny9Uc0lLmhGPgAWF6fCrQvO H+lgyuq/bm9uFouF67oxoGZdPhM/izivsB8Wroeh/m0hFxQF9jNSMOLfjwZ/ g7/B3+D/7vgH4rPQU18oz4WPNCD5Qn6Ea1GFo+3sKGCUiZPbxQq4Ma5JMVpr InwixzSHxN24wmDod4+vwjy3GZRXn+czTcG0+E5bZN914hgLigRKz8Dsr24t P6SUBwYsRsZ8uiXl7HuL+wSXYFBmy0YiS8B+PT+hhw7VP8oS48QrYkyv7Cjy 85z62GLQrBodCKZ+nOF4UdWTS+QJ0ij2ldQdo3M3KuHKigMKPUk/iJpQ8Omf FPflVIUdhcibxE+hE35aguEh2cTSr3wf9xu8Dwl8Ow75tK3tcbAVhpyC8HK5 G30fi4WfqM+Fwd/gb/A3+L8z/jPbeeun66lfSgZRXWbqLE82VCNk1Pyttl4y IfKSROOvDlJGlYpgBZ3OlG0FnPHGiaJPs7ub+dwKAyRxM9dyBTqMTU0nMf4f ytWJFLhzRDcsitbfnTikl3GRr0I+oxMqbyW6dhTuI89KoMavYgpxlxgkx5On wgQrYlHJxr/sCqS0eJZUNcCXZo1KpbA5yJTksZxUW0qOVxQbqd0s1mgbFw0W l03W1NBO30T/JNeL6ASaqVQIRoi7FN4GiB44YL93rHuZrxIJ1OuHzYZpim8X gWvLaHGTEGGJm97gb/A3+Bv83xt/X+7/u14MiHMa2ZBTWjGRqWtpQygYXOLI SUiywhXDUuoI8lwOgama1krfovQo6zi1E0fAn7ysKFx49s1idmctcQziL6IV 5mjLakaCpB1HjKc8P9/QlUBMk+mJk0QisrTXWUsHB8VXhbIV6ieAPRSCLoNa ErEjb7sXUT6GdZlC/hY35U82mLSd+sfhq7hhv4nydaXmTl1u5WWxZYOyhGMi 4iT4rS3UAmnBS2WbpXLXgWkGuKlAtPVFpk8YyPHCd7HrqK09rv0f3SLsvIhI 38JWtH5sqrztxMTH4G/wN/gb/N8bfz4jYmMFkpQCl2um7Q9SloczMKkRuimm jLiJT4Svm6ue9uZ03V+fEXTYehy4FjO1AsEIGdbCd+49C2/wq1trgbiDCNWs t9vTA5IvAhhHPDL02IiRsCUNq+D9IN9ijrjo5vSwuzzpWujL48EhGblcC2Ku s9MGEMy92x38TDrg8vyNG5wmQtBlxwcQkB7DTtsfED3F+0DlOGrl0wpRKlYB pUAURSg2XpUYqvT3lUFGGSUr8i0BR9m25BJLrV9XBztwwf3W9rvD0vMQyoPi zUICNzBYHSzBvYvsK0royGPwN/gb/A3+Pwd/1hpKZijVOOX94JEUlCuzCHkZ ReTowjmIbHVBE0zmX+xH0Lo5kjKcHxdFhNUnXeJ3VkgDdb6KAnyO5VD9ve3x YeEgAYu0W7nf7nGS49Pr+fnL/uG5mdbku0rExNW3pyuWQDM+6cKgBN+wO6xP F/yL0E93Htolh6H42ms7mxsneUu7tFXgYb7aNqjeCjg5cBPLNopNxdJUTke5 joqCiIm62aTKn2lnBF6M8nIVfIIQv3Ax/sBNU5xHxWaxqShFu94WfY+fI8hy yp4jfm31zWLhxbSEwKW5BKk0HsrekL0XGfwN/gZ/g//PwT+ORFmCvFbNv+wg coBPzJhYiOeaCK72jNRVrbkSvsIUhv2x3x5Yd/ACiYaxRs9S1hHjwWiDvLh3 Vog4iJtA+3h9WXnB0mPzHbKtw8PLy/e/Xr7/C6/ry7dpf06bFsgACmCFbw8P z0nZWEEYicIG9oA0WRy7DcW3WScqqYyqRRnV+qADsrTyOfRoo8KGFom4baSn TzupPbacZGnXNeOmaAbydemkQ+flvOuYCSIPLZEMltp1rlMuh/XKD+4tC/hr fwfdluuWZN28iPLaSzIEaOw3XS+M+dN8vnTZavF3uzqw9ZKUDYN5QRIaE0aD v8Hf4G/wf2/8kT1lLV1j3CSJ6A5Ze3E6dxy8EEeYs8TJ73d3JF8tlh9ubz/c 3jgStfEagcN2/2k2/zyb22GoKcYy8BGh2GqdZHYQA+2V78uSBcD/9PA6sx2M H5C+nT+JLT9EREZcvl0u8VsGR0lqzk9fEJ3TsmVrXk6fZS36s5chzmjKkNfY La5IOWGJV5EX4rdRQpFwimaLM2ac2FGkyuFp1eKVCLa88SiyrO/KfupEgk+L L9W4xjYYtke88qYn4bbhaqrgBrYi1hfjX3iYY8gnb1JJ/3h/P7Mcy49WHtJD 1qF+tIE3n+eL+5WN82APh8LLxR3L3Wo1s20riDA7XEU5DAZ/g7/B3+D/rvhj SDXCTaePpzi1iP0IbG1mOGMa8nl+//H+7m5l/fL777iQE9PF0iUvd0I8AmKf ZjOcUFSG0lXo3ZEx5VFkO0pXfkjCap5jtM16M+5OGOfMsvm5qBLhZQVCBnNc 8lcdN64a7YneXR5xfJAVtITICsVTZCvaqKgsP/DTTKS8xZRTHuLxYV0Y2/KV 6PK9JYxAksgXDRYCP0+oCstHfHhf9xu1YEBkV72OvO8Y30f6BCVFjX8ztstF MoBy6Xi01PFcXNfmEvARIlYBu8gJyUbGkCLRCeHTtgzoze9XFuaLPakXJaUh COVDP8zLrMG9TWvwN/gb/A3+74m/9l/g/3+kAAHdYYIgo3VOkBRIIpBZhEW+ 9KmYN/fdu9US8ZFxMwzfqhLkx1ZA7Pe7WyyBIykbDmZ5GtG8QP7ShGmhhsgU 9GhbZHAAH4uI1Xx7sCZSpSQmRZEVhvphRjYXdTByDIx5TRlkZUjeFElTmC9j NEJ8miJnJOuJdCk2SvPGIIoxJCsIyApr6r/LLso0yNsRwS6WWrwwtcqs7rE6 7bSppy2um8jWiqlDuBYRvymh1RrL9Dj5KvABAqbgRCQMeFkK0BBqhVSQsxSV FUhmxa+zXFGsL8CdzO1yxZZAMYnTEjzvPWIWnvAhfRzIf8gM/gZ/g7/B/33x z2NqjbLlTavJgJ3ZSlFqDYJkoTjAVZZSYZfKSBr9kKQDekvP/TS7k3wkosh2 yqdnOBiYILqp8462VDiMj8nCdZGv4V+HfWpUz+O3VcUpCL+L4FCIlYQlnF8a 5Rpt7qCdvSjaiRRe7LLNrUxoXlYJpYpVG6aQaaYH01VTiils5aChAz7p9Xka fqKtIizflzSY4+rQh7pc+i6gSLtOhZJEoKMWwSiChtktXAcv0m5jginqrDUg 5YXyIlArIllftZnG/hF/OuE55NhpAbJFNpJzGLXaPRv8Df4Gf4P/e+MvktfC UH1jvfrsYqDuhJBdGXHY4FBXCKysR0eBTTpTpCUPW4RPxXQ4lXo3YqivJWyW Y/IMP9TaRyAp2BtnKdZgxCo/BrO/Pve7vS3eNAqODkkLFiJnwQGoCDajc9vW 06TP7qQvQ0ozpE5R0MkvUjWJTqi2PQSid1SoFrdEOqUc6BRU3BXnpFdy36VC x9VlxRmo10rdb15ap8ZXzIZEafcjE0z1ptrtfiVdJ+xAjwOZe65PKXEMT4V7 j7aR87O/myLeXCbeOQTEx+Bv8Df4G/zfH/9S6LWRFtbZIxASZAlYxFDU89g3 sfDYNYYBzD177jn/h9pKxhF/IukG1bZpcDAMyFAQyDgqqddr3oSgieE5jLns eiCwVfny/a/T46voeCfqWeDlifZZWFHIOJsmgTS7ic5GWg7TuD/9bdOpfX++ gOmmHAzOQz7tm55qGpbSGSE2ar7Yw3GTxJFL/6BYyLQBy/E8jF11WlWnDskw EiLZDL7sBzWV0PnK48oCi749P2IJbldLtpNkiUWUxGZCBGa1W0SbWagfXmTy 2wQ3OZi+7gSDv8Hf4G/w/wn4Z9TfZqfYtO53R+Bcj3ST0Z41DN4CJP1Qrzcz x1l6nkTJLOv7brsbDydKj+4O1TB6UlmQyOJXQtm9Wy0/ze+EiUR7zWZab8/X w/V5d8Fo92Tzihg1AtDzt3+dn77QZI30pBAgrI/nzfnh8Ph8evqyPT/U5OXy JkF765r1ttvuRcGvpgkm2yIKMVZoxFKHotkAVuiv2GCpqCeVTpikNdsMl6Fv yx2CpmMVRbk73XsaylPpPa+HdTttpXWOdkLj8YyRA+rN6aFZb7QfUO5ecowQ n89s5/N8juHx9oNNfBwStq7kbhyGjIR9i8oHy5qu6CgGK/g3Bn+Dv8Hf4P/+ +GvxgpYB46Ya12U/5v2YyPMuFrWjACNsNlsnpmu8E8XiINAhAm5O1935cTqc kd0wjqcRQ0/kI2zhtQqCm8Xi3rFwCSwWDr6+fPvy579f//j34fqCfIfJlLgb AH+c52Y+v7dXGDwmC9gvL1/Pz1+ur98vwstV0SfOOolbLP3+xMGnudrucKZD r+pJ4h8x/HhqV2n6A5ydMMYShEXlidPQ27NHFmL4vE78PcvoR3c58K+I/y7v BmnQ7gDCuDthJIj+orNRatEf6NEq4vq89Fia0T70t2JT0xQ0s9tLeV10AkU/ ijpXQHvYlN1I4m5BmzmDv8Hf4G/wf2f804ZVaSZHcZzVPSvdaUb9Veqgsnjt RCGm0252wH/hsq7N60prg0/N0iYTiWlH/JEl3YiwiP32EGT5vWXPXBtZWCBK ehjh0vUQp+4se+G4IvrBas7LH38Nu+Pn2ex2ubizluykq+u8Jvd1geMd5261 wtKzoU8eanWbPeIdLu1GqRWGOA/xb3u2XRQ1ma51l1bsicj6jrIeLNDUlh/d Ly0/zt54XGm+cDwhx1oYDKXwylp1ORC+qYlUdTiPilOpjJIdsriP+4S7lWUF USTJI85/uD4B/5Uf4it2//UDrpu1gCUDnkU78YdhRD/QrvVob1fR5HTalUjx SAnomdYZ/A3+Bn+D/zvj37IBmVWSsgRuSdXGRYXUg+LVFdWQEBowfuDvZwUZ VhHjnZJdVVwUI8xoRlNqHQfjqcYJEMVF7cQJUjY3STQOzhz74/3dr58+30gr h7YwAE/EWUQigL/y/JltUb5VtJWsIPz100cFf+n6wIfjwcnGCUFfTBBKac2r 9GkeFiKvaZpDkm3VYgVxY6BfZU2/cgNAbQcxVfsy+gpFRYU/P92TPEzfhCxX nhgTJbZ45MpDTpo2eJPXYJgmgSoMrTAS/dUW4+93e6SEWE3LD3FLkLeD6v5h CYBhSPJYAZSAquZimAVS3WF7xCeIwpTvNvgb/A3+Bv93x78Z2F7NwoTor6pC XUXq6Sj5DkswbvZWLqfhQpJoKzTZU6K8mrG6TS97n6lH6YvSBWlXWeklmRuT WKtqSMKPZUMfuw+s1dJ1PSHHliPTpaUruhwUqdZ6B5VdrcBHciRTyP1Mta9Z GwLUqcRH6mmLBZs+7+IjuLrF54hrwEGkBelxiZ/PLHtue16U0sqNZN1ERflw 44GLWr7vSUFceVbcaeySW9qSb7LgLv3UfG7Wsl1OmvhqIQ+TD8AGQNfDYBj3 204v+kN5r5SC1FgIGYDsgpIEY9383ZpR2OBv8Df4G/x/Cv7/GzLJSlo= "], {{ 0, 256.}, {512., 0}}, {0, 255}, ColorFunction>RGBColor], BoxForm`ImageTag[ "Byte", ColorSpace > "RGB", Interleaving > False, Magnification > Automatic], Selectable>False], DefaultBaseStyle>"ImageGraphics", ImageSize>32, ImageSizeRaw>{512., 256.}, PlotRange>{{0, 512.}, {0, 256.}}]\)], "SurfaceNormals" > Texture[\!\(\* GraphicsBox[ TagBox[RasterBox[CompressedData[" 1:eJzsvdeS3Mi293ck3XyXegW9hW51+UWcGXpvhra9J2fYBSAtgGra9r6bvunN 7L3Pk+gBFIqQdPbZs8muAtICqOqm1gK39AicG0QUK5rdqETmLzNiYVX+1z// l2uTxwf+x3/7t3+79d/g7fjVO//bzMzV1on/Gf5zauLW8ODEzRv/feL2zcGb M//rtf8Jfvlv/wP8g+vxZ8YMZ54KNzphNiY1l4Zxx4Wn3DHmGTVMWiEto44z S+E3wnJmBFdjU2ppNJNc4TXcMt7lwjBmo8TGacaJ5vAnaIp5zpyI8/Gx7vJI Bh/k0BTvMVYJVhLRZff/SGRJiBUs53AjDo27iOvpgXx1phPJTJBM0JJyJek/ oFnS1vKuYwS6rTg3TBSUFTK2E7fyR6NZLB2FzgvPof/CSqpI2uFpLjiMSNf9 NBzbNzPQn9sZkznjGgYraE7hrzBACb0tOEIo4E8SbsELKouxUbU6nUELnHrB kAa8GHEkMTJ2lGhgyAS8dznLhNATv6pHY3kq4KaewpXxPvDhdfswTEFgmBb7 j/yLhn/Dv+Hf8P/h/LE/UvrbVJ+ZNh+m9X2mAwF3L/BGseWp4aljiWGpJdIj T45zFPH81C39dEIvhIZKJUQOtxaJE21dX5+ztqOx+c4h4fY34k5MqPcT6gHN ifgiWQEjFbLPYLLkP1nSo23PYidYBV2NhR1u5dfHzfuZDkwi57lgfc4rITsi tTxxNMlpO2cJ3BeGALRhYbiTk+b5hHpEdMQd4YWAwQL/RNG4Q2FSsPMwCx3G dCz8VKSvQn+mcrgXEbBONIOuQjupF3HJEw8dY9ACtzBxAOo2seen9McZFTMY KUDAlQnXs9gAJYovWG+GwlJkX7mAaQI+ZndcLUc+YjAKmNwSVjVPCpEU9WDh dg7XT8O/4d/wb/j/OfwtQT7FKFGnQ/+uVaxHKgSScSGAXqSiyYwO52Igi8e0 /M0Q6KEwkn+9zbonAvskLB9HinAchaSG3rbBYE6vaHE1S2/qZCqHyAiz1hbF UGhPtrD9zUCFspSiz2iHzahgMGPX/5Fc08mQje94wkvKqlS6i2H3ZtT7eEff p/8JfGASY6FJYOikJsO5HOnKqY4MFZOeCEDtfmXqaGCftzy0H3CYdJPEmlBN Z3I61uHjWv4KsTVn8RfKu6mwN4Lsalh+bvl58jXgSkgtoKnIkemcjhs54uIp I3FpQXAvE+pHiD4X+E93/AIwEU7CvCSORy68pel4JiZzcQfC7pdIwuraj8V/ zrLsSMvvBsWTULXEPwUi9TQydEbz8S4bVPFEHrfg4cE0/Bv+Df+G/5/EXycQ 72R5k6hzpHxFyl2qifAR9eMDZvKonj3u6JlSnCvTU/7hSbM2oNvUSJFN8vwk dTus/4Lm9SRWw+P5+BkVnCnopVJcquKzxfxpvTWo2qxK+MF15s6J4iUrn1Ib sV5Iy4FhNX0uC8/C9ZW4UMyddqtn8tUpSNBszLoX6Nch1n8buRX6FcYLadrk WHf6mG0d8+R0IU8X6XH/8Ihd+UXNESdjP047J4jfJdUzokNYJDyfHFLTR3Xr hGNnvDzj507YxXP5o1v/FPL/SPh//cK6g6z3jhWrbD8SeSTM+KCG9qOTnpwr +Nli7rifP6FXBjE5TXl5g+YXafmGlpsEcjdPqJ28ZmeOmNYRx04WySnXPubu H1fzg5kkeSy/TDN1JnKbvPciyghzlPuJUTNzwrRO+uickzXPhZN2ZbAb84Z/ w7/h3/D/E/gvD3XTGPIRd11kF3i1J4snwka835L9gTUz9coEewV9WsknVftV Mf/erO2otrSJcOMyPyGLHdF7CakQfgN2OL7hJ37Xrd8teVeId779u330V736 GJKpImXVzbg4HftXsnwsNWFlJHqj23bys2598OxNId8X7c9u4YNeXtgXTMH8 nk86A7L/Rtg1mUUMhvBleKU7+Vq3Xnr6tBRPS/myuP/Kbm2ph0khWX9MquPC 77ByTwB/Ewp1c0VNPDfh44pv9OV2L31eLDy2y/f+S4j/vS3+zytxZ5D33gu3 LHKCKae+uZpN7ulgt+KblXxcxS/Khedue8XAw0nC/Q2ZXZTla1puCx0JPyvs wGo++dQF2xVf7cu1XrxRzW/bzcWsjV8YAv/9s8xts95zoQA+4X54WU29RJ7R sx57XKUvqsVXdnNDpbLh3/Bv+Df8/wT+G+sa/pSy3mBbn07du7TYin3I+pId 8LQfrbrwiYn2tNwzc7s+XqhoUlDhE15NxcWRxD5PymdtE9JDyb7Bi7X70XJJ trzcKpLlUs5BMnVI+EHC+hPSH5+z79p+PVGEVdC+hD/d74Xriu9ouZEni13R hn7mDFIn7q6288tJ9THRi3EHeArxh4i7ZEG3HhvywvBnKtnpJqsdMQcf+Raz wxmpj6T2KfZHB8wKnou2aa1ls88z8ipPXqhkS4kFS+OvTP5fbfHP6/HXa7L6 FLt5kRHMv5xo58Gqbb3U7K1JXtn4mYnXLG2XVLpUFkOJOZMUb2O/mZiQlUJk /L6b3fKzrxV5p8Qbnb5U6VaH3/2/qdynyX/div+fM4l70u5txx3CIGMtZeKj ZRvt5NGTfflSJ09Nuqx5XBBeNPwb/g3/hv8P5p/U/BkvYtqfiYtjD9Tnh3Y+ rgjtc9ZntOJRKQJ47/GoYsEBiw44zAs/FKwfiv7P8+b1klpOq4geCIDPvnFy yMNvMvpG4RUeMFJCO7j5zsqWLI4vqneL+kEMyYvnrMegKdIXoeHEU2J55HBf W1RMFAkz43Pm3JL5fd7MQXwkmrOvuF8TGRE4FlQsKuB6GmqBu/xwi8NQup/m 1Yt5s57oENoH/hTaNDzSDDJEkpPQMfgvs4y7mOnRuS+/PLJ/eaDbIoPnB8EP CevxVhYH0PIBjw4J3sVwXnDuY1ZMp/bYQ/vhnlmULmAFzi8tRNgTUUWw/4qH lrRyTv9TiP8S/L9ad/9+4qF6+cAu3e0QARmrFrySpM+iCoBwUtHQswjJNPwb /g3/hv+P509r/lyUnPcILa+uq6frWrKKceBWMfgT91xWnPZwLkQpUDSFg+Xs m6DfBlfc6paO6SHjh/Uv8SXkt/BOL/m1ZLKPg2UQXzLcdya90VWzsuEEPWCi 4hxvii9p6G9FDItB1rdjpr6RI8wNQTqz8k9Gu4znnENXLUwNkwomAqhy1DVl gn4RMJW8L2nv2ope3crnmI0Y6so4t1w4Jh1uu/CMCcOEFZANCSWZbonu0E7+ dDljLMOdfeznIY2dECUsBhZZvKPw9Lt4DHeFer9smd1NlbKi3knH/jPRw117 Bj0xBCK4yCWH9YCSLQB7dUVtbmYp1yha454RLYmDgTMgEFb1eAH1d9oN/4Z/ w7/h/0P5i5o/R859TvvhvTK56xA1BB1WUW4likX7YyN6dczi9TjSHoZgQE0O mDzg8QHGXArkDyCeQhSm/PDSkH5y07RpDzI1AfcFGrRg1AlZsRhvJNghZUqg iPfbLFcjN/efYfs9BIt63R6qZCGGJpCe/F2wLxSlsFYAed4TsR0ct8sDWSJy CujEvqCaQeiMUGHF7zmIuajgRSbQYRcJNz5gVidzgrpihWoulqFUjHaihyZu K0Fhpg7xOYF+g3VFRDE+li1M/V3EELUhzhaAmjF4CKnCOR/fg6BZCnx+gCUK lEoRlxPjenEE9VdMwETj1j9MHKNl2DbynmbE15OLK4ej1E0PTdjlIcgxe9ht IM/rp5SGf8O/4d/w/9H8e3WchTgILwgKBY9LhsEF3l0si9tRdWpUfRzXd4mj cEfeZ+JAyEORfuPJNx5/Y8k3Fn/j8hD4x+zwVlQemTHvbvmNwIUYXDyPtUxR dMrFAbxYAi+IdCjxTfjhUOAuzOj/uO3apCS8g/flBZY/tPs8VTxRNC2JUALr FGDiCsitjkybpxNmPdChhBnUlGus6UidSCyLC9ouaAy/7wKfmPupyJ6d0J/H dcI0RF6GJRuKyZzLfYiVLPEURg3RnFaQoyXM3Sb27Lj5OAnXO8pzCdGWftfN fq+bKEgChD1+ljvJq9mof2LMvBlX92kGcw2LTVCM16wW8RLskpMxEhaYuh6E rDw6YV5+1+UCkH895zT8G/4N/4b/j+YvWAWQKfFk2vExI6asvO0FgV71CK9S 3rveKs7NFh+DYjUEnj6GVIUchtO94Lonl5y46JIrPh2u+OwhYQcp8CTuZOT3 ovJJZEP8XsvzO3520N85p8kpHZ/W7XP27o1C/AZxuUz5wS+huRr532eLJdTx GglBnBTRLRtcd+xqHl/fTwe9mFWY4PAyYX6KFKhrDcu9wAQCMh1IlAo6m5Mx Fd3MxXUVD+r4liLMUG7avBgI9dmw+BRYaD+EzAg+AlEy3Ce3O2L6q5xw/FfP xR9YQCHzhNvhID816z/f8cuhC6SOmZOQGNJe9KunU1pOaHkbnhAcZGrwfJJw PxKYU7/5D6FdITrEChF4zOiKKA9nSjrs+BDqeOPZgkJax6uE96ei4ufAPQ/8 M+w/xP0ylr7h3/Bv+Df8/wz+fnLETh1Vs0ccP+7FEZv8u5v/WS/dhOSrivnB hcj/Qso3pNhGXa5rRdXwNT15wsye8eyXgl8r5cVi/pLeGdF3aRnzbzeoO8uK p7R6wWzEy5DbG7fy8RuqNVCJsR4b7cuBaum6fTzZbTML8foi19d48Z6WG7QL kbRFyuGb3emTqnXW88uFuFC1T7nFk/naQJ5SLFgea+2fJsUG7b+NNAHywo5M 6PGzunXKkrOFPF/GZ/38Kb01oFLcZ7FXo+wSKd+RYhPio8xDoieuZ78d1a3j lp008pi/+5NdOGLnhy1jOuXmKjUXo+INKXci4IP1hlMDbuYn0/rJRsetOO7m fnILP5vFYaw0T7m9FukLpHhLyq1QR6xDqJ0a6k4dUbM/u+hUIU4V7WP+0RG7 es2lxCeyHCbFSeJ3WPUyyiL8Kq+YHAb+uuHf8G/4N/x/NH9WDC7mE8/V7NOC bvXkdpU8KxZemO0V6H8Vs/5FaX8R1Rvhd6UNWdVKeqNP7MxnE332/KMXH4q5 v7iFv9mlx0Us+wk7GKh1ti9E8SyGeN3jopjZ9JN/M3f+w5BPln+yd/9mHv1N z29htXKbFZcT90vsP8piVe5T7sO4HH3cnf5dBR883SvZXtF+6x++y5cWvswJ rOYei7+eF35d9t/InDBPmRtf0ePvzeynInpXiFdl+3358LPb2FYJ8ldX5f5l Xr0TxYaA8eo7Ug2td6dfmOBxwXYquYvjXXqithcgLps57n4R7pIoX4nysVDA J+Tu+kI++USHOyXd7LHNfrpbLT9TW4/yGHVi9gpTl1m5x6pt3qG8EwgztKQn nqnwacEeV+JJme6V91/qtcXOfchneX9Y+BPCP0Zd7lcS5STSg4uq4d/wb/g3 /H8of17zJ0qkNloxs880eaPiVzp5YtJVj+JbXrVZ/0rqLyblp7tuNfEhhRk5 QLHQ/YqslmyjEBtFslSJ5AAFV+wwoYcTSXm0bd/Oua2kDOk3wSoZOkEr+Ahd KsRSIR+WWDRNLOQvbeYGE3Nuzv2eFksxxK9CslLyityrgg1Lnjj+WMWrX/i9 Lom/Cvz2rzcZfz0T2520ep7mIbWSF7g5PmejZUu2NNtVyYaO76OTEoH4SPVQ Oz9zt/iY2CWZBwzyKS3SbriSB89y+krHL/L0cR6vOpb4CK4nxWCiz6TFu6Tc TLoB70rm+N0y2Patlzray+WbfG7PpOuOpDnj3YTq60l+Pi3fJX4jVSEqzYxo 22jVBk8V3bPiSZbsGrGS8XsdBuuZlNNS/dz2T+PqSfqlJbqJhP6Yhn/Dv+Hf 8P/h/LME5UyVQJ2tFZFlUclC3GuuN8F7Ke2PptW5Rf3XRZ2KHoqRcLPeiajH wx6PvsGLhd9YvXPN2KFkh7Oif3xBv1vRD2Wf0EN0KJKKkE7ScpwcoI43OmS0 h/vRXMXU34rN2UX9ad624Uqsm6go6wnoQ1CK0LGwTwLNaEeiVdGBZN9+S/Kz D/afz/t1HC+66qEegB6yCEZhGHEscpRgEQflTkLAjbPTi+r9vJ7jitZCKdxw Dw1v5QzeI8cDR8OCUYXuTMzeEvr0vPm04B7KjDB4SPCC9kTQY4FHeXDkaauk gWfsK+OdmJqZ1Jyat5+X1P3YEdRlFZwVIupz+EjYZ1HBghL6xlifMfQJCbk+ +kC9WDDrSTcSMN6i4d/wb/g3/P8U/uizRzUgxc1lYmRkUXCL++9wfU+yKmT9 4W29s2gJqQSvfVPRgNQK2aezfRn0ufj2/4tv8VPkcGTNr61Ba332XWHL+1Q6 kWg6q9KW5rIWcfHvVn6eUje+nq8va0K6nHdqMRUat3LpaFTwAKbPM/pVAmpU K8G9ekNrX1Y29ttkn1O0OeVwPYZmGLgXsxb9Y+GX3NXWrxmj+chatrai4Acs mhC6lmZp1PFGhtfOsZzhl2n1u6PMDG10dzc8/h6VVw6XBMdnBk5hcnVt6wev DvoWChPSfHhL7axoDr3ltaQZS1pKJipKPA9rDTD8F5eWr0tFzI01s7ajU9zB L1GX2/Bv+Df8G/4/nj9e6ak0SKPeyFgdVRJFRB7r77DUAmJxn7Yhw8I9aIam 0yWF+3ITsmrghnkyav/Fnx/UEtyK0z7DGYSYCB8v8RaABc8XKK6OZ48HdALT gWLXEkszWF0TJ7tAu7YzVUwoDqGQQrNmcMRujimGftr/lDUNVMnCtMae3XVE dCTfF7V1Klq2Sn1jwi7eyO5xE9UO2wyrP6A1zeNacEVzxjqo14L5opYINzak N8a7kYT/dvCmdZWEoJbNKQmrEXjS+mGDVQzIczs27FbHYWF8N/HWAkI8UZx0 aQp3xzWJqFFqCx8phOwNjpq14TyRuPNem34D1QqiOUkPxN2Sk3qRY0VJ/aeG f8O/4d/w//H8eSlEMcv0qXH1btI8oEVUF4VhaVh8INIeT/q1aLaHltEYjFwi ipGWOz/t/nLL3Yv6hH+fgkMe90R6wBP8CE0qLIjA6KalqO5E7ugt+27GroTl LCpXcy48Szyf0yItsfHUcRQ1VVRksbB3iDs9Zd5NZvdph8iizhMPuDzkyQEs BiYP4bMsdnX7ECINYeqnSf182m4GFvfNUVpghFQi6Qrgn1raNiSGEIzxXQo7 HdozE/bjRJaQLvpvsxznC24UaxGjxTdajksImrAw4O76DlWnJ/SHCXOXGoKN OEq7HAI9PFdIA7cQWH9R65ZR91vcicpjE+bdlJqPXFQX8WEoh/aTnpDfSFzC YLGchGMpYsO/4d/wb/j/Gfx76C/Ny9FAnWi593f8RqBCXkruJfXRdBXcdPQX m1xz8aiXv5aU9ij3qSivhO5yWH6a9aukCvk3yQ8E+RZNleENSy9bcdkmN3U8 bSC9Qp0qK0eJhfb3wmI3RD6xLAWpohkb3jDQvrzi2oN58itOfSR0ItxoZE4E /u1vfiswoTgU0H58SMN+NFnSISOGbDyu4t8MZSi1TbibJupI4J6R8lmUh3ho ghYA9tbfw4G/80tfk0squZ7FU4oRQO3g+mstfTGoPrT8SqiCumJackfuODKh 6JAW8JwwZuQstO9h9hNpRiN1MnAf7/g1YkIM04D0C5/Nw4mcjnSTUSWmvsYt mMoqosDHDwfuRMu/nvXbgQ6wHtBKiNGhjyYcHbLY/wktWwUTeFREw7/h3/Bv +P8Z/H1KvER/aXW+1hHt0n3CTUDd4HU9fVyHZzy9WMbni/ZJt3TKrI+ZGKaG HVwg5irpvSN+C6aJfwtIf3DATJ3QwVnPLpfiUpmeKR6dtNuDOmYqFe4GtWej 4jkrnjIdshJC0sCImTitgnOeXy75pbJ9ulg6atZvKskc3GKQ6vN4cfUyshE/ IPRgYsBNHjF3jnh6quCniuSYf3hMr17L2lEei2w00qhrJeVLkoVCE74/NLE/ cTELrhTsek9eq9LLxdJFvT7WjRnW4v3C9q+w/itSblMd8gyPnxvTUyd1eNyT s9/9t93Do3rtpm7TClbjAMnO0uI1KXdJ3mI+InZy7MvMSRWccOxsEZ/y6XE7 fzxfHbBCmJQX16g7T6rnrHpM8hD9QIpJGO8x3Trm6GmH1x9zj342Kzd0Shv+ Df+Gf8P/h/P/CfirtvQJL65LfY4Vb2S5LTsRzUNphx7r6c8mfO/5q0K8LdKP bumDWV1zaCXKeuelucZ774TfFJBffIvEwfCunfjdtt4X/EUl9qr0bbHwyW5s Q2hTKXPXpT0ni5eifCoxflFejG65ic9m9kNB8foyflc8/GA2NzV0Hscb5+dE +VxUzyTkVt8C0RtYMRPPTetpybbQDzzd8wtv9PqumZNYVTcsstPc78pqL4Z4 B0HfTKyryb+Y1mdPPxTio08/m0cfssU1JZhLWX496V6Ky9dxuRXD80YGKdXY mp54r1vvPH9Zspdl8gb9xje2sI5DMnNTqHMSdbnbrBMyHYl8bHl/ei9rva7o k554Cv0pF17bzdU8oa726zZnJKy36glXEW4G5YNL+eRL1XpV0CeVeNpLX5YL b9UW+p+7hn/Dv+Hf8P/R/N+ozQ0NobDN/HCsTyf+0z2/HHcihsoiCanQAxNt aLqj5JaJV524h2YUlB8k1F9p64vt6lPiVqUH/oL18fqH/dZ2QZ+7+IlN4CPz eFgb5F8ptUOxO5n4t2mxnbiA9ST6UfSjexZ1tk+1fKLjTR0veJZW0NuUdkcS ezJxr5NiJ/ERVvb1WXoQrLnWC0vemHTPyccmfthlePKmhnxqPFEnEv8yLR6j PzZ+7yeJZvDzguJruVhV4uE/RPwHZR14ukhhvlJ1JvUfUr+a1OfN4aFylj5w 4YYmjw1/rJPNLHmEX8ExPJ+uHEkz4PM2KVZkFhIlheJxRh92g21Fn3flCx3v 5umiIYmhIoMlNBIb6M+rtNhKVcAgA81FoqMFG+668Nl+/PRr+sSmS47GBw3/ hn/Dv+H/J/BfRv6U5zFzM0Kdf5R/XjBprCB4MZYJpjmxMkCbbhZaHla09o5m DL+am2ybM4vm84K+Kz3Fogz08RNRT4R9Hh3W0tMS/bch9IgiJvq2tMcfmU+L Zj4uIlrVVn6HHH5AC+uSkoqFvpb+lozrmHd/k71j8+rDvFlMgHCB/t4U2lcC bb09CzRr+SjqctKVLIfngd+kOvFIv1my84kitaqq3srXPFIwEVEEo8BNFiHw fDdJFVx/asW8X1R3eU6ZqsVacLHlqEN2hBQwZBYZUUt8BS1ux/rkvPmwpNqi C8Q4g5cWVPHAiEjzEHW8tZ85jDePubsVO/TrfgT9gfwOMly4O1xZ8ACwdCTp srAARECAsoZ/w7/h3/D/4fzDkpMKdUEcsgA9uplvL2m4dW2OqqGf+IM0rGUk sfWh867WtaK5dMSLoc18d9Uy6CqKdbHugAvc0OHUoeFqfUg9KmyxKgElUgMb +e6GkbTPeCV4rT5C378+JTBrJYtR2UtpJoiBIQiirm+YnU2VsB6tr2eivl5U jHogSeUXzv4huBJcw+0o1QPrXUhnBAUCDkW8qOOFAJrRFlDSTGrcrOc4NejX R4vRdbO8mrOoU5v7ofIWEcFlgLHlIfKisx/69aFUmBI9spGtryBGWJ8crsRH C6DU4RDoISLjz1WtTy6xqoL5qxt6e9MktCKoEPi+xV+gtJjkIjLIijvsfMO/ 4d/wb/j/WfwphlqsXEuUiB3+wL9As4JZLmyLq5Eb6vGYJbXEFEvwqBX4XtK2 F3GF8qRaZ/vdx5tJ3MhYGq4lrLjvYGtLVZiRksyVMoXoc1AfytOvjx6ohOzf GLdrgyrBQzwLKjRjf5dsH7uUajlXodF3XanBoJ8ws7I3POLWR7BgJMJOdhER rBZYIYnlqcXZr8soYFEBJSKymyNqZ1gJkdfc6nMcoFcQ6OOiJgwvDL4Eoyp+ W3hz1KwPQgzFCnHkzAscNTE0rqW8pBbfClMfu4Ay4MmR7tJIFstuPd7vFuUV LEvSdvKeR3PXegbxHApYuvHXofFsZQTbrxXChjX8G/4N/4b/j+Uv/8Vfc9GB ZnliUHQawyhULT2FIKsSXoyE5uKM/tuMTig6WjAKt7YCYqs0XPpaBFvVZ9Bg xJHMtIg5Pm7eTuT3CWpi5b/0q+jRAaEWFbPJIZXo403xK7uyRcujU2Zv0iyF LhKY3xHZjRO4DA+sZPIbSw6ZKBnNudiPObRfnJhS7yfMfciqZIeLjNdZFY8z DJ0xdAlr5QARBDghilskOzFjP0ybRyQjAsaF6FhsRJJhZQcsuQTeHRco5RI8 D6Ls2LR9M6WXiA+Fr+NvSWMvEsVjwxJNU1VLZ78f0OPusPzkjHo9rh9GWX2y T1mfqlBQiUczEFnAR/BQBoazif1n5vh0Du0/jHBfhtJOw7/h3/Bv+P8p/Bnr xEQFk1l0vUMuKXEpT6+pdELT0BH0x9NXQv1LVH6e9cuBafFSoE5VkTuaTWo2 ouWoTWYgNlUEz3F2ibRjoToxW7xr+bUwC/HEGRsnOSdFNFWRYSuHTTJWijsQ Z/sRL1NRjkfFsTv+1b90uT0IdjH35E4ZjVk66MSgTcadmHU0zpnoJfzbROSP BvZty2+EeSCwpFrKnIaKTOV0JOM382RUxb85WCoQNGNmh8P8dFi+Cf0mges9 Rr3IhJNq9oriF5W4nKc38vaEI6GJaqvtCdo5Fbi9oHjcAlZATEvig0kT3cjo L7n4JU8H8viWohRf0P5k1D0e+Jctvx12I+TTw+QuzOmvio4rNqrjacuJoujO ods8GwvM8Tv+dctvBt0QT6bLZaTChn/Dv+Hf8P+x/CM8lTIfHlJTZ014oaBX S3m1Si+VS5fM5lQe493VZdq5xqp3pFwjeRRpCFIjA3rmmImOFfSkj0/49hE3 /+9m6bqT1MfcXSf5eVLu0XKX4Hk0lOmpQTX1s75z1EanCn6yiI+6+aN69Yap dUrlADFnqH9Key8iyJV6RFQjQ2bymA6OOXbS81O+fcwt/GxXr5g0qoD/APGn Qr9Hq90oC7kmrDtxM5v+2QbHfHi6YGeL9ISfP2bXhnTCrOTmBsku0OolL3ZY HnHbovnQcD5x3gSXK36tElfL5FK5cNFsjORtZmJeDjF1lpdPaO85zKnQlKuB 8XzynCLnS3K5lJer9Hy5cFqvDmUp7SRCDZOvp0nxjFbPSCfihlA7MdK9fSwP fwJEVpz0czDen+3SNdz0SYS+QdQ5Uryg1WPeidjXFrFDDf+Gf8O/4f/D+RP2 dZbY8W116y8m/N3Tj4X44Oc+28XPen4tZyxLubkU6yuyeiPKNZkRmUF/BjfN 1BsT7BXRbo9u9JKdcuGp3l0xc8LClF2T6rwoXolyl+eE+4Cb64vdqSeKPC4I +l2X6Yti6Z3Z2NSp9AkrbkpzjvvHrNqTNmIHhPcG18zke9V66+mLkr8o4lf+ wZ7a3MjuySqm325yd4b7Pd57IiB/gZDaHVjLp16Y6GnJdiv5tJe8LJfe6fUN GKyLub0msou8fC2LHWkCDimenthS0x/z1idL33r5zs998vOfzeKOkdB/qkeE Oiv8Y1G9iFVY12VPbOSTfzGznxx5W8i3Pn3vHn0wy1u6HeNpy8Ny/4z0T3n1 nKuQZSHrDj36MvXMBM+gPz2+3YuflAsvzNZ6Pie6CawHAeMtXiXltswi9s9Q dMZ3kX/U8G/4N/wb/j+WfxB3YuboXUUWO3RVi9VuMo8WQxExnGdtZm+29bm2 fx+7lcQEos5HZBksZGRbBa8Uf6var3V727O7FdBOsW5CnY3d+7ZfT3SIWxtK 3HXhpgueG/pKy1em/cy2l9FwI8LzHfxobI+lqFN9ktqA9SF/kbKK5stws0uf 5uKpirc68aJhc45CvkYPRlJ/vO3eptV2CoPNIBnkbR2uZeHTnO4Z+TJPd7Jk XmPorOuyb8bmXFx8aJsV6QJaSgbZkGXxPoXxrmd8PRPzKo4VwW8L4Xozlajj bf9yrthJ84AC4W7CDG37cMXRbcU3c7nSje9ZgrszCq6fTOF69zwpHidZwGHR Kpbu0+X91uMueZGLvbz9wiTrhrUh/1IpU8NxfiZ2H+f8YpxF/GvMu/DQ0vBv +Df8G/4/nj+0z6N9QSyPOpIYRiwlBaUZx5KE/ZgXtxN1drH74aG9L9BJA6VN VDOax6FC8+rIibCkQa9WYbmYQf/zMw/174/sfekJN+hQRI0MStYq0Yw07LOg T6Me2vTV5ynfif3RefduUS0kRfQvHW8hooqHDt4pKVmAe+Wc4lHOkvZmRXVs Qb1fNA/iLKQqRiskK0IjUAdbMehM6BmppWLCJMxNJurcI/t5UcPjQVRvzRPc mu8I0kVz11Ch3gDNNDSsN+hPIO3JefVqST9MTMRqcRczeKRyAIOtSAQ30pxg O7UOzYZCH53XrxbsUqIi1CfAkHMe5TzsiFDJ0LKgR8Oy3rWH+OtmYH0uqE+P 9D1YAygGU5w0/Bv+Df+G/4/nr4E/kV1BDYtz8ptOI0NFwfFQ+6yW5vYYNUMb +caakRS6bWsFKRqN4v47K2rTVF37dRdoXsrzCBKuzfzpCgpcGfa/VpzyEl2m ofOkQgEt7lOUjFWIjvnrG2ZrQ0tyWOt4++j+Kjxu7pMeb6FKCj5CmeN0Hw1R Izew3F1b6QiKmxec5oLlaIiN7dt/+WkLW6tbC+TDvo5udLcWcxLmDL9PQ0kV 7tqLLgkzGWmOOls0zSCsk8ByIm5kRa+uw7Lx6OONvtxonc2EpyFMgeZJXjt+ 29qFFSY9u7mcQToZs5xCMMVSDsjavkjRpfRrTPJakKwoheecHFYXoXZ4U22t AZ/8u5iZiqzh3/Bv+Df8fzz/WhfkYpG1aDZ0Qz2dUBFcz/B7p+/1C5xq3PtO DSdYdFCfFOBZ7SY3MmGXhnUS15PCSgp9Y/9kpEPu23hOQ0SmvCMZWtgB5Ei6 iUG1OVYw2fteeYFu3nAvUtLUi3bBSZ+zA4riJbjLgYjLG2Nq/aZqM1gDJVqb SlgtFT4hSMVTWDOY7OCjQq3LpcKMj+iVcY124qTAug9oH1DQjKZfmMQ1VtuA wy9RsgULbHAs3xzTAvlj9UQou1jK3ap1XLJgxP+LgLAoMJbu5qjeGlRSKoKR F/6UI+ooY3FXtDNGIJh+5fQrNE74F5nsj4ztrw4bdAhnXyg8z8BahcFCuI/r qhbUOX9f/7bh3/Bv+Df8fzh/z+qShFhmw8H+hRn/tyndppZgvUNdrRaXPC1Z WrDEstTWftT1oQmQNUT58Unzakwvhj7CI2ZsJPI43mcxjAhPUuCywmN3IK5R 9KObiPz5CfP7hJ0jEEz7yBnGJQuewKvkccXSQxZ/q4/msTE/nCW9n6ftyymz EuQ4XgKTfsBkSRMjsA5Ck7TLhKl1tjqW/ldiT43r9+PqLsU6C4F1fwZY8USz +GtdOmHreAftdCXv3ib7J6ft+2nzINIRnijkYDbJnIrvap5iKQdLCirx8YAy m/DyDnNHZsxbWHKBDoSqiy8y6EmUdhLe4YmhiaIx6oEBjhT5LFfHp9XbKfWI ApnvTwVaxIYntpY6e6BKE1wPmLc2/Bv+Df+G/4/mX1DIdGiRMPtLYH8hvY8t txKhH5HkOdpW3CrIsOUDVgxqOabiWYVHJwsnhb5F948H7tls8WzWBrKSvCdh NqMsmtmnY1/4+B9z010RuQgyL67nRHEt8BfC4vOsX4l8hIcslzA08quLhi25 psXVPB3w8XRFSY/yIuWHY2F5rOWfBOWL0LQkhEKFthgzNhxU5HomrnSTgf34 Vl7XYmP/h8LsdKv4GPrlaD+gJo48HrUzq8h4l458lSMqnsZcCeIgYVkq1VCU nw38+7BcJ8DT4eY7dxH2J6NXlbiWx0NKzuScePSPEtU4Qd3vXlA+CVwA84JL S7Mgb03us+F9caOTDEN/9inLKM/bwo+G9njLvwv8ZmRbeLSoktGXaLIT3tDk kpaXVHpNJ5OGRvjtX8Jcw7/h3/Bv+P9g/hFxMZ5Kn19i+XXSf8eKDYY6oohm w0Nq+pgNTxTsTMHPFO0T7tERs3pZp1EhuRnn2Qnidmj/FdEEK5SryZt68qhq HTP0lGNn7N3jeuG4WhqHBATiV3Ex1Fej6j0tNqlDXRYth2+omWM6OOGj84W8 WKan3fxxszWg28zH/GCQ6jPU7/Dea6JDWkTMjUyqyfO6da5gl0t+uZeeK+dP 641BlVDUfd3k+XlavCHlGvvaEppSM3o9nz6mwhPQmUKcRh3s0gmzNA5JUzel 6lqY/0LLPVLuwHpjJmJ2dEhPnFHBOUsvluJ8FZ/yj06Z7SGdEpOwapC609Q/ odUegf4fwJDHxrPJk2r2pCfnSn6hTM7A9fn64Nc2yVNR3oT+k/IVLXZJFnCY 4nx4/Ov0ORVdKKIrlbjSa18oVi7rtSnV8G/4N/wb/n8C/0t6dVpJaSWzl6S6 JnvvRbEhuiHrEt4Z3VQTH2od7PNKPK7i59XD135zW92XaFU6xrunud1G3WkX kqkWtzeW1dQLEz4v2ZMef9ybe1msvNIbi5Cq+JiZ8zy/SXvv43JTFoSVgaiG dvTkBxO8Qb9r8bpM3xcLn836toFkJ2blkLRnuH8iey8SFXBI/czEmp3+pO98 duR9wd765L179Nms7uhE1DorkZ3nxTvov1REulZsBjezqTcuqDsvn1XJK7+8 p9cXupTjrv01kV3h1Z6odjie4BMxM7aeT7y3s29KHO/LMn1XLH4yq9s6FXnK imGpT0n3hPdeSchP4aHCjazYibe69d6T14XYK9vQ/9/tyq5JZDehvetcnePF nvTbohPALUQ2sd2Z+auZ/ezoBy8/urt/dUuf9KNVrGeXzDT8G/4N/4b/D+b/ cMXUvhnlzbv6Yrv8nLrFOA/ZvuBd3Dp5YFtbhjzL2AsVP9Vza4bPlQR1Vn4q zo/N2WdJ+TQ1AbGCGN424WoWPM7Is658nqc7KpnPiFCUuYS4K+38SlL8NfWL cRGyCvMvUUYPTbit6BMldkyybuP7ODWUQf5VTsTmWOrezBXbKcApOHeSolFG 9MhEq5qu6WTZJPchFOb192PVSJyfmfMfE7eMdQ0wIifaOlgrWi8M38vl0068 ncfzXYpVGxambCDNLsTlu6RckyoiWrAsFip8YMNNw56q+JlNtnT8AH1ZqXAp PF1If2zOPEvLZ6kP0T+8EtyTBypaz6Ndw59C/zPoD+WHETdtaodTezp1H1K3 npQBJF+4AZTR1NClLtuwbM3Jh/8UUuN2TMO/4d/wb/j/KfwpHmEsaTmT+LOr +sOCSlFDlXE8wsbWftdGhDmPahduFNyifgnyr0DaIw/V3rxdi3WAZq3/Mrvm AX5x992ym0ZoVYfxjurJVF9Y1n9dMJCboJ0dKxmtBLUCbcCh8YKHJa33zdHH jxaBMMeXzOtl/SjGHXwmCipQ7sWI5aGBjwhUQ1nUCdCcETcrzIkF9emBuR/n BH3wDG64hyUqfiPFQs1ahkYdwVTtg2Sn2/rUvP34QLfjLqMdWZ/LDI2LUEs0 065o6CieTIcWspJhf44+qMfbLkM0D/cwXkE8KpC/+4dHGvf92Tdsn+k7sjy5 ZD4uqXui9339MF5w7BKs1T6BXuGOT61AaPg3/Bv+Df8fzd8if/SR84QUgrix Db20CGP57izq6z8pVD3BfyN0rqv1V1Z8dzEl/sZKvr6Tx1hnnXOUHmWMGya6 cAsszRC10hVVuwpoEKbHttTWsqW0YrV9a63aMqjmCryAnsse+67jre/CqR9d tsvrGivmcN8cXf6YQBvtiBjRUjHKoiwVMMU5k04wP7Cmd/B4tbKWEKM/Ngq9 RAlk0FgbdcIomqU8k7DGqL+5YTaW/4D0k8hMsq8UdbNWSMUjLWBJ4KBgCHDr LrqFs4Pra2YD0jEUiR2geSx2wHFIJ0MnZysWH2D/0Vq2RAtuZkfX7OpKvcPF 9/FcBlZygXv67FcbR/36xIeituZr+Df8G/4N/x/MHxqvnaWxhsJAiCESBthB XStVgmqsL2AqkWZ4Rs3fVCn7//yrse4AYk3GEsNTiLk5EuDdun4NY/f4YHd9 HJhrDDHoU41fwWHNWoqCKxphhgX5S91JQ7kfHjJbwxbrMiDOos+25hT5UwHQ vhfHmZpAn/JCxv76tFoazO9Cs+L7EkKL19o/3MZtLK/Gcg88BAGWSj/gZvJG tj6licyBJNbN4bkJGdyC3LViDh4tiojvS9rF+8L6ifXoeLY62o0lZHYa9/1x HnucHNCkEOgfDoR7jFUcj36AWehfHUFdbsJRPCzYIa4ujM6wog4Y6nhNPYMZ r7PO35gau9l9Ou5DmUtEXR8V0fBv+Df8G/4/nj+GMC1Sh57SiWNpzhNNk4wJ mIIOoqP6+JTaHjcboY6QP5Dv4mkySQ6hCnqL/tIy/364gBSdqfCPC5Pm8y2d 4ow4DGo8x2Md4lJgAIXbeSHhBXG2jIW5ReypSftpyjygZYgZFp6bJtOCp56m Hv204bMpluNxHHJJWPnTbbMzaXaiPIB4h/or+KvjiRGyI2JV64QNryEkoj8S mcvj+i+TeKIQYq/rtTH2Say8IBySO/iNQx8MPHwhmyXq7LR5M60fhOZfeRzW Ax5wWYm45HGfJX0WVxQPj8hi0fuN9I7M2DdTZinoEvH9OcGKpMfTAzxRKC5I opj8WvuEQ3/0cNC9NGP/Y8rEzEfiD8G+oCV40vBv+Df8G/4/mr+EvIn4YMJE Azm9kqMOdkgltzVhjogsZuoOMz+3zGar2pvNQ0ypYCB/yKDbGld06KsczJLx TPyWUUy+IAblN4Ivl8Lyc8s9CjMCF1MIcF0ypaMRzW4aMaCTMZvegcgOUbhM hB8IzNmgfB+4tcC2aCGZiqkPpmxwXdHLWvyi2zfzZMTyliO0QD8QUvx7YDej 8vWsCnhRH47pott5NNSl1/eTG514JI/vWCqr7/s4V0N9KSr+1rIPiQt5B7JF kRhKNf3NsOmc3eqK2b/jpMSq9l/KJqLs7Kx7M1usRzqSSgodQ9IUFNG0pSOa D9p41MW/YueJMCmvRqPyeOD3Ir9NOwGak1eC9MPxIrhi2GUlL+n4xn468094 pIFHi0Tay6R7Jar+GroF6kJpYAXCA0DDv+Hf8G/4/2D+Ua2kGhjW0+dMdN6T S1V8sUpPF/PH3NoVPRehdHaGmmORXaUHbyM8pziECDv5x8SJbPaEJecKfr5o n3QLJ/XqiE4IVsldI/k1Vr4jfgV3OkyLmqHB/PZZTc96cr4UZ6s2tH/Kro2Y GPcp3BWqLtHqDepyNRE+IHbohp4+bYKLBblSyStVfKl4cN5sD6t7uBvSm2Tu OHOrvP+G5ujvLczItB47p4PTBbtYifNlesKvHNVrA1Zi3UR5kehrvPxE/Bop AmlI1Jm+kt/+Wbd+svS4kadtcqI7f6b7aNhA4pYKd5OpC+gfXu1ifxxlfmw4 nzmiW0c8QT/wIj7uHx4xGzdgvDYRvRvEnybFc1I+JRnhmtDqJup4dXixZFdL fqVMLpZLF/OdiVzyIuG988zcYOVH4laIhecZGO/AkGr4N/wb/g3/H8yfcNuK 7PiOnv5dz35w33Wk8dviwVu9tqPuSZ0wNxWrY9Ku8f5bqRk3ROixNTv+1rTe FexlKV+V6Qc3/04vr2aQlMVMX5XZFVG9E36N64iaSOrRXT392d55W9AXpdgr kj2/+EavrRlBfUzN1Ti7LMrXstziecRcIMuxXX3row7fe/K2iN/79LN79Bez 8sQkcT/m1ZTwR4Vbpr33VEVojpRPLnXGPuR3Pjj2quCvS/jI/AeztQbBsUzY 4UVpr/PyLS23qI3Q7u/rwEo2s+OizYouH4jlg3Sjt7hltuaxaDqOOoMiuyDK l7zaRWWXDqkbWs4mXuvgRUEfV2K3lzwvF9+ZzU3Vjr0gepB0L7DyeVI8i20o DOF+ZNtN/W5aHz19Xco35dxnt/C7WVj+p2AKunRe6Buiei/8Ojchs0Tm47sN /4Z/w7/h/2fwj5WEVGvOhWuGPM7Eroq3tJjHvRXIDhJufuPupzmzkVSv2llI c0mdFJ48tMF6Rrc6cuMPuazEXbivjniW0GywnV1ol5/abl52Q6Zj6gTT0V3X WrEcWt7IxYpOH8DFnoiijf7Y6rz0n+eKpVSFVEtWclaQu4quKraZy7VcLljR LhjFLY+Y9X6VxU9tu5b23tzNw1q/JMhXlnSi5X262xE7nXhDxQsVTer8ix5c bZuLSfEp8WuJC1gluKUPsmBXtfby6K2Sb/P2syxZy0RbR0wl8dfx+jyFd2m1 mexHvCu4i+MsXHSt7Zy+zMVe1n6Wp0sO1i0NMD8dm+ueTdy71G8mRcArgBnz XnSvIOsF2bHxtk2WHfSfsK+M5e3IXUnV1aT4fc4txDrEE45wE7/h3/Bv+Df8 /wz+hlHHSYFS1ahkUckDg2batOD4nnNujj6ym0t6q43xVLCMUyUizULLCXw2 p6FlFEVZROAex22RX1hU7xcgdtdmp9+tjUhZa3cLFhai1qnirjqej2MmY3N+ 0fy+oCF2U1rvmyBVg2bdkUK5b4QVIrWPax/3tUX587zZWjbbKfQfnVohBWM0 E9FXESlKch56FvXRso/5hFSTqT+9oP/6yNyXuHeDvlLEie9OqtB5kqFIOMrQ VJwb4DkT56cems+P/MME7fhwc58Y3vI8zGWg0Qwc+IQOdcVxN2X5LZmfmNef FvQD6SM8adqhBIsc8vAQ5biBY4EHApQrQrttYsZj+8uy+X3ewEwhN2YZHgnR 8G/4N/wb/n8Kfw00UOlEaims0Bik0HcOPvU1ib4O3+/Mb3bv8no/WuS1ZWiO ttUhHnxABW7Ho9Mp70JThHVm1vaXFy3FNk19BIOtdaeORoWAHqKpteZ4tD3c 3QTUjG3m6wt5FHVr079cMsMYyn1pkMsInY5wh722foUpiMnB0IJ9uJvPoZi2 QD9AaJwbITNONA8L3KnnFfrEcishyrPq+pZ6gn7X7ruomOFHUNOLuzBIWAmU CnQBqYCci6sb6/mTNVhUWa1DthFe7EVsGM9QMYXtd2tH7gpuTZi7sZ49XoV0 skcF3pejrrjPxWEES5rgCQ44WWyfoqC3iKif2NDr85bA0HB9Gjyyp+Hf8G/4 N/x/NP/aZxXd4UyM/tJmZSC7K/HczPp8AcckoMip/IdMulj4hofRdDiEYMgm hBoc0tvD0B9VH1KQM7gF/YeAbkscHR7NgIcmmPqQhSKSbmTMrI/DxNXmpYi0 AAIArZZ75Yx2BVO1OTYWekQiHxrSO2MG/bFRf6sFCnQPKR70Y2lsBIEF42BC OS0g1YIsaWi6s3wT5gWmo8c5lkigxJeUZM7LuYIhClVPIqwNGGM2PZotTXVp nHPxRfD9elK6kqjwbh63ISJ/X2m6PnUIplKPTuRrIzmLujLsYOUFVtX1oA/k rpVtJ0hVnx8B7RcSOIveyIDemMRDnCVaTgHATKL7ayES3NnhIYR7PMGhPtWi 4d/wb/g3/H84f2Eowa3qFslPT2Z7k261pVoUgyPWI0CshPAXWxF3WAoToQA7 5Trm+jbVJ2fMhxl9L8J99lrXmvGkK9N9EWsG0SqBDMWh4Jb7hBe3iD4zbd7P 6LsQozEpg484DPqyPisHJlrmdejPGNZ3u6lIn5myn6fMfQKZXV4X/WFsFann 7YqlHl+JZRI4aIELoHPslno8pjZaPhDf6jqIPpcwWOh8SeOKIefafxuTOD1L /zg/nr8bz1OsyMD4i9UWYl+iU7djqcL+C4+VJhiXfUC7Z6byVxPmHvsi4m5d J2iFKHnSExLaL3gMYf17VZ1NxeF4WJ2f0J+mdYzlJJAYwqizVDiRVDSG9eNo 20mBJ7hRYhr+Df+Gf8P/x/OHiwkzKbOTwJ+YZ2Fvt9UNaoclTKlmdTCekcGv 4lonvvk1mcx5YAi1ba6GQ326VXwI/RLpRCwXeEhlHk3vh4Nf2fUv6fVOMpQn v9Y63vpc41GiT0f+Y+CWIh0KnHFIjqJZG0woMar4qE5m9kWAOQ5EvUTYm0F+ Piret4q1KIvQD9xKVpFfbTRkyFXHr9j4pk4nHY9KyI+EsLNU/RTYjVbx+o4O +TfB+5L1aaukk44MWT5ok4l9GXgCaSCzicgHQnX2Tvl+1ixH3YjjN4cwKYzs 02lNh40cMvGUgv4QoWC80NWJSJ9q2beB34ScER05KkwMIxdNOzqeiTEnbzsR 9aLYU160+eGVlrvU8n8N/QMGeWtXYN6asTt5NOiiGzq+YeIxncxCftrwb/g3 /Bv+fxp/QWs/1Uido36L9l/QboiHr6mp6XzivJ497aNLpbjUk5fK+QtmcyyP I98m5jrtXqTVW1qukg4QDqkeHs4mL6LulN9A3Wx6vlg8o9dGdIzjdQORPUeL 11FR1/FBJ/XokJo5aoLTnp4rxbkiOeWWzqjlqQxCbSz0ZaquRL3XpNymnQi/ +vPDw27ilA7O1DreC2Vytnxwwq9fNvdmjWQGdcLULbPee6YI+0bY4ciInT5m gqMuOunEad8+5paOqqUB6I+D9q+Qzi+sekXLDdIlrEPo/uSAmT6iW0ctxeuL uWN2/mS2OLIPfOAjQ9SeJ/4lqXaDLOSoy50cyqeO6OCIJcedOObmfnLzP9ul QRuzKuGH5yJ7nVYfI7dEYb11o7A7ekPfPmlbZzy7WIrL5dw5v3hKrY7A0oL+ N/wb/g3/hv+P5X9arULg44qzfFxkZ0SxzfvPeSeiXyFYTDzMJ17ms28NfV2K 10X7rXn0MV/ahIysagt1U+QXZPlOlGsiA/5EdGe2/zn9Sbc+GNTxviqS9/7R e72yhv7YMfU3uLkgyhe83OEqqoPyzRU19UJHTyu625O7VXvPr77WK0t4tHEc 2V94dpX33shyGzrPDKVqdC2f/GhbHzx5U4pXpXxXPPho15/ruTlAam4LfVTa Ndl7G0PE7BPeG1lV42+z4JWnL0r5okzfFgtvzNpynkL+yPz1eP+SKF/JYhO/ b9yPxJehlc70KxXtoU6YPa3ar4v512ZtVcUyj7kdkuq8LJ6x6omA9eYjlg0u ZxMv0W+c7pbscZk+90svzNaKTnkVs8Nz0twQvffcrQgdCN9KuiMb+7dfWQL9 eVnKl1Xytlx8a5ZXULTc8G/4N/wb/j+a/zuztIzfnkmmp2XnVFrsJuVukmM+ wg1aZ6SazBu+kbP1rlx0og3oNOQvMemMxfpMu/iYuqXUhHiCPFpYk3ZOFv9B N5TYyuJVze9bUldhtJkZjfXpdvE6KTekajFUH/HEBQs23FbsaS5383QtS+7m BKv2VCr1jfb+L3H5oV2sSripEXiYpiX3TbRqyI4Sj43ctvFygQYX+H2gmxX+ 3+fMZly+TLOQOcGcZJ3ofhZtZuQJXJ/L9Vw+zNEwhGNdyUCizib+U9stwnhZ JkVHpp1wKSdbHfI4F086yWYmHxkaQwqZw/yOJ/pk4veS4nFiof8JLNrEhSs2 fJrTl5l43k2fqnTFsxSnPmWHl9ruSlL+3nYPsCgPemhJqqIFTVcztqP4jk5W jbhXn2SKVdum4f//sveezW0k2bruP7x7umUpqeUNPUFShqhKnwVQhgQ9JYry 3nRPzz4/5X64J+6cPa6NRBJAVZpyALVP3LVKc89PUH+pCMZED1SoynwyI1Yt 5LveVfOv+df8vyn/2/lX01HBskBlx1f8k5V0VRtK+4I6xvBUXbNUUkdCI0KH HeQFhJ5E8f0FmY+s+vfLZvHreYrIUZ3FPKeJJAbVuUFBaUZZJrE/WnpL5UdX 0tfLfkmgKItLS1guwhxCLWexIJ5Wvq9S4ImPotlMlJxaSf+ynC0qIPC1D3LK Q6+DVKIod8jDStOLR9gFZzk85ciK3Vrzj1o+QAfUyveVoW4W/niYVjpbmEJl Ksh8Q/uTq6ibjWCnodQqEcxx6nmYCGIZWnbnPHTom8GNZv6mzr9fTd90/JqG /ZYJmQp4KLES5b454BJBycLKBpAdRuxwtDU4t+J/XrFcJnjOgkowGGcqccol CQvZHHBaojoLXWpr/jX/mn/N/5vzR/GtF7RQtBjrxGsbsRaeyZShz6qRykpl CIHx50I5yS2HRRF9dFul2fSmWYN0CWgDOgYhO66ss42gPeCJpnzMUYU+2EiD 5tc23Po6LChCY5XvqFBeqWr6aJftcFIojsohJMEqjz7wu2seVp9XTSJQhaWc UNXjmjn6teJ5Okq5mMghpE7cy+4+crclviEIFF+VqPvVOYMtEaJxtxRWoB4A TQUp8VP33fpKjMylrUzCMTRzLKzzcD22n8CBobss7EPFi9FNt37ftFglHsP7 o50gV7g/cQkkLDpsEi9ZAvndLTaceWgfLJsAHasKSdFXlsHTVaFCXAsUNsjK 8RWbStT8a/41/5r/N+bvUHwrcyoG2DEBZhdlkkDmBVHDKwmQ8Sjk2nSyMe5b 0lV1BB6dsauUgcuqSoI5xruK9ySgAIDajU6ajTGD7ey5V6i/dSjxYp5ox9uZ quy+IWjSqkUOg9RvzK7PeYpisLSK41gKJ1hC2l5ouAPKn7AFD54KedgP12bd yiV3l+ek6uBQdUnIUIsrCtH6wojHw3RWVqV8qLa6Mu7vj5kqHCdVaQksqEFh FSyl6kv8EPvyVJvHERlfG3UPxz3VrjIbTCq9sRO0RKPsyErmvjqK86/3V25s 3GyOJ0oVaKYtINo6XrUQoouYNsLAcPNgkUUONEKZz1x1W9NoPI4M+VcUNf+a f82/5v9N+WMw5QCkIBJGnomoFNFAtCzTDjlTr2VGWO/IjHs1l65RTwSWwqHk VQFJQJ1ybbGhjIbo2a36L/gArp+zr2fyFZIFENcg/4IApzKlc3TJRumpl1Xc B+CRymZDe3Yy/anhZGV2jfUOwAHvGWNBRJTxqApSWKqGR/OQDf1p1j+cSR8u uFBi82gmSqZSIV2kS67+m7aMgK9U8xXMNsPk+0b2bsbdIwlTcdXxxyuUB8Pg jYBPIsOjRMBmQz1tOkvi43Ppx5lsiSSo+8JN5ZTOZHsg2ujyXUlzsfUDrKyS w1s0+77h3s+4JVYS1OtatITVAx4NGFCF+UZFdXHKpG2JdCpMzzbg/mkLO58O quKUvOZf86/51/y/PX8Uo/KShi5sJHzMq4lUTTl5w6P1kIoXtZkMzdGF4jUp HxLfFIWGlIf2UWd71fFLVl1y0SRcjyXMVCSRPJjj/e9J9qI52A1sIJyMUhXB VzJ2w1OAPO3UPIT4HJY4rM5NroTufDj8uZkvwTUCYqiVOiWBp7MJm3RqwugZ IwOLP77xvhbx9TD+/mb2gA5fB3CHIayvYmVwMwsnYnbBynMwJN8at3KhIDyF 66dJciQoX4fFA5IEAkMzg4Ubi4MfEnrKqtNJ61zSGu/BIzj25UxHSXIiLN8G g+2wG2JpecZDx6YMuejpGSvP2tYF256yIihpVVcyGaZHm/mHsNgOfQgZHzeK GNqw5KqjVx3ymXDqVkowubMw38tNmO/gXZAvM0MZtrGDZI3Cd2v+Nf+af83/ W/MvG1NZ47hrnijYqVKNlPpYsTTiNyfitoTxp9dYfJoNXtLhE+YCnjBmR6f6 s6fT8Ac0l1bnBu2TxfKJbGvMtKiJhB1n7hgtH/HhU+IoJDjcT01mc0fT4D9S eqzkR8vWn/LlP6Ub1zDf0aI4y91lOvzIitWqM3JI3NR5P/cfaXikIMcLebxY /D7rfOdWrzlNe1rYSeGOs+K+OHzH0xDTKz8x7aZO+ObJkp4biHNDdWawdCbf nbBt6rQwV7k5CePng0cMdki6wO3laTtzMaOXh2L0ixg/jK4M1y+nDxumhTqo 9ApPTsvBKz58JJIQpWL+WsPOnHfB+UJcGsiLQ312sHLa74zbRZprkV1h7iQd vKblLkEdWpMnY2Px7IinJ0vgKc8M2ieKzREHCaaoui2cZf4qPXxNiw0G+xPP rRqTNf+af82/5v8H8Ifka2o9mXntK51qKZ4Pbr8p7r1zW9u2DdGTluORO9kq n4hyl9kQTVP9zP2s8dE1P5Tk1UC9Gui3Reed37yfRjJRIp1U8QmZP+JfXkgc PGF+fMVPPUuDpyV/MBS7h9GTwerz7OGa1wz4+HPSXZbDH2W2qhxjxS3lrt23 cy88eTTgu1/k4y/62WD1Vba94Vo61jyelP6oLHbF4StlCYe4nE2s+cZ71/wp R13um0H7x3z1z9nKfbg5LFk+ruxxVb6S5SPlCMuoShu7fu4vNvzZ8x8z+TFr /+zv/Rgvb1rFS8WzazoZ0eVzMXgsTZNhnjW/bed+tgv/IyM/FfLHov1zvvyf 6dojr/UgQv9Yf0LD/QdPVArxN5Bm+qGf/SltfizY21K9KRc/5hvv3coq/tQG 0f+cdpfk8E3lT04hO1PZZM2/5l/zr/n/Ifw1Jh3hnZRs9PiDRD600aaRdw2V BWN5i7lZ7Y9ExYtWtt3yhA/wKJnlJIpJJ+YPUrmT63Wr7liKR/PdiJfzsv99 O30aDZ9GaYB6Ksi/MrJqg92EPjfqhdVPfbTpWCuDpYyYv6TdBTX4y2J6VxqC hxGOLabBhg2e9NgLo57Grd1+a93SCE+FIJ7OyeRIK30cDR9HvZAbyWMlPV30 bNWE24naTKIVbCdK8ZQcliCb1cn3rfzDnXwDMj5eicFIxkWP3+6xlYR3+vJ2 wrlh1FX+q+mMtt8v5u8Wi6123BTwRuEV/pNldz3bSMVmqlecbOWMDpgoI55O 6/S72/m7VrkTZQEfCIWl6KxtCYx5y8ntOFqFjDJjtAx5GpH0cuTPtwYfF4uO zigvBTYVymr+Nf+af83/D+GP/RdYrlBxmkrUzXpODfrUKa8gB9HpkdX0/aq7 G6WUY78zGC26ybHfItSplqjdQn9pz0WsqAeqf+r4Z0v5VpRjfwTUqWaUeBlU 94e5NzMepKi/4ui5Pd7yF5fSn5cg0jnGq6MW5kXoBNnnLGH0q+s18pF4EJ+G yhy5Z54tp+utfkisEnGl5kpFsCeahqMFayZpij5I6BboF2RyYt2/XXVtabHb sqj0V7BwLBEUrj+QDPuEoukrWi2lgfQnNv2bLX8b3h9w8B5VZ/AVOpDAnKHo V6J5+CG6/GFDuvT7Nf9m3d5F3RdKGvCoHYbRrMzDYe3QqDyTMqfoE+JnW+m5 9fT9Mqx1iSf4shQ1/5p/zb/m/wfwBz4lhCRsNCk9D40kVsgCBiYrHyTU3zI3 uplubjjBBgw7IxQM3epSinJc1J1KdMCDYI3xDmbdptnlNbf+0LVFisNGy24P F6NOFc9QPEeTPQx2eB7Bk1vKTO6a3WULyREe6wN/arFbfWVYynkC6yIwzwJi fcliEaZX1/qb922Lx0xU5+nMSgEBuhfSvm6mEAEZ60rqKmlxJkI/s2ZX1o2m KW4SlE7B1GKp9sObSSvoCYnOewr+icWAGljNrbm7qCvG5A72j5QWZ6HKsJnr uUzorDL3PkSRlfKwFpMbfnUDVhPieMpgMBwCcV+pnlhIFYNFxPJwXBeK3asp z6a37foybPIBmnhzrBxBXW7Nv+Zf86/5f1v+2CVBoEqKKzfRMJuTscZYYHDk GO+spJ6pAi1VQ5ypwvoIj/FaFZPTZnU8a6mcoi4XQjBWQ2iIVsqLNsq3gD9M AYIyZjfSNxqmM5FICWOIUcKKai4nwpjddlqnGHZFSqp+QJCFEWnnx836XMJx sWLGewqtWRPJLIt66rbB7jmo18o4LBbeMB6bN2vT8aJIiD6QEi2yq9JC87WW HKsk8Pc02ADwT3tN3r92zT6bMoz3Ba5XgvwpBmWszqCJhKQMR5JVpXNokX16 Kt25YpfQTBsi7xcG2RMtsFeRxKoQrOCrdhfGcRkvKDtx1T6atlSnld4Y4ztH nbDnKMrCVhQcQjDqymr+Nf+af83/D+KPVQY+YP7o9ezVTLoSmoAXCm4OoQdi TeSFLrjOWSvjLeybg3UTIg9YdqyRvp7OVmke/JtDwaIY4o7UCdpcKDwcpwyz D/gjwh1v+JfT9h6DnMVhXRuWZliprVSwxDkqZiETYdiVTKMO1l6Y9u8bqawq oDGfgk0inFKJ0F0IsrDKQB5bKjCYoAn5wck5+2TOrdCECkPxEThxpR3MgutE oG72q0+4k/JgOjj44Ub+8YZt8wOiepR9jmSPteGVo4sdeVQsVExh7iqTDAso AuL/r/ns2fVsp+lDfEnIsOhbGxWhDllomEIfKOGmQj+TfCIwZ+eyv1x3EIIl +tMWROJIWJTLKCNRhv7hKufVJqz51/xr/jX/b8+fQbSFFEz6eeaPhMWzYLAT xqEulEw0s/yGJ5OWXPbqchZNpPoGXlz5XZcN6o6GBepsm2mAulM0zaZBzK9/ 5lOxnDCqga0qiUKLJCXK6zQ7EuSvmvkWsQGW2gFGQGfpfJ9POtnwagHrvonG euRI+ivEngsGP97KlyjEQcj4HNa1sR693udTB2IyiRpOBAkWAMpccdugyZGF /EWzfEBMwCw22RQ+vJHQUcPOOXXOti77aBodPDBFEvFV+vkSGbynvsN6EPRF 5PjN/sIVT87vsdN9cTpunza3Lxt5E/tjauEb3H1P8l0yfN5EXZZUKW6qySS8 YOiIE6dM+0K3NWlFE5tpRjK9SM0FVv4nSW+zBPI+xVIZ+KDhg8tGnLfivG9f 9aqRcjJA1XHNv+Zf86/5/wH8yzbFlpdTLBnh+UN2+JwaNNmT2cRUMnPMkyMF HxmKkWHrWNE5mm5ddRGDrKScFP44Kx6x4Qtq0e+IZdNTZuaYC48U7Hghj5Xt 71Bnu3ol1SG67c2I9Bgpn9Fyl9oQTflsY9TNfuea32f8eK6P5rf/lK4c9/ca +OucFvYCtRfZ8F2lUyXKUGobY3b+O7vwXUaPl/JEEX1fLB/161etIkby3jjt nqSDR7TYpb2mhCUzExO2MeKDM0N66Yu6eBidGaz+kD+YwZI6Jdx50b/CDt+z Yk10KbcL1F9u+NnRnI4fsokvcuaLnPjSuZY/mbWL0ilhZ6Q5IsptNnxJE8Zy RvMrDTd1KQ0uDtiVL/LqYXRxuHbe78yayt81O8uTK2zwkeTLYQJJ2U3mx0bt 7EhOzg35xUN1eaguFJ1z6ea0rfj76Zp/zb/mX/P/ZvwvFisV/0g7zc1MFJ+Q xUM1fI5Nk9FMb3rNTP/omx8K9hx1ue23ZedDtvXAa4WW2pPKnpD5rvrynEO+ ljFezqz7yXf+1quCPx3yZwP1orz3zN9fNy3uWzyf4PaYKJ6L8pH0lKeBdFfW 7OyTlD0d0N0hf3jYfjTY2Ek37zhF8haF8Ztr/MtbVW6JhEofKD+67hrP0vDJ QDwayieHrVdl51W6tm7aoqd4d0LsneHlYwVT2A8FLJmd2HZzHzLyNhdvSvmm uP1jvvTera3GUlrgeU70r4kv71S6ynshg2wxndtN5n6ywV8y9lOu3uf6p2z5 P/3aLpaEaxo3pPlOF9ti+EzGhKKb3/XVdPZHv/DnnHzM5XvU5Xb+kq7ed0Il ihUXhLmohj/KoqNiyDQD7SYfmfk/p+RDzt4V8nXZepcv/ejvbdvK37vmX/Ov +df8vyn/ZeC/Zbg0WiTzyhxppU/V4HFkA4a6o0h4dicN7jv62Mmnqbqf6rYR KLUqNHMNnX3XKp5Fg53IYHGxLCJIze645laXPe7KR4nc9WrDh20n8f7prDBH 2uhfvaN9iP7bGV9Mg01DdhP61MvntvU4VRt5GGVMpG2eXWzHl/Xwo85XlKXo UJqqKA3XDHls6NNEPTWLDxO+ZLh2FOI1SxqtvZHF7E2r2FQ2ZBAxkTO5Z/ma Fdv4pzuOtuFDzOYUSy63+1dagw8td1f0KcfKQRR9KU+X0nDZ8E5X3rFoRUjg /ri+TWa+W8wetMonLdukDoK4RitCR+8aumLUSqKXjFI5YyX2J5XZlXb/XFT+ vJjfxY6lTmJTUUcWHV1N6IZnGz5aTpVylQ+h0dLU/Gv+Nf+a/7fkrxU2lxQ8 kTwPhDm27J6vp6vahrzy3+O5IE4EmSQFryyjmYwjdO1LIV8IZP5dx79cydZa eBzPRFnpZlO4WJIcpVNBQUO0pEPjO5rTyB/tuFeddEk6SmLFE86cDBMRxmj9 RzPeTHnTA0ymXMT9TNueWc9/Wk4Xq/4+XOSSekFQ1yqJEZAEBZaEsWIGD2WE WZDm+LJ7s5LdxY4GHnVcHH/f49QrkgBGRlCOK7EqEOv4ptrJxXX/cRmPWrh0 6EOu4D6QWBUQEBksCjqH9+BKIT18BbLC40v51kq6KeMQ9iea6WWoQMPzeiNI ihavKFrIBbcRi+F95tx6+uMyercCMV75b1QW35axrLLpLmT1IYoKeFbzr/nX /Gv+35g/hAYIRryyGB1bsxtbXrJcVocacLFCXRbALHiYcQHXY8kYp0kLaQyu bfqN+05z+DzFz+WAy0wqi96nzZhKeJDF825mpSxhUcZWDFwvYZAanhhzkXC0 +O6jLIqkTGGTGi66QiQMNgDPxu+7B6twpYXBQAqj0N0UKKEhqqQ9Bl+XcSWO NfAI2Crj625jzQI0VVl5cNkXwjDZleRAVNpgWA7BAGwP60p4MrtltpYMBXry q9Vqim6EasiCTASWacOVQQtu6qqQbSfv+aX7rg0RH0VW2HIIyVe/DUrYeBxP XhhsEgoXw239LOpsTYjtlVFCXEnOcBVImAmC7rWV/SyMKqmsZWv+Nf+af83/ 2/FXLCU4Tg8DQGM69N/2ChWhwDNj2qnKOHpyynVGE4WBBsWxaNPNS0EKmKOC dAmDkUUxkhgwnrZUcm027VxJ2jCGytcaQhXEX04z7J4QGUr2NcX+nlz0uQSG 3cnR/vZ8JXbCSrcYohjwh6WvBmAlTSn12LkG/bEhkCUTE2ZtMubqgPMeDJ5i 3QQsiiXaKwXvEj2JLxUZZ4kWhqiD2dHeesOgR6swQvSF7MPqU3og5AFcwCkE 8X71laRyW/3vK2Pu4RhE6qSqKIEbYoEGxwKTRLcsvAzgppWFhM2GJSr90YZZ n7Ba4jghxAsBn6PNOIvgTQBt/SDoY6kdmsdi76Gxcbc1jbmeRNQG5bs1/5p/ zb/m/235Ixlu2L+r5ND4lOlSRjlXGdZlVzrbW9QdbaSPZ80yhsW0qr9Ayw7e znnLotMFfAtiLoYkDNCCx0dn/f0Zv9XsB3xPwTThuapUKpUR8C/CO7FoYTrD JMzXzQb27IxH/20GQAB+BSryUg+x+q8F44SMyUi0ToWUx98MkpEZ/6bh7rIe Sl65DdElI5aRIdoqbaQ0qNeFVwvea8u0QZNzM+btfKwxj/taJJjwyLNWIqKu inoigqXsfW2y0FLZHCmPzKbv5rJ7QUxgPLRfDRWGAfvBKgmrjLXSiE7kCnhS c3TOvWj4JeK/+ntwPN8vFNZcZKKV4K7GTZgKyARFNs/86Zn07axr06pSA19C av41/5p/zf/b83fIHzIIYulczEeNHPPRVKpvYXeYUKToL0Tt8Wb5OszWmQmx zVmKfW1uejLuyGUrLqZizEQ3upxi/Z2S+S0Wfx/6bTJ8RpJA9SUERObJ9ax5 rScu9PRZ27pk9IwXIdCwSnSvhfG5cPihmS6TPqlWXIQDcj1hU5aNxXKsp6f7 IuhiyoMtlYvp0JwJ8jdBsRXYgCVY9QYxumnYTEInbTST6Fn8wY0oyNS6Leku Ns35oPwphPWC8aNyADvKwfhnEj5p1CRcD7kbZIuwu9wiT0eb7mRQvAwG90nS FJgntkVMqCVznk04Pe7UVIJeItgSCH+HnCf2yK38JSlQV4w7MAXyrOnZtONj To/GYtYoCkuJrYvaLL0a2NPh4O1CsR5aJgwkcVzZmn/Nv+Zf8/+2/B3wV9I3 Ju3MUX/rWEZPDuSJAepa/5RvXPARdTDaUeFPssErOnhIbaggqLnxcT83ki6c LNiZgfxhGJ0aLI/4zfGkTSFFyua4O8ayDfHlNUuAJ+PZ9LyZvGAXzpfi2oBf GbQvlisX/dbsQYTWeea8cBf54VtWrPMDJvpNmkyM2xs/OHY6h/uLH8r2qWz1 rFlpxJCLaVVeFf4sHzynwx0Sh5jEJVMzydzJNDhWspGBPlm2vy9Wjro12Ei8 r4Q7S91lPvyRFGvUEJkGoR8/a+f/I6PHcnayVMfLxSNF55hbmcR1bPH0Indn 2OApG+zSXsAc1/GN2XjmpGseL+iZQpwuWyfypSPp6mXfIllb+glqR2jxnA0e cBNKeDnJpsb8/HEfHCvoSKlOlre/zzvH3eokpmaRcJdYfJ4NX7Dhfawf95ym jQng724dy2v+Nf+af83/m/HHoEbSiY6Zfuabz0r+ZCifHaqX5cqb7MEj34qc FvmYjE+K8oUaPFJJID2h6dS2m33lmm8L9rqUL8vobXn3jVvfSloCSxtmpT0q 8y355ZXsErSw8DeW4tl39tafM/GhkB+LxZ/zuz9mS1tWiK5m/lJkz6vBB1Ws 6x7h/VD25ra68+/ihXcFf1XI14Pb74vOa7e0BsHaaZ6Nan9Glc/k8KHqB1Wq Nb3aa7w0C68K9mzAnw1Ql/sy3V6xLZFo7s8qc1kefhDFhugTnt7U/spDe/1l Rh4fst1DtXu4+LRce+7WOweaJ23uLkl7Wg6eysMduY86BJFMLpvJJz54UrIH h+rhoXo8XHqWb236OyrVLJ0QdkSWz/lwV9hAlgs6H1+1c4/T4AmajaunX6IX g7WnfrODFn8t4S7r3jk5eCkGD1RMeUqEm1hJav41/5p/zf9b8t/5//kL7ehK HOxa8czJJ1bt9NurXuiS8lzzfFKZY7p43863I7/AUqlRB0UXPV/34bbnm2m0 5uUdQ/BkBA+ab0n/fSvbaQ0et2G+CeQpunKxo3c9W/V61Yq7sVB9PC4RScTd RBSfaWc/385vc0MYnlBr0WORISsZ3TRyox91jGqZsOrLCbeaVm4kKt4slls6 bqK1hUNDp0VDNg17lMinNnrkRKfPNTaGbtEurm9U/vl2tqRtyEyLO37b3ELd 72f5PBbPTfSwpzp9KmFIcYu58VZ8AnXCw219QFA36wXkp8u2udMPnxj1OFEP Er3q0D2DFxBPp5U/ERWvWuU26tYypbPmbS86jj219IWLniR6J1bLqBPm0sN6 XdXJKT141yo3dC/gVjMrIuCf1Pxr/jX/mv+35s+roxNq0Ry7mfMQva8hKUAH aYrWQzd0dnzF/7jmF3WOklSZE3RSzQXKa0vBUkVzRvHEmVfny4zHI3d7j9f8 SvsgwPwoA2joMkfgSrQtEgRninpUdE/y8yo5v5G+uZcI5ionkBzuIGnBWY7C MGYkiSvZqkP1LMH1Pb2avl1Lb8uYsESjq7YT1KnQK+JRKtzMCY1x/NivIZnQ 5sJK9ueOrQ73jeKxIAY9sVmPEbTLkIGlMF+JejDNshs8PnnXvbrrl3WPojmV Rf0YYAlSGIZgBgW01FR6gExTvyDT48swfndPOYq/EGYBbCGd6TCjNFXEUuSD ZlCUwH5IYL7HlrIf7/o7EvLNRCqDoqyaf82/5l/z/8b8JfJHf1Tp8YgZAiUs hLBVx4G0qkrAwurx+25701eDhCQiwy5mvFCqCEkKTxGyYF/Pl9E6NVfMzKzE K5u+xSCoYek0LhYruHIiMGrBQ7iRxAvmBT8A1Iz5uU13rxNX5qiphGCkLZc9 JR0jMcKXMaN9yvuS9wjrR2G/sZGsr6EaikureEJhdQRKyATxKoBwbJmM0RAV fVldU9iZHbOz5AJmFDqjevxXNAwsKMNpojmeQBEaY32Fp/m9a5u9nc1Y8j7s AaxPkZUKCwUACeM9qT5z9RsTcHH61br26obdXO8D6srxNUN3cQlYssqT0KPJ qsJiEIr9PWG+5up9+3AtUaxbKYcTRV3Nv+Zf86/5/yH8sSACS4/tVMOvjhut zb95VikVootSVB/xoioiyAjHKAwhdWzab0y4iJc4EVhHlPKWsvK4FlEu8UPL UIxaVCPJrk6Zh+NWojAJKw6E3Gccza6FiLFcQkAE3JeQB2HB8gEkRGNjZmfa MAWcezKKmTZEQraSaKyMgJgbc6zLg0dgwR1kYdem3NY108Y+PmjlDbPgWKnh WXRQ2bTCCmKzHorNHXJIGOdH7eo8pIE+Yj3Kukz0OElUcBC296LFrqA9zIyw OKWPoVkns7eSxXHTFp+Z+IWrPVmp14APi6xcTGAjSdxUGeoBeEpUNj/mV+cs VSVsAwb7BBYLrZxistjV7erO2NnNqJp/zb/mX/P/Y/gnTZkqbKAQH5tLXzbS JeYozE5gUZuE8etM6EJGBYmwyRrgrboSFAssO3ndv5zP7lGHulYB/Pex84LC AwWhU/zFCe8DARELPRaYPXrDfryeLXFLIO/gHrsn4JU9ofuiBX+fefQZu+Gw AyXj2SA+NZt9nHMtSJcgC6Mx5YnUPmrDYCyHJUA1LyRxkH8ZrKpm6Xfz2cuG 3whNKGIJqyktNv1RjqHaNueYaaLTKYWsjWezobsw5T/MWGzfIHuM/cZFn0U9 rhOFhSF9JgwuljgQ4hPcX6n+iXmzPZVukoMQk7UeZHBfS+rQc5uhnBiSSmww x2wkTYP4CxP+p1mYZpXEwT6RiYpgO8EG63EVV86xPhImkL7mX/Ov+df8vzF/ KnxbmJDiufB1Yr9vZq9uFdtNF1IgnGBWEjgybcQ1L696OWn5goHJEpZHvJgJ 0xNB/rJZbgToj6Eh85KGLjg6Y8l4rK7GeqyvbuAhCOdxJNJp5o/R4m042A4T yHEUBHfqwoYJrnTF+USd67Uu7S9OxzQwjO1rbq6F/fPh4G2QdUiPQPgTjuFg XHjB8DOJPhNHF+LWuOcLcch7mvt54o4G2TMyeELiJnZ2szzwtGHJaE9cMvKK i6b7MoD3BwDS06J7JTAXSfnTQnYHxbfA51OEHd88WejrGwfi+p5YOMAXA7XH 5ScNqR+Nv2u6B83BkyBu8hy2XKTgAseDLrmZqOt9easH6xtqD0ONpL+8EF8I yv+8lS1SWERI8ZyMUkZTQCTm+3yuq292KccfPwlFq6uaf82/5l/z/8b8FVzM fEumE8SNkOIJG+6ShCrMa6bHzewRHxzL6UgpTpbRkXL5pFmbgnUpIlGOMdSp wvU7zFMF2VM2PWlnRjw5ldGzpTg7jE4VnZF0YyqJRC8S8RizJ0n5nAx2WEwU LIEfnXLTZzJyYUAvH8pLX6Lzh2vn8q35A8G7EY0v8/gSP3wtynXMXHzAktFZ 07iUhddKOn4or36JLg6XL2Y700kbdbzxjIhHRPGQDp/j+mIr52uzZvZsRk6V /OxA/TC4fTJfO5muT/cFzjq+yPpXxOFbUqxhnXgCi3h9sn/jRBKcsOyklyfc 4jFz72Tv3tiBZD3J9pt07yjLNuiXl2EcVH3Wbl6P508lwRHHj6biRNb+Pl0+ 4ZamvGYeUtqz1F5lw48kX+EW+9OFfu6qm/+TJ39KyZFMHs9bR/2943Z53Gm0 Oqz51/xr/jX/b81/ady1WniqMintGVk8EsNH2BnNEWHH1pKZVzl5PqCPh+Lx 4e3X5eq7dG3DaDRZKsaVO6OKp2K4qzwRQyqymQ3TeJsGrwvyciheDFvvypUP 6eqmiXgWcTcq7ClZPhXlA96l2JXYTW/3Zz8a8jGn7wv+vmi/9yvvzb3OPqNd iHeXZf+SGr6VxRpPCFpemPnN/vx7F7xz5H0uf8zbP6dLf7bLu4mAkMeSWdU7 IfNtPnzO+yHDjp9zm2b6o23+mLF3A/muVB/ylVd+bdUo/KnQXpQHV8SX1zxf Az40DVk8sdKdfejCnQHbGvKtQ31/uLyTbtzrtsWeVAc35f5Rka+K/37DE9Tl cjN5pz+x7QO8/lCs4/UrW37rttE0b5HsrDBXxZcfRbEqbchsU/qra3bucUYe luz+UN4f6oeDlSf5/TUTacgK85p/zb/mX/P/xvy3Vg3Q0CJtKHdK58/0YEdb iC+CWhTNLrvwQUoeOf04iXa8up0x6ajMFXMzyo+0ime6vC99yAdKefSmWHR0 LaHbsXhooo1Y3k4Jnoa7FitmtD3Zyl+0im2NT5Tc43l6ZMg9I1a7fN2oewkE fUr7nEO8tqMte36xfK3zZWKrppa5Jo7BkO78ppZ/5Z1f5e3fFe9y0qd4Pg45 1+cTt82DxcGu7oc8lSLVJOHKBp1UbCZ8I5EdIxdTyh3Ol8Zj7e75VvFBlyuR CUSmRSxaNtww5FGfPtmTjz63Hh2ojZgvxpwftOjBLX3wXSvd0l9etk2IeasV 0UG4+il4+Dl8ZsQLEz01ejMTrS6TWVukl7S5qgd/WSzuShcwr2kqF32w7Zu7 sXjeEy/60aNetGHRfIPZmn/Nv+Zf8//m/B3XCYRaJbKbyp5Ydi+W0w5gRK85 bBYvYe5Bzgn8h+PNktJC8ZQztKq7Jf2pe+mzJd8RlS73q8s0nkFbQVEQS8NE Vuf7HLtPukD3j626Nyv2tujzyjSbsZQQC49AD22aUeoZ76HVqjAtnja0v9wx zzs+ihzAZNjsoLLgo59V+ImF/+Lhr5J9khzyNUjQ+kJ3R1bs/fVkSe8xikvJ yb5qJqqZ8Vsxg/9AHS+aeFSigv5N2T29kr67l7SFC3lWeWhb/GsmIjhg5ECE MQv2eXjA6YHme5LuH1lKHnSK3Xa/ybGPg1B7nP0m6KdKlmAp8ShIptg/osW6 E21zpZP+vITO4RQuEE4S7DHKKbwAHLCwz4JYNGMh8SdNifxdzb/mX/Ov+X9L /koZRrEyAqJw5b/tNMNiCgiaXOZYVaEyrGWAkbMBmstR87X6gLN8asuvbGD5 ANp0c+wjwFDL6hhJVWC5hMWFVM4IyJ5YT9NkYsOub8aCf8ZmB8zRyjdbSc+D VLKYyK4QB5SXojK7JszNbru1jucQ8fGMG3vcc5kyeSDIngg+Cwnwf+dsDysp eFeG/cY9e2f9QLBPTO4z1oUsTIl9IXvN0LVDB7FYMsOwSAQtp+DrU1u9lZVP lRNUydAqFq1chexK9FztYxcG/N89Jfek3o9od3S5u/zQ3RU9yrtKHKDPkjQc T2H2Q4JCYnhPEBL4J/A+Ewgzs2MedBJsBg1Y4OZ4WwczRYA8phB2GWy/hLCs 5l/zr/nX/L8xfw2RlCRClAJ7E+Ss7UULW8NUrtTwh/EOUp6Zabc6C2lUUWll seiAY8qQM51SBZlUVXwnU6SNPqXJRMNuTEBOZ/HwXcRoeQrRiuZ4Bq2wKINz q5QLsPENTNk2xtz2bEx0AsGXwt0wu4kxiKtCKizEozyXrMBNQnPBe5Mz3fXJ nlYxZZ8U3xOiD+teMYmp6gvWhZcKWE3aSiKZ0La9eqN3fybBgo4qDqJCDN22 LY/2mepy1uW8gJcESmG3eKV687PJcgPSKMy8YEtUqt0uxF9YGtFG2RXQA4yK 4im8kP3p2e696R5TKbxmwNaicBlsIVKKdqpkQngfK0HQpbwyhhW9uZleZ7rP ZCJYLCHP/Tf/rOZf86/51/z/AP5ouI1nylTkSmPlBYqycCH8DebOzbg3s0Cs KqbDlmFYZ61QeppRlaI6FyssElwamRIWH5lzr2bSZWLQvwJyK+WlcjwaqMgp 3Wf4315LT2RP6v4sN5dm07dzfUUhJKVMYaWGjnLeNjIqOfypATyFMcjmckHL Jk3OzJtXc245TAN08N4HOBy2QZTA3SisaRQzhXEQOEvpIQofmfOv5/LlSmcF iwXRXOJuga0FWyhhUVcomDtacGD1N+temO8+n7aL1FSmHPsSEkbRU7qrINTq HmslKDMWmYSXEKzF/nx6rvdoxi6GffQzr0o/uHY6glkPGD4oqcxj46qVQ7pA +z9MmxczZpH14B1D4/tJzb/mX/Ov+f8h/JMWK8NmSmc9m7B80kVTTt7ymJRh H+RiLLRnF4qPC8VyGIcc+w5D8kUWLJuN6ZgV46Y15fVNx7FlcwZB83rQPbaQ vwgHOyRuSizl1jylTUemnLhm9GhPTyb6Fv64h+cO7GCieXA+LD8upHfpQcgg JA00z9kNE4wm4rKTl2E8KVuASJ0Q6bRwDWZO0+JlUN4PbYidN2NFDsh8Eo4a djGWl/rR1V7USASxlKUtYadZcizMXzQHu6G5KboR2YPXAHLDkEnLRr0eN3qu GwU2ZH1SWWrcDM3pZvr01mAziPFnPbGvxR4nXTbfFdOf1dSBmumpW1hywkTB pL/Bfz95yz8NsxWB+SZEeXyTudUXDUPHcz6eRrOGhdXREtZl5NPUnabls9Cv kE8wfk3TFitq/jX/mn/N/w/hf33azo/48GRBTw/E2TL6oej84FYbvhXZSKeX mL3AB29Zuc58KGBd7PS4nT+FulZ6rhTnB9GZonOmKsRm2E1gRsWneP6UHT6m JhSQUiXTM3bmRNo8UbAzpTpd6hP52jG/NVH9UifsNbZ/hQ3fsWKFd0MdB8JP X7Nzx9Pw9ID/MJQ/DNsjMB67PvO1zs5M0uQsGzzig13WDwWkTt3p6/uzp23z 1JBe/CIuHEZnhp0f/PZEssggyscTondMDR7zwxfUNbWhUTw+4RqnPD1dsrND daZsn8yXT/jlqb7E3ZVPUXuBFo/44U4I+d0Bk7/Oz32C+4cnMn4ylyeL6Gh+ 93u/ddm2AqxbmRT9E7x8QQfbPIYdQqidGrU3ziTseIb+3qcGi8eLzmnTmcUq kjbNrlFzjh4+osUmrfxJhLk+VfOv+df8a/5/AH/CTKOTzD9xzec5e1KKx4PW 83L5hd1YMW08LHCXVXJeDt6ofE2hgxDRfnrbzL5OyeuCvxywl2XrdbH02q9u oKi1RbJp3Tuhi0fiyzOByiImzOR6Mv3WBW8K/mKoXgyi92XnXbq55rFLsrTn JdZBvFN5hx8wFt9SbnLbXn+bhm8G/NlQvhy03uRLL+zavfhrC+NJac7zwb/9 tzkWU8xsmKkPPnyTsme5eF1GH/Kl99najm9ryB+Thj44prMnavhUuSA0jMZT m77xNkW/7qcD8XIgX+YrT+3qFqRvRql0IrIXVbnNy/tsn/I9wX+bXf489TRp vizZ80NV+Xvf/ZBt7TitkzY308ocV/kzMdgRkK+Zpk6mtpK5t3n4Au8v4foX eedJsrrU5ypROrkm7Tk5fCLKjaqtD5VxY6XmX/Ov+df8/wD+RGEIlnc8W4vp jpE7trVp5Z0YQq0iWYv6a5E7E5U/6eyewJ7yimGTenYnpxuOblq+YeWqUa0M 8ouApVGYLfD+kXb2NBo8imzlv22kiNntfnPTsB0r7/ejtb68jXZ56GVHk2vt +EJr+DHK7qh9InrY7z5K+XJK7vfpbk9s96OVmN/ucnVAGcRH24ji01H5Jhps RkkzjNsoHu6z291wrcs29/TWZ7EeyzvovMTgempvCfNdlL6MBg+0WxAHkU4o M0x32XqfP4yjHcM3e+ruAZVYFRIxN6Xt+SjfFum6/AdTfxPyHxH/nS7u043P dHefbffaa/3WsqVRSlUWyfS6ir9rpa+icgvmy/qMOqUytmzD+zHZ7cmHprVx wO4YLntc4Pgno+RUa/hcF6tRTAS+IdT8a/41/5r/H8S/L2UieK6IRyPWMBfE M4hTolS8bLF8XrvTK+mHpVSjY3blyIen4TkPMhp67MWAztgpnl/zQqJkq3di 2T5ZSddkgr7TaMpXCV8DbEDMiBFBn5MUvsg5oHOz7fjcWvr2Xk9J5C8gpRJW 0FyFhhJkyEmOVnUCdcJKJKHqnVpJ33b8Xe0Xon5LGSwVoYkgfU67nOxzmAXa xsJSVt6tIj667J/dS1e5pxLFVyGeNNmIWkkz3nSsidJf9EfViWKmKbtnO8n9 O/178q+S/JWL/yX474L2JenKhd+4qNp9Evt1yoInofh8tONervg7ohfStPKh hcFbGWScFijHDVGQXPk1AYGkqX47tYLX39ZYhC5IhlLemn/Nv+Zf8//m/GF2 ive49pB9wFMYRX9UmKkQhRBZhNLZdPK+3VhDozmGsqVc8IKhkbXDagvsHQBp mkdNKUp2s4gmU8tJZ9O10I/OYp0a2lajLx/2O+C9qvlOLNBt1Ul5QPmvje39 9aXfGftFyF+5/MzFHl4grSApCn11zGUX6zUU7AqrmRnfMJsrNsJNgs57aLKK BtoJZweCddE5nKKrHteAqB/RvYlOvLQJkbqHYics5bYMfflShMNdJTxALQGs GiRQnMRTK/Ht5V80+38l/38E/5sUvwI9prqKf9Zhv1KgpegWjtUce5L9Y3L5 8/LyHlvY02hRnqIKF622UxEWsBkkRydAwfdxEbG2fX92fX99PWGsS4AzJGWQ Raqaf82/5l/z/+b8ATu64cH4+5MzZm0K/q9DmAL73aDgNkwFjEpiEKH4OdZl c5ZJ5cfG3eZUwvEQx0r2f1Keyg1bfw1SHsnAU6Sl0k5Nmc0GrHVcOeD10bxa fhLsN64/CwXMD4T8hctfKHwIKZU0jTGz0aj8UTEow7ewYTG8BkDiIxU8qC+Z rdoiYC8GKbvjDbM2ESuVMOybhi8VFKsqDDqvRjDsuNoMsG1gnBmXxfSkW58y DO4mUiYzzlOC3RkSCblV1Bfsr0r8l5SwKyDs7iv1+9R8vzPeb2HlINYVopQX Bkb/Fao9Kg4YM5HAITF4P+F5IIr5Ud+5HgsU6/qqyDFBIJCTtqzS+4wdVNE8 kaIP7xU1/5p/zb/m/y35M+QP98Gj54AkJ+b8y1m/SCB/qfIm7pXMhS6qgAKx FZsptKQNUUfqb5JsZDZ7M5/eJo5ixwSMwiJysgWTxZ6VArs2QIYC30qUsNep OT2bvm642/Qzwx+dehA6pe6JqCt0V0QHrNVlep+LvzH2LyW6s8ScnXXvGiZi fY79C4B/F1I5qfoQiGVkmIZhH0ieMebhPYHwg2Oz/vl02iEHIYeZxgz+CYCj QtjyKBY6ltqhDgr2FU+boR2ZTd/NuBaDd4xcMNxdCrKwKMEdKD5x/Vch/8X5 PyTfU7In5N6J6/Gj6RT9ZrFXEdwfruwy9Zkp+JaV7X1e/bgnWBIpO0385Zn0 3Txqj7H+TsZc9ThacHuIuVzvBdiUB5sKCdwkNf+af82/5v/t+ceq+tVoJnSn g/I5KdcDRyrHDAW3veWCcc+vGj1qoikrA+w+SWkWKT8emrPN8jUpVynWR0Pe ga0Nridksscux+JS0rqS6Gknm3g0E0k3yewIKd4E2Sr5jI4c+CObIXNdNr5P rnb15V40hpbUTB8Q+avmv1wj3R/CwYeFokO7gYgVgyU74LxLb32mc59Ew+mb fYiJTHtIpiIZz5PPRxayF2F5nyYhvlHsA20m+uS64dNGzsR63ilimfQUNpXy DR6fDItXC8VGaJsyV9wzbWRowvkua/yi5v5ndPO/BPk7U/8Qcj8S8U3WOxqk D4Ph46ZB33IWQzylt/rh1B65ZuS1JJowch4rE7nyLZFcafZGyeB9M7sTolIX 9jPkX6K5x2d7dHJPT/zGZo1o9iVNBIWgXPOv+df8a/7fmj+nSTtMIX6NMX+e Dx6R4TZEIukJT2fHksapNDxb8itldBF1tmtn3cocBNNMi+wKSy6LwXM63BbA vxDST15PGpdccH7ALg/F1UN1abB8LtuZcm3mNHfXWHKGDV7QcotB/HWEJ6PX 7OyJlKLu91CeGbZOFBsn7NYEhMh9Lf7rIv98nn15w4bb/PdQ/kp5MjcVXx+x 5Dh8JZPHyztH084JSIgSiPuK9yfI/ilSPuXDh2Gf8B7ka/PjduaoXTiasZFS nCja3+dL36Ubo/DyYJUYjHF3hpbP2fABbAORUlbMTbn5MzY4lZILmb5s2iPF 0pl4Zfp3uHkkejOsd5zm99mXZxSCLOwEOzNjpk/75g8FvzgQF4ets2Xngl1v JLAPNcsvSTvGD1/RrMMtYUNC09kJMzfiyTGYb6nOZdFIdvcH15lMFkmqa/41 /5p/zf/b859KFnWqiJnk9rwodkV5XyZEuUCmjQ0//yolr0r2ZIC607fFyiu7 3MFTlYjno9pcUINncnAfM7Jc8mR2LZl95cmHlHwsxNuy9SFf/smvPLRaodR2 TPZO6+KlHD5ApVOfqv3p3f7sz+bWx4K9KtSbAVy/+jHd2PKQmmn562X1+zl1 +EbA/feJ/I2o3yZXPs8+tc3HA7r9RTwY6p2y88A/WEpaWIVnx2R8RgL/w12e QNiF9Rrr2KnHnjwesvtf5M4wejroPEt31h0Ea82Ta8L+AOPnwx2J/YNCmU50 TOPf/tsDuT1UD/N7D/bXVn6P5Gctfp+W3ZMyfyC/7OpPYRBr4qdX4rmXfuFt Tl+U8sWg9aZYfu2WV53E9XKjqntNlS9F1kEd8pC28ukNM/cyC19m/OmAPx5G T8o7j8zKil1UNf+af82/5v+t+d+t+EtWID3Rv6Dyp1GxKnqMGoopUsHvZGTN 8e1YbVm1ZESUVH2EXSTSSZX8oPNXbewvUPURw3yK6kzetnQl4etWd4C8Y8xj v06GdRBH2vnbVrGpe0QcaPFPLWJ2Nwm3c/rYyodxtBmr257JkgoT8e5Yq3uq PXits3WBpxtcHohon3X2Fnb2ydM99Wiv9TjRm4lcdBDNI+EnInMyKp63Drdh kMxwDtlZTDb7tx47+jTRz3zroWutG97uUnTtSCe1H4nKl1GxiTrhXIiSK0tX u83tPtn+LLf+qdb+qu7830L9TYh/ttjf59UvR1rZ0+jwweL+DeUXZWUhu+jJ SkI3Y7ll9YqXLXhvgdWPI27GVHwpKt/o9C7sN54qlgvt6D1DNix9YPgDQBrz OzGTVgB/Zmr+Nf+af83/W/IXwF9hdwPF/XXVv3AvfXbH3ZZ9jufLKKwSxMsA rZZI6MKFrIVH6jETeE5xXR9cvhe/WfEtHQthGJrmwaplmmWCWUYMCzHtYsKh 0x0EOL5/aq3/at3fUV0qulL+jjantJBhKohDG1IyQEEXxy7PinXn1cGpTv6m Y26rPca6gh3A0nMCQ0o4h693ZegZQVUwlfigee2P3k3f3svuactYLHksYUsE hjWdCBOJLuLwHwYtZGUfssWbkT/Wyd7eS+9pH6KFuGO0qwJDQ89ZIugnHv5N 0r9K8Q8p/kvyvzHxt2PL5lknXVU2xH3VFTRBK3KCumIOeMOMozINESlu51vm /Er2/E7c4oClQF8O4EAzSQq4vvoucIjRha/mX/Ov+df8/yj+iK6AhGVyrbfW 6VV2o/sCojDvs8pSVQcofCUtH4kMGw3gaQj2xJzZ7m2uJZwmCJ9XVnsyFVHG ieHNvlQpfkITISEbgkHuza/+vrTeU+z3ikC30iPFSicsyBRMAW1gYZBZddre 5ezz6LbZWoslS7CCA/W6MB7/1fuO80ToRKgYVV7USZkR7i9t9nc3IX3zXCfo yCdS1NOqhCn0BpRwc2kl+mObylHcXV1PtjaSKLQELccTonuCJQrGhgc3+1z+ XfD/KcRfBf8vKT5H7J8Tq3sr20mLQXzPiOxrBfPC0xZGKpWachwWFx/Uh7cR wrPJld7Wck+gVjlDy3GeVlsRXngcbiE8qYnDal0E9mio+df8a/41/2/Jvx9K NCMlyMdR/btq/Y59DeSvjH/i4nfB4QJzfaa/Ph+HGqZpFdYvJErEkqYwLyax fQxMGQsZYAlQSuRGp+3qeLLIDeEGlwCtp6uAxf4lxK+S/SZFTyiDRQrwaPm/ r13JdicsU1iRxxlAgBQJvpiwyErd5RS2hEHrV6zmLpTKJmZs50rcEjGtRLmw eTQkUCwPbhvdhtgNn6SQ9H012QaYc7P9ezNOaV85eKB/LLwnSJyvVe0YPVS5 h5FDcITsqS2S2Vl3t/EvLv8X53/n7B+c/yb5b4LtCfUvFn2GjQG3lehGgkbi TKWTDbMxjcpkCNy4ygKFvtgYrt3XEXyYY6WeqNy/4e1FmblGtzNrhDpQFFJR J2r+Nf+af83/j+AfCvTBowp/CFJyj6u/Q2YkNEQfiJL/4PLTTbp3ed68mbOK +a/FFxRGC0Gq5amCxxkRQbIGQa0AzppmTepOzfrnN/JO6CiiwIHBaCHR4OpX Ff1DtD5x3cVSCJZGYjATlsdn/V9m0jtYLgG36kJ0htjNW/tSHIioz9sQECHE Q1ID8ypCURyZTx9N+Y1mP6jErhJeISCqYgEFqoWl9jDCqk8cLJkNWTwybV9P utu0Ut5SyLOq0WIox7cLhvUdMYZRWALWYyw5O+eezPUj+omxT4L/WhVf/F1F v/PoXzL6lWiD7XuwGhGVuiEzx6+7l7NukaGZlcSCvpxrC39KpyzKWCvGWkUM vh5Q32Tu7Jx5PuMWYe3kvqSfec2/5l/zr/n/AfwPJN1TkGcRSxYO+PVf5Nyv 0a1/QYpE0C/ok9S/TNJfrgTFu2Z+GzvF4MkFPJ01+3Ta0UmjZ7pqLpYBthgI ZdbiWYPaEZo/bw62gD86bBvJ+/Rmvzl+IK79pi/uRZf7rZlYEPQjagl/lZgT ZPBjUGyTQVNmincFMaThgms9fnk/utjXV2PV6FHyG+RcimY3qftTkO2EwyfN OKgqQSJYZeLIDc/nvJxJ5RzkVn3egmAKKZibDfzxZvGqWW4FcD0sOixKQUOU CvPZAzm/rxewCCLELpxfdbzxmaB41syXSY8KeFX4pMQvMviFz/6TT/xTXjuQ Ewf6xmd4ryCQZzEzT8zxoHgeFBskCSXGXxnmdNaScSMuOXXtIJrZ5wtYcg5B X1E3y8xJUj5v5msEvUSk7MG+qvnX/Gv+Nf9vz1/J3vVGfPO0I6ccPZuqH7LF U2b5VHd59kBBdOC/XOW/jrLDN7RY4QYSLgg3jdFk7oQLKz/t6FQZnciXRtzG VPXjG89nUGdb7vLhQ7ieJ5S76elk+rRrnhnwi4f8wpfWmeHKSP5gIm7zg4j3 L/HkNB+85+UOzULhF1h3bMw2jqfkdCnOD+W5Yet0uXzKb0/02hRSlXSW+iOk uM++vIQ9AzFd+rkZ3zjqg+9SeiSXR4voT/nqd251FIvstEpGpYXxPBXDR8wG HPsmzE746yM+OJGzkUKfztrHsnsn7d0p7CgHu2uK9M+T8ikdbAkToL/373Oz n+ZPJ8FIwX8YiNOH+lTROeMeTBhOYy370xDf2eCxGDxAP/A+5b2J6WT+vCfn BuzioTpfLp4ogc/6zIGE3aiyKWbO0MEjNtwhkFR2CbdzMzX/mn/Nv+b/B/AP mW104sZjG+yU4v6QPRi2d4vVR3at81nwvUjsXYl+uyYOX6t8pTpZvimTiU17 /YUPng/Ek0P1uIyeFZ0XbmMVzbq1Tid0PMIHT1HXmoTViUNjLW689cHbnD0v 5Ksy+lB0PqZr942WSSS6V+XBaTF8p8r7yhLhQ92dut9t/OjDDwV7U+p3RfRT efdjur4Ta4VGFrPCn9DZOv/vN8xQFDulEx0/9dQGzwv6eCh2h/rpYOVZ+mDZ tESumR2V7pQoX8jBA+EIzYlIxztubtcFuyV7NOA7Q7WbLz20G/f6EaRjLJvg 7rIYPFWDbWoCFnP+22xnb/55HLxI+dNcvCgX3+VL7+3q5p4S2NNzQprTonym hvc1/phGZW9uM5l/54IPBXmdsdd59D5bfudXNw6UOIBUcUInZ2Wxyw93uKEs CYWZAf6Pav41/5p/zf+b85cG++As2XDrgG3/Sz34l976Rd39jcvPVOxp2h1V e5ei4YfI31EGfVB5KlspWe7ThzF5YsSDnoY73/7avOxrPxpzslU8b5Xb2gUC PkwUs7zlw84B2/in3PpFr/fknT4VQM+3RDrWwut/auWryuExEOsL9om1E7Zu 2HZPbPbVSiza+0wcUNwAeVPZ/4+992yO29rWdf/gWbaVg5UDc1ZiA5gZaCow 5yBRgVS25L3X+SX3y61b5+x99l5ethXI7gZmQGpSOmNAq+5PkL+gqotFU2hg 4pmzPDAw3/GOY/f0UlQ+iZLA15KigR590PLX9oNHLfE4jh5puWRYU1e6Xzci zakofRHlCwqCL3ZYY2EazCRkzdHNDt9oqfWEz32mkf6mOhtV6ZUwe6rSeYX7 R5z9KdkftPlfwfT/S2f/l1j433L+H0L9TtlvlO9JiOZhfPJuthtli6rt0QTv lxmmYjLd5kstvrwnFxLW3GP8E4RmSdtjqn2qmW1HxQq+J9TYyrnmX/Ov+df8 /xL+HPhbHljud3jwUZI/KfnMsan9J0g9GN+7oT5en9Mv78USzUs1wf16w0lb +rHvaebBt2IS4M6CUJqT/QbvnJ1xT+fiexxFWVyikx4njgd7zP+HDP7Bgn0W tKp98CSk9obKTi+YX2bNFHZkwK0Qyj4x0hIeXNEGsDaCD6L6e2XlbTnXpx60 l+fMcgjx0SiKNrAyQG8Q7sWoCvAsRSmsxX4HPL0D/GfNzrS9r0yA/uGa0zQI UuUZVMNSQ4OUBDFcIpBG0PSWcpfuu6d3k7vcUJhc/ieEYB78RoPfWPBPHvwn J/+H8Y+C/sHZPwXfh3OemddP5vUUPj/EjH9mrMX5nqAfRWAJ3KmH+/tc7KH1 H9O+6JydTbZnzDTwR9PyuOZf86/51/z/Av4QuaqQilZyKAf6p6CfOf8ApwXy wEGwtif/vLn0YWF6j9KWIFoCBN6iDG7NBoAX5UN7QBgyEbg0kR+ZSIYW4qX5 TmWyhAdgXRt6zX2GkSv+fyp91z760cGUcQP0Btb02qKhxKGHNr7C+oQb4up3 6RmkKj6hhyrLqPjM0OA0G53uTK3FTUi+lGYCpj6tVLVGAE/PoZk2KnhdtUXu CHEDc8n8bDwVWCor822WUOpQQhDgXgmTcaASKbJAwILMGEuHF/TCbKUc43vI H3VosBT/ZOR3Efy3EP8JiCj/IGGVYmuJ/Ym59vQ8FmJ8gyY5/B29B6mnZQN+ gfVsGI99iu6snLRGZvbnFrUiGltFYL8GU/Ov+df8a/7fnT/qZuH//xKinty/ OfJpcRTu8TN2hKH7WIPAOoy2A/kBrshoC/sdkETiL1hWMDKczN9sccjLWBul p7jhklCSwO2EIepyJXwdz1B1q5etibE/VkY+C/VBAnwIhSJhPMWxhahWYijW wjyFCdyqINL2D+iN4W/NEdrYuIEBhz3GCooW3LFEUasl36S2vpUyHRjX872x AsIExpkyLKlLYVp9qSEhikjCIDpTR1mK5XLMDQ2hbhad9/AhJPUEFk0IUjLp 8FkCk699yj5wlCJDtvXb2Ng/FsZ+q/j/E+ZF8D85FnrDsGG5xjh+hnXiSsIX HTyl9IzEa/1xiDLgT6jUFftU7FFYWvALfCtwAs3AsSVEzb/mX/Ov+f8l/CFQ Kt6+xdoXbrjdiXYE8PGiHzl8S7apgs9nrj7jOyVuIYNQDKPtDaLPD9lX44nC 91pJFToTNL7groqJuFmvsE8NjBC722D99c32q1E3zfcq/+qqf4F0VBmIxVw5 FlkmW8iftrGe2m+dG7Nvx+wUcaj4ZfsB+12JP3mYEoATdURY+b5ydM+TuPXv jo/rJ2NmPjBetTNCKbbvgUsQ5SDyYp8dmkLOhTJdnjWYPXfT7UyYe37VNAeT u1YjzETYhUswZbjCnhQw45TBgvzH7eB/XZtoP7nxeYr+FxcQhf/k8pNo7nP4 hLAIP7NQs7DFBKRm+Crytm9OAM9xt+A7jye4wmGO4AbDHNYnlYkILdw1RR+P mn/Nv+Zf8/9r+AdCN0VrKNg75+UvvHSG7hP+WWD/ys/k5ic6vEcG9lV/S419 5D4EEQjWuM/S73cuePk7L52msYfFznDpNgkSeiumE20x0Ykm4aJY44ZRm7kb wYfTnnnl5atBK+B7UnSk3GNe0hiL+eCe6jNqDLKhjo/7FC2IWb1B+1yQvUJ/ 7LaPjkb7+Axw61PQH9PrbXG1Ja8n4VhM/TQgeUjdLd+eDOwTr1i5EwckiZjx vTa5kbCBTnC9I/r21fBHOWGYXzCSCppPBOZckG438uUgIZCOsZjciRsjjvaj 3zh8pvra4Y0O99tVFcbHoeDzdeJ2AjNL/pvJfwpYJ5OfvYGP/sWP9NyeONuK Ln6eGvjEvN8p/Qy51Ygfn/GyZ0Gx6bfv4E7QnvDbwS1DhtpeTyz7O2oIzg/P LQbyvpp/zb/mX/P//vwpNp3fh0RpgLYv0XKXZgu0TdEyujU8sj9x3pKfc3qp lBfL6JybO1f5S2O8dtdY5zItX/vZchB7PAXyNwb3bv7c8U879rNTZ7OpY+mD 48l0f1K9tUsGyefztNihxUPaCkQnYMnI9WTiR3PnSMZOF/JkPvVTNnvUzg23 YeolT64EySXafUrzVfp7INF/Y3h8b+yi8S6m9HLJr3bVlWLmvF3q01EQS9qZ IPYsTddJsYF9OU3Q0MMj7Ymrxr+U06ul6MnD63b6ul0cM5I6RbMhai+xYosX 6xyLLzyaDIzpm33O78t53wEf7EZ9+Wyfmbv1WUGexff76V4/zx8zt0j/ydhH j/8+cHN/ZMj4oyWdOOTjh+FYd37ULN35DYK1oh+H+KcLPN8g6Zr3KaAZEXbs 5uexyxrGz3q6oqeUV/OZa3phdE/V/Gv+Nf+a/1/Bf350D0IJ9i8Q7Uui3OXp PO6AtCFFGltpTbyMvZeOPM3E0yLaze4/M0szKIINSXpNdC6J7i4t1gjEO+fJ zsBsPLZhgpWCLnfFUjdcK+Y23OpsrBS2PBgQrfMif0bLJyKBjKkhzPXlZPRJ Sh4X7GGXb5XNZ9nijltewFbFIe9clPFlerArizWFfYoJ25+Y+/PGy+TOqzTY cfKZUS/Tu2/tzLpWKhH88w3++TxLN3i5Wem4iHQTi8ntnXjyhUHd79M8eu7u 7ZjpBQfJV8iLYWkv8eKxylfRP9wRrieWk5u72nvu6K4VO1a90Pefxg/mcb+J 09ag/L1f5s9EviQ/UPaRir07Kx9uv25579rBWy1+0dHr/Xs7H8Lp/03J7+g3 y/YuqnSdZVsoyoW8r3VjpjX2OAmep/SpZU+z6Fn6YKd9d3FfsJp/zb/mX/P/ K/gv7FPeVrwzFrZ/nspfNtMZGQd8X+ErL8vCVjDbDmCOlo2ctfxujFYSPIb8 ayCMz0X5i2Y2D8eTVAaaRkljvuNv7LFnbf6kEz1K1KKRUbW7wfS4/P1M6F6E +cPQeKwrRMbvJt6GDZ5qutNRu0n0yMg5TWWbiv1I7F2K2udV+XYqXwrbHsVt bsH+m6nP/v02mfudzfwW3sNXcAFPKzMNd0e1LjbbD8N8JUx8lnL8WKk6ZDoJ Ftt8zoq7Dm06aEF5qXg+oez5KNsJswVhfdyOySEVRWumZiruxfzBPp+CzNFy gv1Dlfg8ov5xPcxeTpn78hMhf0r2SZCPnOJbOHb3D373n0z9yYP/CIL/IOyj ouaWap+96x5GxZqIgyBlzCga+8rwB5rNfGZzbf6gE7K9AJ52eEvxuOZf86/5 1/y/M39SZVsQLxoQf+f009k4xGbK+5VO1XGasgC3rVngWJChYAn3U7CbwC1l T8+ZV9OmqawvMmzWyRz1nQpi5ifwi/At8dFeG/sy02RS/OPUg/jtrJsPHWEF w5aUDuVPfsxJmweWehkamVY+3iFrDTdb5+bNr/NaybZPPgv2gYk/Bf8dToWy MYyJbTTTZhV/oCftxZn9jdnOTNVhk4a4Ay6pQZ89GgfU4r0wh5x5IWjpcXtl zmzPxU3s+JBBUA5YTmguWAE3LmA8cOO4ja45+mzs3ZZ/9C51ns10OPnI6AcJ 5PkfXKDaSuAeDSRlvwXy/6P0P1HPjG6r+vycXZ2P74uEECNgwDypRGKxBOwE MlasTAGetHIpqfnX/Gv+Nf/vzB/96zB+tRj7fGO+ff/BZ0EgI8AmNQzdU0sI bQEw9DVTmWQwPFQuoQM2tQOrZmkxxvviuUSnOwcHS2EZgWm1UlT741h/12bY 5ec/+pf+eLhmFBIweFEOJy+5cgIb2VsOx4iquIO1JOtAzjW4pdcX2j79k7IP EiVM/4Csh8kOyr38NlYOolW4paKA60KKNzaT3F+IgXnE0A2boDoXXe9IA2L3 Hgk7lMPIYephwF1Bs1uz+v6s5qSASQTUKNaF0CzdpGejRoIXkvCwkQkB3P7g 9MOthdaDBxAxP0r+T8n+weF5gHeE6vh39sPJT0z9FvDffIE+HujCTbOb9+3U HIwHsMDNfoZ1iPpeyMU8Q+6gSSyOH13H4Y/tmn/Nv+Zf8/+e/OU3/sJh1Ru6 au9T8RniGif7VSsZOABuLR8YTlZGtBBWcICDoQpuCrErTeEDyQuck8LxCJZL OzaRzI5BxpSg/yr7xOnvnO0J8k/W/D1sdjgtOC85+8LZoWAHgSjHe/TymCUq Fli/5tDHm2MjHhKlQrYJjErFXDq0ZqUdKTtDtz4/GGxFYp9jYwW4kZwKR+Cf mOYhVhQ2YYUQ+IvFFgxSD422Nkc7nuoEmFRmFG6BFYJVCw8dQjCIC14AHJxK lvaNxuujsYIZoYZhSbVmbL+yAUdlAuf7gn+A+xL0g6CtgOmrA8n2EPD55PP9 QOZAG11n0W3VUemw5gIbLkBQTjkqh9P+UTM3HEcC4ntLYAEL8O/U/Gv+Nf+a /3fmL3kCQUSiX3QssKONgbumYcIl3FSqRH6bmNM33fNxey/AYj0YP9DmMuVh xpXBCrjIUZEzTKng/GnA3IWbyfaIvutDZMTqPIH1yFZKyNEsfIWHBxAEYR4h NEc8H/aK8/3612GtBDpaU/6Z4cEwuRmX+yKMifyEOlj+rYuBoSw5cyPeGDeL ftvHfKqytobURsVVhwVDwlhIw+EZQLZFaG/67fM39asbRnhwPIqBYUWJsJAq q+osYDw6UBD3YV5yCJ23iL14W+/cdPeDnIguLCcZWdbMWQTjh2hrWARfMUJi kA25HgvMyZvZ6xvmQRAH2IcO1mSKcmJlpMoZWnBXiCScHBtV3KHm/KR+eMvO 0BYR8KTxJ6/51/xr/jX/v4B/G/gL3/pDJris2UUTXmqH10w4Ur0941aJdJgm Z2j21C+W/A7BiGwxobhjguGE9Wrel4TDhjdSKgvKUynym9yc8dxjr1ghOsDm YpkKMyzKuGP4aCKGEzWeQW4SwNhEGsmDi5694Bd/b6SzQeYLIN+CfIfcToKR Fh2IRV9bTnyQPjwYfGI8FiK9Sd1x324FxSNifFgJHAJcGkw6f6TDBtpioBWO fZC3W4K0hd9W1PUFnYtevtNIH/g6gIPRbET748bvifmVRF3W6mosB2PegIzP RRx1WRf94pmfL1IL/JUo2Z3U6zX+FeSjLrWbV0xzCLttEmabIukhnZ9J8YJk y0HHw/EkkF41xlzQq+nVRF4xqiduDmvmQVDGgvQxas8F2UbgFoM/AvERy8Br /jX/mn/N/7vzJ8Cftwdu6tHradDT5QNd3t8NrxVzV+z6eBIyiC/ZgIjP0exh cLBFO0TElNqRUT2K/tU5PVuIs0V0Mps9YRf7tKQ2FNkQxEeSPyLdLQJ3hJ0x J0baE8cT/4glR1NxLGv+5Ob/Zhb7AUWqaHmO6Ku0/AXGT9oBt37QHr60f+NH 659w7GTBz2TN4272uFsaaCv060jHmT5J3DrtPkN3JgMJzsiEGT1v/QsZvVLw q3l0OX1wubMw3Ipo0qTuOutcoflTli/wdiBcA/3AWzeumaCvSwfwlsO+cmbQ Ld/sKKFD4XqZucLLx7RYpSmkYxDie28kY/2O9JW8/0D0dcPrxeI1s34jkTyL uL1C4ou0fEa7WzwJsAlFOni7M9qf+L0lq3jK3mLmqlsdMU2sy9MjPD7Pik1a blTv3GDSB26Ymn/Nv+Zf8//+/H3ubi6Z8Tfae5vyl7l4nYXv3PRbO7NiBc8j Xg4IfVblj3j5SED8guQlHZtPRp4njVdZsJOzp0W0k0/vmqUlGHwa8nxI6DMK /aUfcRNUFhmDs+3hJ7bxMCebB3LzINwu5nfM1lws2F4o9i+Kveu8fBem87IT MNzW71vv3Hrhgp2CPSnEkzJ8ns/vmpVlpzDfiUdk57TKVsXBDq/4czc6Z0Z2 rbeT0celeFKEu/n9HbewqsMwCbnrkcllWeyG+bxM4PxE2fHVzu1d1MGy3Uy+ zO++NvdfdO4tWSZwg2lQ6ssqeyLKdQkR1jGZ31x3N97Zxvs0eJOpN2nz13T2 jZlexE2okKeXpLsoyh1VrEuDboHM3VjojL80jZeO7KTsWRq+SO+/NrOoE07h 0WVc6p+VeyjKLeV84ZiwN5aBv6n51/xr/jX/78wf4hckKUw5MpOyBSfnHL9v mEopxaQpZPl4qE/cddthvh7GPu5fODQsmtJkQdN1w7Y6YjVW04bAV0QOIWki So5PpdthudXUHse3alIm/uxHf+sDfb4nXyRTT+JoOSNNFB1FPL84lVxRxd8j 90A6D2ewI+62vKWEPGyx7X21vRdtGRgVgbtjiWL7t2R8LHIbsngcGY9pGA+s EzLlgqWYbmixFsvFWNwHbpawJGLpgEouhfnLML2PZhdwMPpNkWbKZgybN2LO qAcWkiZCLb7349moMj9H2cu72WyUBjSRNFckZdKw+5bOp2Je8/sO30DSlEgb Qn4XudNR9lpmi8r4uI8DX9FMpuSBofOWL8RyuiObaDZOID/l6c0wPhmlT7Du I646xMGk2Jp/zb/mX/P/3vzRXzpjqvKLQy1rxmjG0aEIt905ok4DaU/Omu15 Mxdih8pKr5WihYVnUKTq58xPBckEtxRtl3Ii9dFp83TWLUSJx9soRqJOkj0Z tHiwL0mbeAWdbAl6QHkRUj2gOhfn7L/PQrjPKG6yaBTWBm3p7wuiuZ/wRgpf QSmsNFzGgdQ/PXDbM24lxOZB6HQqUA+A5qvouWdgbBCUK19ZCynkWKgvzphX 950SlfIKLbgTThNBEkpSTiwnsNLgfvHRAu73jnIXZvTO3bjJMyI66EOC7oJW ELhEBYegiEvi9j2mkLdUenzBvZ6z91TqV39k2EVaM5Kg0gDbQGP5IWEthMyw K+jZOfNk0d1THWwwDTOrcEnU/Gv+Nf+a/3fmz6SrJKyooSKek0Fa/SXjooA/ 4m4F0UNzenZVw9ggQjHcOodLoMCVwiWCjMPxHOKRJVwLCdFc9y7oxTXMfWAu MFTBVEon5D5qmarYxNSewHEeCuFu8z8n1jqbs87H0RqMRyji6giVsADmIsci ONTHwnpIBMMHg2vzZnE9noJkB9/vJaLSu+JEoN0fYHRVcwe4bqYoRO14aLWz OBvD0kLtK55fo9BXGRo4FCFLuKkcFg/jHSpKzrqji/HcXEdhZx+cF4E+sZmU GYXJCjqVXBbrR6rrGkpd/4pZW4ZwD+vH4EhQVdtmIqYsE3ALMpbS+TKpdMjw wNMZn4tnF9B2VUqLMrCaf82/5l/z/yv4Yz0ahipUWw0M2/VRFNBWSqocoyFG ZItXlK7yrE7hnHCD2IVNmMFRvTgQS4g1mLwAT4yG8DsJnYxiRqoyNHTYzoAb 8Bwa6iwNwAA0tuPhJeOlYAXhHX7vs5LFNxO86uoQi1Ofm7GeZHm8HQgsEqwm Qgv6kRNDIyvvptX5NTKHobJcKjc8kcwOJkpCJggoMnxOEA7WA4naLNLfcFXj tFhtx+34UGfxZswkoICpTNE/nONDCJepCOHrMMi86iLhqgnKBwf08liMNCjC x3UIHwj3ygpIPwND8X0m/MRWQcBn+KaeGUyaOLMZxVd57WruMlyBsCDhgaEa TMW/qPnX/Gv+Nf/vzt9VetfsJjWnx+2bcXOfGQ8iJl4asfPI8ijloWURxNOs mhqco4AnJ2+YxyN6zrdUVkEK8q8wFU3DohRbKjRxYBSLEVKIxbdJemxEvxnR D2hCxJ5Ev4tUyAMWWqU+8bBLmxlTEPFLGKoSrr+RXB22bybaFWSIvAcwZSip jRwPUxoltJkwhfv7HOsmHAA8PmqfjuhpYgJInXguMDVzMtRUteGWqYLBQ7Bu oxWGyMYCc3lUvxlL4FoETUUMxGs06IgyoQrgz0JXtXvDJAtA3STu7Jj55YZW aDaODt7fViZTlY02fnCzCU2/0So2ZsjHbg3rxSAL2Lfi6wIvEeYizOFmuaqU zNzW/Gv+Nf+a/1/E3xHkkw8SfdLPXjfy1UD7QFLlAugFOhiNaX8iemI1ZORt S2CEaMG9f5N1jnlu2y8eBZpwvAtJLb3pvN6EXjLichxdN+FYApERZq0p8j7f HW/g+dc97ctCigMG+ciE9npjdvVjeMWEfU7dAW4FZWUk03N+53rQ/eWOuU// wH4NPFXCEM/SUUP6EznQkWNt6UM2lxEBqNNbTP/kuaeNDM7vYfC1oTKEGjqR 0KG2GDbyFoRLmLI9yjuRcNe8+LJfvG9ks2Tfw8zRCDhVkJLxhA5bOZCqMStx aUFwL0KaDRBzxsve3cnmgIlIISjDYuNB6t8wdDiWY4m40+FsL5CwulpK/DHJ 4h8b2UM/3/Z1Q3wWiDSjgaUThg93WK9WI4lqYOuHmn/Nv+Zf8/+L+JsQ4p0s rhN9hhTPSfGQGiKygGbDPXb0JzN5NKWnCnGmiE5k08ftSg/qSKWIR3lynKZb 7OAZTapJLPuHk+FTGnW55wtxvlSn89mTZqNXN1kZ8sOrLD0j8h1WPKYuYF2f Fj39evxM7J+G40vxcz51Ml0+lUCCA8FOsc7PdL+PHbwK0iW6D/dLRGd0qDN+ xDWOZORkLk/m0dFs+ke3dFFPkVSqbJi2j5HsISmfYF0GhONktE+P/2Qax1J2 KpOnsqljbv5MMnPjs5D/GfIPF1mnl3Vfs3yZtSDFC4Qd7jVw/uB4Rs7k/HQ+ dTSbPWaWevHlWMSLazQ5R4uXtFgnKcZ36kavuIkfbePHlB3PwxNp80h6/6ie 7cVG1UrujTN9KkjXefdZEJPKJGpk0E4cs43jWXAmlRXPueNuqbejeM2/5l/z r/n/BfwX+zqRgnwkvSrin3m5K/Nt4QJ+0JAHPSt27Ln1dnP6uJTbZfN5PvvG rmzppnShSIdlckzmW6K7EyZUQJD6MryWjfxqGr868hp1vM1f3cy/m+VHkEzl ESuvq/ykyp7L4pE0hBWB6A5uutH3pvE2Yy9z+SZvvk/n3prFuZZgGub3bNju kQcvhVuRccDgFvb6lzqjL0wDdbaFeFzInfz+c7exoafDXLKDIamPimyLFbtY BGF9oa8v6ZGn1n9U8rUDudmNnuZzj9zivQ9C/D9N8V+XVLuXd9+IdFEkBFNO c305Ht013sOSr5fyUameFXNP080lCw8nIc+uyficLF7QYlOYQGSTwvUsJ6OP U2+z5MsHcqWr1srZTbc+HzdlLAjwb51m6SbrPkU/Q3iuyPoX9dgO8gyedNmj MnpWzj9362s6kjX/mn/Nv+b/F/BfW0VTuIh1e5vmZJS+jvINlfnsQLJDHh0E y6m/bYNdI3ft1MNMzZU0zKnIQl6OqfzH0D0NiydN69Mvkn2FD2seBIsF2cjk Rh4uFnIKkqkvhB+G7GBEZken3Otmthpqwko4v4R/ut/1VzXfMnItCec7ognj TCpfi/RyM7kQlr+EZl61gacQn4TqkDnTeGTJM8uf6HCrEy63xRR85atiXyak +TFyj3E8xkNRbiKatrESTz6NyfMkfKbDDS3mHFX7TP7WFJ+vqv0rsnyn0lkR f1MOiGbiLbvGjmGvbPjcqSdWrTjaLKhMI5n3hfZUmL9S2XpofVYIEfP76eRG NvlCk9davDTRjo422vzuP6ls0fDDDfX7qTDdbnY3VZtgh+tChlmw6IKtJNhu yR0TPrbRouEqJzyv+df8a/41/+/MP6z4M54rejCh8iMP9PtpN6tKQg84O2C0 5EEhPPjZ5UHJvEMWHHKYF/5FsANfHPwwa18s6MWoDOihAPjsKydfuP9VBl8p fPxDRgo4D2epYEVD5kfn9et580BB8pJx1mVwKnIgfFTAUuJ4kOK+tiiZyENm h6fsmQX766ydqvyrOXaFzkRghZcyr2RBDsdT3wj4Jw6X+OLL9G+z+tmsXQ2N D+cH/hTOaXmAHnqMJMRPWWAr8ViqmBmc2rs44/7tgWmKGJ4fBP9CWJc3YuXB mQ958IXgVb7pjTPF8vHIHZl2b+/ZeZl6LMf5pbnwuyIoCY5foyNHI+H0DyE+ CP6hcffPY9N654FbuNsmAjJWI3gpyQELSuwNQUrqZyxAMjX/mn/Nv+b//fnT ij8XBeddQovLq/rxqpGsrES2JYN/4hmXJaddnAtRCA7QDirr1K+Cfu1dSpc3 jKJfGP9S/RE/Qn7173TDWwWTB5VCKa90WRkn3cFlu7SWCnqIttscL4ofaent XMFikNXlmK0ulBKW9kE6s/SZ0Q5WTKA+ysHUoCc2y4AqR11TLOiegKnkB5J2 ryyZ5Y1kCmscUFiLAiqRotiJQUyPsfJCOAHZkNCSmYbo9G0ljxdjhh0fSoHj /EJVKkQBi4GhNBd+/2bWiu6slHUvbtiH6zpiebWTjuNnootuqwxltwQiOJpv m8pnyQLYy0t6fT2O0DMwQ90vMZKkqN0FAn5Z3S+K0CraNf+af82/5v9d+YuK P0fOB5we+PeK8G6KqCHosJJyJ+GL8mBowCwPOTwe77SLIRhQk0MmD7k6xJhL 0UyboZ/2V8q/nO8z29dtk3YhU8M+C1hc/E1tVTKFFxLsC8XSaSv410muB663 nuD5uwgWda1dVKVCDA0hPfkTu9tgMYUT2A2hK5TrHXaLPXEoEgroREtQwyB0 QjiWGb+XQsxFBS8ygQGngUiHe+zyaEJQ2atRzcVilIrRdjBtVVMLCjP1BZ8T 6FdYV0Tkw0Px3NifWABCIM7mWIXB4CGk9KcydQ+CZiHw+QGWaI4+3qoYGTbz A6i/YlWlBtZ0iIzRwm9aec8wklWTiyun8qE1fSNusQ9yzC4Om39zo6351/xr /jX/78+/W8VZiIPwgaCQc1UwDC7wM1UyvxmUJwb1L8PmLkkp1hcfMHEo5BcR feXhV66+svArU1+5/AL8FftyIyh+nLCvb2RrXupjcEGbbhmh6JSLQ/iwED4Q 6VDiG/IvfV7684T5nzfTJikIb1elbbmAf20e8EjzUNOoIFi2BnkTTFwOudWP 4/bxiF31jC+xJQQ2NQOqUSpCx1ROmzkWRPAO8FE8Gwvc6RHzftiEzEDkZQyn gMmEyxbEShZmFO4aojktIUcLWXqTuNPD9pdROD7FznQQbek33SzWTXCZEyzN yGRVWiJ5ORkcHBuyL4f1fRrDXMNiExTjNVMFfIXgkFKpkLDA1PXQZ8VPI3bn my4XgPzrOafmX/Ov+df8vzd/wUqATElGxlM+ZMWYkzczQWBUXcLLiHevNvIz k/kvXr7sA89MQapCvvjjXe9qRs6n4lwaXsqi/pJPfiHsMAKeJD0eZLtBsR04 H99rZfxONtmb3TljyAmjTprmGXf3Wi5uQ1wuIn540beXg+zXyXwBdbxWQhAn eXDDeVdTdjlRV1tRbyYmNSY4vAhZNkbyStda7HrWE1gch6WCkwkZ0sH1RFzV qteoG5owS7lt8rzHN6f9/J3n4Pw+ZEbwFYiSfovcbIvxfTmS8lsZF5+wgEJi zXi/l5yYzN7fyRb91JNGsVRCYki7wa2Mjhk5YuTNqg5RocsH+tN69sTt7K3v lojxsUIEHjM6Ikj8iYL2p7wPdbxqMqcC+z6H/GAsyH/w0qde9gTHD3G/UFjZ XfOv+df8a/7fn382OuDGftKTP6b8aCZ+dOH/SGd/MAvXIfkqFT/8OcgukuIl yTdRl5s2grL/ihk9ZidPZexizq8U8lw+e95sDZi7tFD86zWanmb5Y1o+Yy7g hc/dtRvJ8DXd6CnFUJcNHsiecuGqezTaaTIH8focN1d4/oYWa7QDkbRBiv7r nfHjunE64xdy8XPZPJHOH09WepII+6m5oUbrJMnX6MGrwJCq89rAiBk+bRon HDmdy7OFOp3NnjAbPTrCfRZ3OYjPk+I1ydchPsrEJ2bkanz7J9M46thxK49k d//m5n50s/2OMRNxexn7I+QvSbEVAB+sNxzrSSf+Zht/c8FRJ46mU39L536w 8/3YuC3i7kpgfib5K1Js+CZgbULdWF9n7Ec9+UManMjFibx5JJv50S1fSSOS hbLoJ/lxkm2xcieIA3yVl4/2A39T86/51/xr/t+bP8t755ORp3rycU43unKz DJ/kc8/s5hKMv1Ts4FzlL/1SZA+l81nZCLuD227ivQ3eZ/yXTLzNp/4tnfu7 W3iUK3kQssOeSmf7TORPFMTrLhf5xHo2+nd7539a8s7xd+7u3+3M383sBlYr N1l+IUwvquwXmS/LFuWZr4rBR53xX7X3NqO7BdvNm6+y6dfJwtzelMBq7iG1 f1Zkq/LgpUzQ8oilw0tm+I2dfJcHr3PxvGi+Kabfp2ubOkT++rJsXeDla5Gv od+suSN132pn/Jn1HuVsq5QP8X4XtvXmHMRlO8XTiyI9L4rnokC/cUj3eHp1 LhndNv5WQde7bP0gelguPtEbM0nlB+4uMX2BFbus3MR+Cm1P2L4FM/JE+49z 9qgU20W0W9zfMSvz7fuQz/KDfpEdE9kj1OXukyAhgemd1zX/mn/Nv+b/Xfnz ij/RInLBkp18YshLrZ6bcNtGyxmKb3nZZAeXouxcWLy7my6HmU9hRg5RLHS/ JMsFW8vFWh4ulCI8RMEV+xLSLyNh8VPTvZpKN8LCp18FK6WfClrCV+hCLhZy OV1g0TTBfvdNlvaG9sxU+muULyiIX7lkheQluVd6a45sp/yRVst7/F6HqP2q Y3J3VO2fUm4rKp9GiU+d5Dlujk+5YNGRDcMe6nDNqPsJnJxAfKSmr5mcupv/ EroFmXgM8ikjoo6/lHhPEvrcqGdJ9ChRyykLswCOJ3lvaE5F+euwWA87Hu9I lvK7hbeZNXZMsJvIl8nUro1WUxJh3+SQmqthcjYqXofZWqTRf5tZ0XTBsvMe a7rrxHYcPrRiKeb32gzWMynGpf6hmT1W5Xa01xCdUMJ4bM2/5l/zr/l/d/5x iHKmUqDO1onAsaBgPu41V5vg3YgeDEblmXnz7/MmEl0UI+FmfSqCLve7PPgK H+Z/ZdXONWNfJPsyKQ6OzpnXS2ZaHhD6BR2KpCakHTZSTg5Rxxt8YbSL+9Fc K5rdUPb0vHk365po6+cq/6WugDF4hfBT5h8QzzDalmhVdCjZ19thcvpB6+ls tor3m+D7PVgS9AsL4C4sIykLUkqwiAP7gULAVfHJef1m1qBfayWUwg133/JG wuBnkHIvRRdxqtGdibkbwpycte/m0mmJTRM4zwTtCq+LDTRpJoKMNgrqZYzt M95W1E5E9sSse7+g76uUoC4r5ywXwQGHr/gHLMiZV8DYGDtgDH1CfG5+eqCf zdnVsBNgP4i85l/zr/nX/P8S/uizRw0aXEtsRiADh4Jb3H+H47uSlT476N80 W/OOkBJNRzmKozh1Qh7QyQPpHXDx9f8X3+K3yJeBlWxlBc52wL4pbPkBRUdT Qyd11DBcViIu/s3KL6M0HV5NVhcNIR3O25WYyqBKSqY0yLkH05cxui/RfBu+ Bdfq9q3sLa21mqTFKdqcoms3huYcjV4nHTq4wh/RbTVFqRVNBlbilSWN7t9A WJhKmmVQxxtYXjnHYpcE9u1nSpntW+s8XMP2Q5XyqrIE5PjMwClMrqls/eDT Rt9CYX2a9G/orSXDYbS8kjRjSUvBRElJxv1KA8yLamllVamIvbZiV7ZMhDv4 6ONd86/51/xr/n8BfzwyoxL9qFm1kbE8qCWKiDKsv8NSC4jFB7QJGRbuQcNg 0Kkb+5RZn5U91+z2oPsXf35YSXBLTg8YziDERPh6gZdA/+2MivzycPyox4Qw HSh2LbA0g1U1cbIDtCs7U82E5hAKKZzW9g649SHs10DFZ1nRQJUsTKvK2N2U iLbkLVFZp6JlqzTXRtz8tfge9uW0yB+rP+BshqtKcEUTxtqo14L5oo6IdKjP rA13Agn/2caLVlUSgjo2pSWsRuBJq4cNVjIgz91Qf7o8rLFjEYrBDLYcIpqT Do3g6rgmETVKbeEruZDd3kG70p+EEnfev5l+A0+I5iQ6FHcLTqpFjhUl1T/V /Gv+Nf+a//fnzwsh8klmTgzr16P2Ac2DqigMS8PUoYi6PDyoRLNduHGOwSgN RT7QSM+Op/92I70XHBD+bQq+cNUV0SEP8Ss0LLEgAqObkaK8E6Q/3XCvJ9yS X0yicjXBvmlhxqeMiAo8eZRyFDWVVMRKuDskPTlmX4/G92mbyLzKEw+5/MLD Q1gMTH6B7zKVVufHPkGE6b+Nmqfjbt1zuG+O0gIrpBZhRwD/yNGmJQpCMMZ3 Kdy4706NuF9G4pB00H+bJazqtiyUEQotvllosUsC9o+Dq5s7VJ8cMW9H7F3s NGQwUtMOh0APzxXSwiUE1l9UumXU/eZ3guLIiH09pmeDNKiK+DCUw/nDrpBf iSrgZrGchGMpYs2/5l/zr/n/Ffy76C/Ni0FPH2ukb+5ka572eSF5JmkWjJfe 9ZRedOGVVA1m8lZBaZfyLBLFJT+94BfvJrNlUvr8q+SHgnwNxgr/mqMXnLjg wutGjVtIr1CnyopB4uD8u37+0Ec+ShaClMGE869ZOL+8lDZ7k/AWTn0gTCjS wcAe87JXt7MNz/rii4Dzqy/UPwhGC9pnRZ9Tw1rdtpSh1Dbk6TjRP3rpE1I8 CRIfmyYYAWBv/On3/MnP74fndXg1VmOaEUCdwvFXGuacV75tZEu+9qqKaclT ciclI5r2GQHPCUNWTsL5M5j9UNrBQB/30l/uZCvE+himAeken0z8kYQOdMJB Lcb2VQOmsgwo8Mn6vfRYI3sxmW16xsN6QCchRvtZMJLSPofjHzGykTOREqxD qfnX/Gv+Nf/vzz+LSCbRX1qfrXRED2mLcOvRtPeqGT9q/FMZPVeos3nzeLpw wq4OWQVTww5/JvYy6b4m2QZME//qkYPeHjt2zHinM3ahEOeL6FQ+c9xt9hrF dCTSa9SdDvKnLH/MjM8KCEk9A3bkpPbOZPxCwc8XzZP5wk929To2+oRL9FJz Fg8udwIX8ENCD0d60tEf7Z0fM3oi5yfy8Eg2fcQsX4mbQaJEPBgY1LWSYofE vjCEt/pGWiPnYu9Szq525ZUyupAvnDOrQx3FsBbvImtdYgfPSbFJjc9jCjM+ ZMaOG/9oRk5/899Op38yK9dNk5awGntIfJrmL0jxkCQNlgXEjQ7tTRzX3rGU nc7ViSw66maPJss9Tggb8fwKTc+S8ikrH5HERz+QfBTu94hpHEnpyRSPP5LO /GCXrpmI1vxr/jX/mv935/834K+bMgt5flWaMyx/KYtN2Q5o4kvX98iMv7f+ m4w/z8WrPPolXXhrl1dStBJl3bPSXuHd1yJbF5BffA3EYf9DN/Kra7zJ+bNS 7JbRq3zunVvbhNCmI5Zele6MzHdE8Vhi/KI8H9xIR97bybc5xeML9TqffmvX 1w0MHu9XJWdE8VSUTyTkVl890e1ZsiNPbeNxwTbQDzzazeZemtWHdkpiVV2/ iE/y7KEsdxXEOwj6dmRVj/6bbbzP6Ntc/JJF7+3M23h+RQuWRiy5GnbOq+KF KjYUPG/EkFINrZiRN6bxOuM7BdspwpfoN762gXUcktnrQp+RqMvdZG2fmUAk Q4ut8d248aKk213xGMZTzL1w68tJSNPKr9uekrDeym2uA9wMSnoXktEd3Xie 0+1SPO5GO8XcK72B/udpzb/mX/Ov+X9v/i/1+pqBUNhkWb8yJ8Ps3b1sUbUD hsoiCanQAxusGbql5YZVy6m4h2YUlB+GNLvUNOea5bswXZYZ8BfsAI+fPmhs 5vRpqrZdCF+ZxWZtkH9F1PWp9HiYvYryzTD1WFeiH8VBcM+hzvaxkdtGrRs1 l7GohNFGtDMQuuNh+iLMt8IswMq+AxYdeitp45kjL220m8pHVk13mHAU4ilP h0N9LMx2ovwR+mPjez9JDIPf5zRfScSyFtMfhfpEWRueLiKYr0ifirK3UbYc Vv3msKmcow9Sf82QR5Y/MuF6HM7gKziG/emKgSgGPq/CfEnGPtFSaK5iOt3x NjV92pHPjHqYRPOWhJaKGJbQgLIwnudRvhFpj0EGmojQBHPOf5j6T1rq8X60 7aKFlKrDmn/Nv+Zf8/8L+C8if8oTxdIJoc/OJO/nbKQ0BC/GYsEMJ056aNPN fMf9klbe0Yzhq7nRpj01b9/Pmbsyo1iUgT5+IugK/4AHXyrpaYH+2xB6RK6I uSnd0Rn7bt7OqjygZWXl94XDL2hhXVBSMj+rpL8F40bxzm3ZPTKr387a+RAI 5+jvTeH8WqCtd8Y8wxpZEHQ46UiWwPPAbamPzZiXC2421KRSVVVb+YYHGiYi COAucJNFCOzvJqmG408s2Tfz+i5PKNOVWAsOdhx1yCkhOdwyC6yoJL6C5jeV OT5r3y7opugAMc7gYwTV3LMiMNxHHW/lZw73myie3lAp+nXPwHggv4MMF64O R+bcAyxtSTrMzwEREKCs5l/zr/nX/L87f7/gpERdEIcswAyuJ5sLBi5dmaMa GCf+Ii1rWElc1XQ+rXStaC4d8LxvPXm47BgMFcW6WHfABW7ocJqi4WrVpB4V tliVgBKpnrXk4ZqV9IDxUvBKfYS+fweUwKwVTKGyl9JYEAu3IIi+uma31nXI urQ6nonqeFEymgFJKvc4+yi4FtzA5Sg1PasdSGcEBQIpinhRxwsBNKYNoGSY NLhZz3Fq0K+P5oOrdnE5YUG7MvdD5S0igsMAYyODyIvOfujXh1JhSszAWry6 hBhhfXI4Eh8tgFKbQ6CHiIy/l5U+ucCqCpZdXjOb6zakJUGFwLct/hylxSQR gUVWPMXB1/xr/jX/mv9fxZ9iqMXKtVALleIvfA9OK5jjwjW4HrimHw05UklM sQSPOoE/C9rMhCpRnlTpbL/5eDOJGxkL/ZWEFfcdXGWpCjNSkKlCRhB9Dqum PAdV64FSyINrw26lV4fYxDOnwjD2p2QtHFJk5FSJRt9VpQaDccLMym7/QLo6 gAUjAQ6yg4hgtcAKCR2PHM5+VUYBiwooERFfH9Bb/VqIpOJW9XGAUUGgV3lF GD4YfAlGVXxbeH3QrvZCDMUKceTMc7xrYqmqpLykEt8KW7VdQBnw6EBnYSBW slPd7zeL8hKWJWmm8l6G5q7VDGIfCli6ar9vOF4awPNXCmHLav41/5p/zf/7 8pf/4m+4aMNpeWhRdKrgLnQlPYUgq0OeD/j23IT5+4QJKTpaMAqXdgJiq7Rc ZpUItqx60GDEkcw2iD06bF+NJPcJamLlv/Sr6NEBoRYVs+EXKtHHm+Iru6JB i5/G7O6oXfDTQGB+R2RHhXAYNqxk8isLvzBRMJpw0VIczp8fG9NvRux9yKpk m4uYV1kVVzGGTgVDwlo5QAQBToj8BomPTbi343aGxETAfSE6pqwIY6zsgCUX ws+UC5RyCZ54QXxk3L0cMwsk80VWxd+CqkyEmivLQkMjXUlnvzXoSe+w5PiE fjFspoO46uxTVF0VciqxNQOROXwFmzIwnE0cP7NHxxM4/3SA+zKUtmv+Nf+a f83/L+HPWFsR7Y3GwdU2Oa/F+SS6oqMRQ/2UoD+eueSbi0HxfjJb9GyDFwJ1 qprcMWzUsAEjB104AbGpJNjHOQ2lG/L1scn8dSNb8WMfO844FSac5MFYSfqd 7LfhUCHuQJw9CHgRiWI4yI/cyZ7/S5fbhWCneEbuFMGQo72p6HXhcComU6oS Jroh/zoSZD957lUjW/MTT2BJtZQJ9TUZS+hAzK8n4aBWt1NYKhA0FXP9fnLS L1762TqB4zOMeoH1R/XkJc3PaXEhia4lzZGU+DaorLZHaPuEl+56+aMGsAJi RpLMG7XBtZheTMTFJOpJ1A1NKX7g/KNB56iX7TSyTb8TIJ8uJnd+Qm9pOqzZ oFHjjhNN0Z3DNHk85Nmjd7IXjWzd6/jYmS6RgfZr/jX/mn/N//vyD7ArZdLf p8dOW//nnF4u5OUyOl8snLfrY4nCq+sLtH2Fla9JsUKSIDAQpAZ6zMQRGxzJ 6fFMHcuaP6az/8MuXE0lzRRPr5LkLCl2afGQYD8aysxYrx77wdz5yQUncn48 Vz+lsz+Z5Wu20ikVPcSeotlj2n0WQK7UJaIc6LOjR4x3JGXHM34iax5J535w y5dsFJTAv4dkJ/xsl5YPg9jnhrDOyPV4/AfnHcn8kzk7nUfHstkjbqXPhMxJ bq+R+Gda7vB8iyUBdw2a9PUnI2etd6HkV0pxuQjPF3Pn7NpA0mRW8aKP6dO8 2KbdpzCnwlCue4aT0TOanC3IhUJeKKOzxdxJs9wXR7QdCt1P9k+S/Aktn5B2 wC2hbmSgc/NI4v8NEDlxPJuC+/3BLVzBTZ9QmGtEnyH5M1o+4u2A7TeI66v5 1/xr/jX/786fsP1J4oY39Y1/s/6vGf0lF2+zqfdu/r2ZXUkYiyNuzytzSZYv RbEiYyJjGE/vuh17ab3dPHjYpWvdcKuYe2weLtkp4WDKrkh9VuTPRfGQJ4Rn HrdX5ztj25o8ygn6XRfRs3zhtV1bN5HMQpZfl/YMzx6xcle6gB0S3u1dsaNv dONVRp8V/FmunmcPdvX6WnxPlop+vc7TUzzb5d1tAfkLhNROz0oy9swGjwv2 sJSPu+FOsfDarK7BzaaKuysiPseLFzLfktbjkOKZkQ09/kvSeOfoq0y+zqbe ZbPv7fyWlTB+agaEPi2yR6J8prRf1WWPrCWj/2Yn36XkVS5fZdGbdOatXdww TYXdlvtl65TMHvPyKdc+i33W6ZvZG3tivScwni7f7KrtYu6Z3VhNpkQnhPUg 4H7z52GxKeOAffZFe/gh8g9q/jX/mn/N//vy91RbsZTe1WS+TZeNWO6Es2gx FBDLedxk7nrTnGlmb1S6FFpPVPmILLy5mGxq77nmr3TzhWluZuxuCbQjrJvQ p1X6ppmthsbHrQ0t7qb+euo9tfS5kc9t84lrLqLhRoD9HbJB5Y5EqFPdjpzH DiB/kbIMZgt/vUMfJ+KxVhttNW/ZVEohX6OHA1F2tJm+isrNCG42hmSQN42/ EvuPE7pr5U4SbcXhrMHQWdVlX1f2jMrfNu2STD1aSAbZkGOqReF+V2O+GotZ rZQm+LYQjrdjoT7azHam8q0o8SgQ7oTM0mbmL6V0U/P1RC511D1HcHdGw/Gj ERyfPg3zR2HscVi0mkUtuthqPOqQZ4nYTZrPbLhqWRPyLx0x3a+SUyr9ZSqb V3HA9xXvwENLzb/mX/Ov+X9//nB+HrQEcTxoS2IZcZTklMYcSxJaiuc3Q316 vvN22t0X6KSB0iZqGE2Ur9G8OkiFX1CvW6mwUsVg/MmpafPrjLsvM8ItOhRR K72CNQo0I/UPmHdAgy7a9FX9lO+o7KfZ9PW8ngvz4F863lwEJfdT+ElJwTzc K+cUWzlL2p0U5ZE5/WbePlCxT7VCKyQnfCtQB1syGIyfMVJJxYQNWToa6jMz 7v28gceDoNqaJ7g13xakg+auvka9AZppGFhvMB5PuuOz+vmCmQ5twCpxF7PY UtmDmy1JABcynOB5Kh2a84X5adY8n3MLoQ5QnwC3nPAg4X5b+Fr6jnld6hfV rj3E33QC1uecfjdj7sEaQDGY5qTmX/Ov+df8vz9/A/yJ7AhqmUrIbRMFloqc Y1P7uJLmdhm1fWvJ2oqVFIbtKgUpGo3i/jvLK9NUU/l152heypMAEq715PES ClwZjr9SnPICXaZh8KREAS3uUxSMlYiOZVfX7MaakeRLpeM9QPdXkeHmPuny Bqqk4CuUpZy20BA1SHsWOytLbUFx84LTRLAEDbHx/O5fftrCVerWHPmw/cG1 zsZ8QvyE4fs0lFThrr3oED+WgeGos0XTDMLaISwnkg4smeVVWDYZ+nijLzda ZzORUR+mwPAwqRy/XeXCCpMeX1+MIZ1ULKEQTLGUA7K2PSk6lO4rklSCZE0p POcksLoIdf3remMF+CTfxMxUxDX/mn/Nv+b//flXuqBUibhB475r+vGIDuB4 hu+dvtUvcGpw7zuynGDRQdUpIGOVm9zAiFvoN6GqJoUVFMbGPjPSJvedmjIQ kSlvS4YWdgA5kOlIr14fypnsfqu8QDdvuBYpaJSJZs7JAWeHFMVLcJVDoYpr Q3r1um4yWAMFWptKWC0lPiFIzSNYM5js4KNCpculwg4PmKVhg3biJMe6Dzg/ oKAxjfaYxDVW2YDDH1GyBQusdyhZHzIC+WP1hC87WMrdqHRcMmck+xcB4VBg LNPrg2ajV0upCUZe+KcEUQcxUx3RjBmBYLrP6T6cnPA9GbYGhlrL/RYdwtke hecZWKtwsxDuVVXVgjrnb+vf1fxr/jX/mv9355+xqiRBybjfa/08kf19zDSp I1jvUFWrqYJHBYtyFjoWucqPumqaAFlDkBwdtc+HzLyfBdhixgUiUarFFNwR dlLgssS2OxDXKPrRjQTZ2RH764ibIhBMD5Az3JfMeQifgquSRV+Y+lq15nGK f5kk3R/G3c6YXfISvF8Ck37IZEFDK7AOwpCow4StdLZGyewWcSeGzZthfZdi nYXAuj8LrHhomNqvSidcFe/gPB3JOzdJ6/i4ezNuHwQmwI5CKcwmmdLqruER lnKwMKcSHw8ocyEv7rD0xwn7CpacZzyhq+KLGEYSRO2Qt3loaaipQj0wwJEi meT66Lh+NaZnKJD59lRghLI8dJXUOQOqNMT1gHlrzb/mX/Ov+X9v/jmFTIfm IXMXPXeRdH9ppEsB+hFJnqBtxY2c9Dve40SvkUNaTWpsnSxSKcwN2jrqpU8m 8yeTzpOl5F0JsxnEwUSLDu3x4U9T4x0RpAFkXtxMifyKl/3s5+8ns6UgC7DJ cgG3Rm6lQb8jV4y4nEQ9mRovKelSnkf8y5BfHGlk217xzLcNCaFQoy3GhPN7 Nbkai0udsKelbiRVLTaOv8+PTzbyX/xsMWh51Kogw1Y7k5oMd+jAvhzQahxz JYiDhMWR1H1BctrL3vjFKgGeKW6+8zTA8cT0shZXEtWn5UTCSYb+UaIcJqj7 3fWKbS/1YF5waRnmJY3RFutviWvtsB/G06IspjxpimzQd0cb2WsvWw9cA1uL ahnsBaNt/5oh5408r6MrJhy1NMC3fyFLa/41/5p/zf878w9IqrArfXKeJVfJ wWuWrzHUEQU07u/T40ecfyxnp3J+Km8eS2d+tMsXTBTkktthHh8j6RY9eE4M wQrlcvS6Gf1JN45YeiJlp9zdo2buqF4YhgQE4ld+zjeXg/INzddpirosWvRf 0xNHjHcsC87m8lwRnUxnj9qNHtNkmeKHvdScotkW774gxqd5wNKBUT161jTO 5OxCwS90ozPF7Emz1qtDirqv6zw5S/OXpFhh+w1hKLWDV5PxI9o/BoPJxUnU wS4cswvDkDR1Iqqv+MlFWuySYgvWG7MBc4N9ZuSU9s44eq4QZ0t1Ips5YTf7 TERsyMpemp6k2TYtdwmM/xBueWg4Hj2uJ49n5EzBfy7CU3B8stq73yRJJIrr MH5SPKf5QxJ7HKY46R/eHz+jg5/z4FIpLnWbP+dLF8zKmK751/xr/jX/v4D/ ebM8rqV0krnzUl+R3TciXxMdn3UIbw+u65G3lQ72aSkeleppOf0iW9/U9yVa lQ7xzknuNlF32oFkqsHdtUU99sz6Twu23eWPulM7+dJzszYPqUqmmD3Lk+u0 +0YV6zInrPBE2bdlRt9a7yX6XYsXRfQmn3tvVzctJDuKFX3SneLZtuw+C7XH IfWzIytu/J258z4lb3L2KgvfpDPv7fKWCUWlsxLxWZ6/hvFLTWTaULZ3PR57 mXrV4OWTMnyeLe6a1bkO5bhrf0XEl3i5K8otjh18AmaHVpORN27yZYH3u1P8 X/beeztuY1v3fcGz97JyzpSYySapwAYqF9CUxZzFoJyoYHutc5/o3r2PLZHd QCWkJu19a0LrvIL8D8bg8JBJNFD1qxpjYnZ985vxx3LlF7exa2OuY1oOC3tO 5M/Z8Tvh81P/UpGPrGcTB7b9qcDvS/626vjx/5at77tIpBE5vsPMJVa+FcUu TwL/CK4mdpPpf7nZX3PyuRBf8sf/yld/sYsbUM8uqGv4N/wb/g3/H8x/Yd3V vhnV3cf2aqf6Nc5XpA5pj7MUjk7ms/aOwy8VfW3kCzu36dhchUFnVbSkPjWX vYyqF7ELcMaxYx0XbqjgmcIvU/FKx3smWlKYG0LzCOc3O/pmVP4rLlZkGdI+ 5F+8Qgsu3DXkueF7LtrK5BNYGkJ9/lVNSHcqzj/Mlbuxh1MylgsCRhlo0aEN SzZttOaiJz4U6vr7sf6I1Bfmii9RvgZ1DX5GOe/YYLNsv3bsrRYvErmr5VJK oGoj80t2L1ZXZPUxqjaFQdhyqiQ34XwWPnX0hZEvs2jHynnwZSU8j/3bhShO zbmXcfUyLkLwD+9zVuB5g7Y02nfshR+/8uMh7C/EXIdkw3F2Ps4/x/lWVAU+ +YIDIEViR1ZTup3RzVwsHHJh4Tim4d/wb/g3/P8W/gRaGAtSTUfFxQ37ednE oKFSDFrYZLXfteOhZqh24QbBLeiXfP4ViOwfC+btUrYpbQBmrf82u2YBfHH3 3bKbILCqg3hH7GRsr6zZfy07n5uAnR2tKOlzknGwAfc3L1lYkfrcHHz8SBlw d3rVvV+zixJO8CkvCQe5F8UZC53/CAc1VAY6AaIpzme5O7Nsfpl3T6TG4IPn 4MA9rEDxiwwNLW07ghJOTe2DlE117Lml7Mu87ciUkkTUfZn9zXloBZhp90mY E+hMBxaygsJ4fpqv59upQjAPL/x8OS5AgfzdPxxZOPen/wP3p/aRqM6uui+r 5md+/H3/UFYyGJLfqyfYjwpOfGoFQsO/4d/wb/j/aP4Z8AcfuQLjkuN8bNuu rvi5fHcWLeo/GVA9+f9F4FxX668y/t3FFBcD63prT0uos9YMpEeKMkd56h8B pRm8VrqCatd4GpjasR2zs5YR0qe1fWut2nKg5goK7kcujul3HW/9FEaK0bVs bctCxRycm4PLH+Vgo42w420jQRaVEe6XWFORc1rc27R70F6tqiXE4I8NQi9e eTJgrA06YRDNEqaE32OkuLvttte++fQTCyVol4BuNuPCMGS53xIwKT8F/+gU 3MLpn3c23bZPx0Ak9ieYx8IAcubTyTAXs30q/4Txg7VsBRbcNBvdzDbW6xMu 1oO+DLRiHM706YNMopO640NZW/M1/Bv+Df+G/w/m729eO0tDDYXzIQYLP8EE dK3EcGKhvoCaSLjhabN018T0//pXQ92BjzWKRo7FPuZqIMDSun4NYvf4YLo1 7plbCDHgUw1fwUHNWgyCK4Igw/L5Sz1IR1gxPOR2hjOoy/BxFny2LSPAn3AP 7XtxnKsJnBBWClncmTKrg/qxvy3/voXA4rX2D89kB8qrodwDmiD4rXISMDc5 oLZaFgvtSULdHPRNUP4R+HHG5/yrRYlYT5AUnuv3j7Sj42pjNJXCZ3YWzv1h HY8Z/pNEJQf/cE/4mNI+g9YPfhVObo2ALjdiIB7m9C/YXRCd/Y76k4KO19Ur qFiddT6kZuxu+mK8CIUWgLpuFdHwb/g3/Bv+P54/hDDL4xw8paOcxppFlkSK cr8ECaAj9nTL7I677dAi4O/Jp9BNJtI+VPnRgr+00N+bCwietMJvVybdrzM2 hhXJIagxDW0dZMUhgPrHFVz4Hx9nK8ndDM7OTWa/tNw8qULIsKBvmohLFhck LsBP2382hnI8BlOuMK3+477bm3R7SAc+3oH+yv81Z5HjIuHS1Dphx2oIET8Z Qe76uP3nJHQUAux1vTbEPgGVF5j55M7/JgcfDGi+oGaxuTjlPkzZ+dD9O4+D esA/mehzWTF5QqMTKvsEmkcoyY8f4uN/TGcfWm41SDH//p6Q8eiYxX9CRyFZ 4shQ0a19wv147HCQXpvO/p+Wk7RA/BunR2AJHjX8G/4N/4b/j+YvfN6Ei2DC oXua3NSggx0y0X2LaY65ktQ8ou4/2+5pu/92VoeQUvmJfBNB2h43ZKgrBlU0 rvhDRSD58jFIDwRH18Lq13a+GCrsLyY+wKW4ZdGIpXcdv2ejsSx+5CO7j8JV xIt7gbsYVJ+CfDPI2qQU1EhSBK0suGPIdctv2M5dHY1krJ1jUoIfCC7/V5A9 RdX7WROwsm6OmaP7Gg2l5E4vGkjkiJaPMiL6389xboX2Gir/dztbwHnIEp8t 8sgRYslDR6c0nUn57O+wKNLU/ktqAqmLs/mH2XILWSSM4Fb6pCko0VRGRiwb zORoLh/A4DF3MeuPoup0ULxFxS5JAjAn73N8Eo6XwU1HrxtxzcqBXjx96F9p /KtFJLLrOL2J+v8K82WSh8L5HehfABr+Df+Gf8P/B/NHtZLq3rCduuTQ5QJf 68ur/fh8uXQq37xp5xBIZ6eJO4WyDfLnAYI+xaGPsJPfJs6o2TMZvlSyy2Xn bL581m6M2AhDldxtrG/T6iMu1uGkw7WJGxrU9y9acrHAlyt+sd/x9z+XbY44 CecU+U1irpH+B9DlWsyLAGdDA3bqvAuulvhmX9zsy2vl/GW3O2x+htOQ40ma n6b5Bjv5QDT4e3M3MmXHLtngfEmv9vnlKj5TrP9kN+9lAuomqqvY3mbVL7jY xGUgHEbJ1E19/z9t+z8yctqJ81l0Jl26kC4OO5+4xTy/S80V8A/v78N4ckKL sWE9/Q/b/keBwQ+8lKeLhX+47QE/3yzixwO4OI/LV7h6gRVmFpP+XdDx2vBq RW9V7GYVXa1Wr+q9CS1YGbHjy9QN0OoLztdx5t9n/HzvDZmGf8O/4d/w/8H8 McvaKBvfs1O/2dnP+XcdqTwo5w/s5p75WdiI5i1pTolsk50cCEuZw9yObWbj B679saRvKvGuij/nSx/t2obySZmk9pZQN3n/Iy82mUXEIWFH9+3Ur9mjg5K8 rvjbMnpbrHywm5uOk0ISd0uq67x6L6odphHNA1GN7duZLzb8VOCDUn4q4l/z xX+69ecukieS9Vu8+Inna+T4EzEIzJH05Goy9lk/+pzTdyV7X/mPLH12O5s+ OFYR/euqyO6w6oBUOyRDYPfXvbeupvdy9LRP1v7ka3/G28crO25nCYqmJUoG ubrCqzesvw/KLhuSfGhNTby3weuSPOvz/ePoVbXy0T19ajqy4NgO4vQKrV5F 5UuZhdxhVozs5q3fXPtLQd5X4kM192u+/JtbXjvk1PghXeZ2gPc/8WKLuZBm WOjx/YZ/w7/h3/D/O/hLI3yqNZeHmw4/U3zfyB3Ll+BsxWcHEXMPWf4fc247 6r/rqJBoQXLBC7yQBVuK7CRi+5tYM/yxf65FTEVEDXbUlU71SydfEmlIrSQ5 pxY9ztvrGfN33tZ83cbz/uIC87ID/tjmsih+nStXYxMSK2jFaIkfG7Jh6FMt NrVYzninpASOPCQ9fiDK/+hkm/Hxh8c6rPVLHHdplKC1HtlP+F4it41c7pOo zr/In7c67mpU/hIVm1Ee0D5nGZlXwb5pv9XowIgD3Xmpok3FOxZRE8nueN1P 4WPcfxr1EEs5y6VU4Ure3tXkjeZvVeeljldzv29JAPnp2Fx6Mco/xsXTqAxY 38OU7Bj9XOKtEu9lcjeL1nI/fky7lOoOym/G5lZU/jaXL0sbQocjOMRv+Df8 G/4N/7+Dv6MkZ7gEqSqqKKpY4MBMm5QM/qsZcz8tZk9X7U4H4imnihHDkaVh xrD/rCZhRgmIsjCHM477XF9ZMZ+WfeyuzU6/WxvhqtbuljQsea1ThVN16I/j JqW7vOJ+W7Y+dhNSn5sAVQdm3ciA3BdBhUjt43oC59q8+s8lt7PmdmM/fnBq 9SkYJYqjLkeGYM3CgqITsOyjRYT7k3Fxftn+a9E9EXB2A75SOOffnVT94LEC kTBSYCrOnOc5LfW5BffrYrEQgR0fHO5jx9oFC7UILJiBez5hDrpimcZUzwh9 Zsn+smznRYGg03QOEiz8Fwv/AjlukNOg8AQIM5ikHezGZXZjzf225PxKATea UWgJ0fBv+Df8G/5/C3/raYDSCddSWG4hSIHvnP9UN0Ld4SfJ0tP0MavPo7mu LUM12FaH0PiAcDiOB6dTlvpbYZpMb/bWVjIC93R1C4as1p3mBJXcjxBMrS2D 1vb+6S4gbuyp3lrWCKW16Z8W1FEKcl8SaIHA6QhO2GvrV78EEv85tJwt7Os5 ENOW4Afob84cF4phy8ISTupZH3xiWSZ8lKf9OzvmOfhd599FxRQ+AppeOIUB woaDVCD1SLnPuZgZ2NLPN/2mUrUOOUNwccGlo0yBYgrun9aO3H3/aEzzgS31 bMOnk8eEw3MZ6IpPGP8L+S2NoYMDLBbtERD0logUE9t2aynDfmqwPx207Gn4 N/wb/g3/H82/9lkFdzgnwV/ard9TjwX0zaz7C+RUeBSaiK8iSqHwDZrRJMyH YJ9NcDM4ZHeH/XhM3aRAU/8I8pX7YQuYHbRmgKYJrm6yUCKRj4y5rXG/cLV5 KSAtPQEPrZZ7aUpSTk1tjg2FHojroSG7N+bAHxv0t5aDQPcvAo1+MiIdx37D 5H5BGSl9quWzpKGpZO2uXxe/HMeMQYkESHxxhecKMVdSQGHqRfR7w89RTY2q 1VZKpGb8iLNevSipwCZ8rGXHR+TvO83WXYf8UtrRCb05oilKRZhA5QVU1R37 MeDHmejkHPfr/hH+/qXwnPnxyD27PQlNnAVYTnmASoD7a8kjONlhoQ/30MGh 7mrR8G/4N/wb/j+cP3cEw1F1G+vzk+rtZL7RNm0CwRHqEXys9OFPZlwmNPYL YTx2wqxk9j6xZ6fd52n7M4Jz9lrXqliUirjHpaU+WkU+Q8lBcMuKiJUz2F6Y cp+m7WMfoyEp8x/JIeiLuleOX2ih69CvKNR35y1kL7SyX1vuCfaZna6L/iC2 8rhgnT6NC/iJMio8B8thAySnZsyzMbPdLgL+P3UdxAkTfrJ+8BWRfQqca/9t SOLsLPl2eVx/HNcxVGRA/IVqC94T4NSd09jA+HkBlSYQl4uApBda+t2E+5ke cZnWdYIZ5xWLjrnw9y+Z9GH9e1VdFvO/xsP+5Qn7y5SVUE7iE0M/axXznEd9 Iv3+yUknFxw6uBHsGv4N/4Z/w//H8/cXY+pimk16/ti9DI/322lQOyxBSjVr g3GFB7v8diLvdqNJzQKHSdZhZji059vl57BYxQmimkOTSo2meuFgl945iu8k 0ZCOHtQ63rqv8Si251HxJchXkQ05rLhPjtBsFkwYPmrYqI2mezyAHMdHvYhn dwN9GZWf2uUmUgj8wDNB+/hBhoYcvpWzm5m8a+PJnKHK50ecZ7PE/EeQbbfL 949syP6HsxNBT0i7IpM5HsrYYBZN9ERQYJ8G0izi+l5oLj6qPs26NZQiBt8c +kWhuEemLBl2YsjJlvHjwdz4+fqhTiB7rp0dBMVTnzOCI0cfEkOUo6mcjCs+ lov7OUfHSBaElR321812fq1d/Css5qnPW1MOeauijzQazNGAlQNOjtlo1uen Df+Gf8O/4f+38eek9lNF5hIpdsjJa5KG0HzNtKb0xGU7e75A1yp+7Vhcq5au uKdjWqKig90dkl4l/QNSbeDEEw6JHR5Wk1dBd8oGQDcbXy5XLtjNESthvvk9 lF0i5XtU1nV8fpB2dMhM/+SC8wW5VPFLZXQuX71g1lrKh1rJ7XVibqLj97ja JQmCr/6K4eF84pwNLtQ63itVdLGaP1NsXXc/zzpBHeiESb5Gjz9Rg+n/YPrX yEg2dcoFP+XobM7PF51T+epPZvWeH0/u738TJzdo/x2ptnGKaYJJb/Kem/qH bf+UEbi+nDuVLZ1VKyM9z8d/ZIhkl3HxBvf3AxUy0OVODunWP2zwjwyfzvmp fO4/8qX/zFYHM0n7EfvrEsrukP4XlK8Sv99SFKajA/b+2ax9oaBXK369mrtU rJwzGyN+a/nxN/wb/g3/hv+P5X/ebPjAxwyjepyrC7zcZSevWIJI1weLiQU9 8UbPHjjyvuLvy86BW/yiV5/6jKzf4eYu11dE9ZFXm1x5/pin07uHU7/Y9mcH Ot53ZfSpWPxk1zfBH1uSYoC5K7x6zao9ZlAdlO+um9Zri170yf6x2O933hYb 7+36KrQ2lii7wdQtdvxBVLt+8NQRYkY39eSXrP25wB8q/q4SH8v5L9nWKzs3 55G6+9z+JLJNcXwgfcQ8wex4ZMOMH6jgXUFeV+J1FR+Uyx/c5pqOff5Iizuy d41X70T5FL5v7CF+NLSeTL0z6C3ohOmLfud9ufTebW4YKbRk2ZAwl0X5kvaf c7/fCkTV4JqaeAN+42S/os+q+FWx+trtrNuY9SX965JwA/z4E8vXuQ140Y7S ke3e/XcZ9uN5U4k3/eigWjlwa+sgWm74N/wb/g3/H83/o1tdg2/PBLVTIjkX l/tRtR9pyEeYA+uM2OIlx7Y13UrFSs47Hp31+YvEyZi0FzrllzhfjV0IHeTB whp3NF75SrYN31Fyw7InGa6rMDrUjUp7vlO+j6ptYdoU1EcsyoPlLNw19IUW +zreVNFjjaFqz8TCDnR6N2T1uVNuCP9Qx6GZZoafOLTh8J7hz5zYzeRaCQYX 8H1gPsuL/zXnnsrqTaxCmnOaC5qgJwo9Vfi5v16LLS0WNBiGMKgruReZi1Hx Sydf8fOlSvBExEm4qvFOgp9p/jyJniqx6Ij0KaT26zse2bNR8TYqn0WZH3/k N22Uh+tZ+EKTN4q/SuMXJl4vaAxLH9O/rnXym1H1Wyefh6I8P8IMxwYtW7Kh 6J5hezbacPznupMpVG27hn/Dv+Hf8P+h/B/n301HGckCkZ1fts+X3YpUGPcY NoTAqbokjmODQsVCAx3kmQ89qaDfZnl+acV+XFRz389TWA7qLGIpTjlSoM4N CowzTDIO/dHcI5GfXXbvFu0CA1EW5RqRnIW5D7WUJAxZXPu+cgYnPgJnk1F6 edn9czGbE57A9z7IjoZWBo6DKLdPw1rTC0fYBSW5f8qZZb25avdjG4ADau37 SkA3639o6GqdrZ9CbSpIbEvaiyugm438TgOpVcqIodjSMGVIE7DszmlowDeD KknsQ5mfXnHvl+yq9PstY9wx/1CkOch9c4+LBSUJaxtAchyR46G4urFsf1vW lKdwzgJKMD9Ox2HKJQoL3q4oLkGdBS61Df+Gf8O/4f/D+YP41jJcCFwMLyWr 64lklnBHwGdVcaG5UAj58edMGE419YvCeuC2irOJDbXq0yVP26MjPmQntXW2 YrjreYIpHzFYgA820MD54LpZW/MLCtBI7TvKhBWinj7YZRuYFIijch+S/CoP PbV7q9avPq2bRIAKSxgm6se1c/BrhfN0kHIRlvuQOjqfPdk3jzm8ITAQX5Wg +5U58VsiBONuzjQDPQCYCmJkx7fN2nICzLmuTcIhNFMorLP+emg/AQMDd1m/ DwUthjbM2raKSS0eg/uDnSAVsD9hCbhfdL9JLCepz+8ekf7krn66qAJwrCo4 Bl9Z4p8uChHCWoCwgdeOr9BUouHf8G/4N/x/MH8D4lueY1ZBxwQ/uyjjyGde PmpYwT1kOAoZnEjXR2zMTV1HYMEZu04ZKK+rJIgh9EjQLvcoPEBphsbU+rCC dvbUCtDfGpB4EYukoZ1M1HbfPmjiukUO8anfsF6bthjEYK6O41AKx0iKOpZJ fweQP0ELHjgVsn4/DE6Z5TvmCc1R3cGh7pKQgRaXFSw+IcjCYTop61I+UFvd HbHbw6oOx2ldWuIXVIGwyi+l6HH4JfTlqTePQTwZHDK7IxZLU5sNprXe2DBc glF2pDkx3x3F6ff7CzM8ojZGUiEKMNNmPtoaWrcQwnOQNvqBweaBIovc0wh5 PnnPbE6A8TgwpN9RNPwb/g3/hv8P5Q/BlHogBeJ+5BmLShZVLNZEGuCMreQZ It0zk+bttFvFFjEohQPJq/AkPWpHpYaGMtJHz6O6/4IN/PXT+t1kvoyywMc1 n3/5ACcyIXNwyQbpqeV13PfAI5FNhfr6mPulZXhtdg31Dp4D3DOBgogoo1Ed pKBUDY7mfTb005TdnXS7sybk0DyasJIIx7iJZEnFnzhWzH+kni8juh2mp1vZ waSZRykRSd3xxwqQB/vBK+Z/EykapcxvNtDTuimUnJ92nyezBZSC7gs2lREy 452KdcDlu5bmQusHv7KC9x/h7HTLfJw0C6REoNfVYAkrKxpVxFP1842K+mJH uI6ZGw/d9Za/v4uh82lVF6fkDf+Gf8O/4f/j+YMYlZY4NGErpcNWjDoxbvgD C9ZDIpmTaixUZ2eLd6jcRbbNCulTHtwDne09Q+9occdEY/56KGHGLI344TTt nUbZ63a1F+iAGR45EfmPZOSBxR7yhBEzPsTnfonD+tzkbmhuhv3f2vmCv4b5 GKq5dCiweColY0aMKjmpeKDhyzfakyy5HyanH2ZPcf9d4O/Q9+srSBk8zMLR hNzS/IYfko1HNJ8tEHX++gmUngnKd2HxFKUBg9BM/MINJ8G1FF/W4koa30jj ka5/BIW+nG4IpRfC8kNQbYVHIZSWZzQ0ZFyh2xZf1fy6jm/pzrhmQYnrupKx 0J1t55/CYiu0oc/4qBJI4ZZG9wy+Z4DPqBGPHILkTvv5DrT9fKuDIF8kChNo Y+eTNew/2/Bv+Df8G/4/mn/ZGs9a5037QkEul+JSKc8VC5fsxmjS4X78bpAk V0j1BvefExPQlBA9NN6buuLCa2AuLW5UnYvF4oVsc1jFWEVMjxBzDpf7tP8C GewTHGrHx7Lpsy74h8PnSnq2jH/KF39y64OQ70hWXKdmAPc/k2Kl7owcIjN+ 007/w4VnCnS+4OeLudPZ0imzMmgk7kqmx5g5T4ptdnxAXQjplR2dMOMXbPti iW9U7EZfXK0WruZ7o7qDjWTqHlUX/fhptU/8DnGzVA9M6MnbGR7os6ETNnIc 3e2vDbjdlopBB+Xu0vQKr97S/j5LQ5CK2cGWnrxpgpsFu1Px2315vVq+YndG 9BzOJcvuEnMRV+9wuYdAh9am6fBwMnXJ4oul58mvVp0LxcYl4xNMVndbuE7s PXz8DhfrxO9POLdqjTX8G/4N/4b/38DfJ1/ja+nkO1vrVEv2qnr8vpg/MJtb uuOjJy5HInMxLp+zco/oEExT7eR21vps2p9K9LYSbyv5oVg6sBvbLuKpYG5M JBd4vk9PXnMYPCJ2ZNmOv3TBi5I+7bO94+h5tfIq2121kng+9gY3A7z/hWcr whBSPBJmcFtPv7Zov6J7J/zZiXxZrbzNttZNLBNJkzFuz/Jijx2/FRpRH5ez 0VXb+mjav+Sgy31fdb7kK79my9v+5n7J8hGhz4vyLS/3hUEkw8K19uz0P3X4 m6VfMv456/xm578kixta0FLQbFCml2T5ilXPuGoTyLNmtvT0b3r2f2fol4J/ KTq/5Yv/cqv7VsoqAv9Ye0H6+1fPhfPxN+BqYtdO/eLanwvyoRTvy7nP+fpH s7wCX7X56H9Dmju8/772J8c+OxPZWMO/4d/wb/j/LfwlJB3hzw6td+nTlO/q aEPxJwrzgpA8JmZK2jNR8TrOtmKLaAVHySRHUYKWEvrU8Z1crmnxs8ZwNH8U 0XKG90533Iuo/yJyAeipfP6VoRUd7KX4lRKvtXxhow1D4swvZUTsHWluieqf c+4JVwgOIwyZc8G6Dp53yWslXiTxXi9e0ziCUyEfT6d5eiZ2z6L+s6gbUsVp IrjFc5asqHArFRtptAztRDGckvslyKZkejrOP/2cr/uMj9ZiMJRR1qWPu2Q5 pUs9/jilVBFsav9VNyn16bn8YK7Y7CRt5t8orIA/afLEknXHNpxcNjzOCa4I KyPqJqQ79Tg/iMudKAtoxQSUopOORn7Mm4ZvJdGKzygzgsuQugi5gcjejKvP c8WSzDAtGTQVyhr+Df+Gf8P/b+EP/RdILkBx6jjoZi3FCnzqhBU+B5HuzIr7 uGKeRA5T6HfmRwtucuS/I9CplqDdAn9pS1kisPVUf1qyLxfyzSiH/gigU80w sjyo7+/n3s5o4EB/RcFzeyS2txfcbws+0hlC66MWYlloGPpGSUrwd9dr4MPh IN6FQp2ZVy8X3VrcC5EWLKnVXI4FX1lbUbBgzTh24IMEboF2lqcX1uyHFdPh Grots1p/5ReOpAz76w85gT6hYPoKVksu4PbChn2/aR/79wcYvAXVmf8Irrhn TkD0y8E8/Bhc/qAhnTu9at+v6Seg+wJJAxy1+2G0a/Nwv3ZgVJ5xnmPwCbFT sbux5j4u+rUu4QSfl6zh3/Bv+Df8/wb+nk/pQxI0muSWhoojzXjhB8ZrHyTQ 3xIztOE21g0jFYHOCAUBtzqHQY4LulMODng+WEO887Pu4Gxg1aztmg5zMGyw 7Lb+YtCpwhmKpWCyB8EOziNo+kiosT21t6h9cgTH+p4/1tCtvjYspTT168Ig z/LEepwkLHT3Vnsb2zqmCWH1eTrRnPkA3Q1xT7adj4CEHHFsamlxxkI7uaqX 15TEDjYJSKf81BIuvoUP0zjoMg7Oe8L/iSQetWc1vWqegK4Ykju/fzjXMAtR hu1cTmdMZrW59zGIrIT1azG2blfW/Wr6OO6IHwz1gbgnRJfNOkH8IkJ5OKwL hu7VmGYTW3pt0W/yCky8KVSOgC634d/wb/g3/H8sf+iSwEAlRYUZbamNsURC LFAwcoh3mmNLRAGWqiHMVEB9hIV4LYqxCbUyksUix6DL9SEYqiGkj1bCsg7I tzx/PwUflCG74bbVUkujKed+DAlIWEHNZViYkMdGSgdhlzlU9wPyWRjiemZE rU2nFBYrIbQrwJo15USTqCseK+ieA3qtjPrFghsmwzNqdSKZYymSh5yDRXZd Wqi+15JDlQR8n+Y3gP/T1zbtDQ7ql+OK0B6D9UqBP4agDNUZOOU+KYORZHXp HFhkXxl3O3f1Aphp+8h7Qnz2hAvoVcShKgQq+OrdBXGcJ7NCj97T+xMaS1fr jSG+U9AJWwqiLGhFQX0IBl1Zw7/h3/Bv+P9N/KHKwAbEnr2fvZ10y6EKaCH8 zX3o8bEmskwWVOYkzmgMfXOgboLlAcnOtdy7iWwF58G/ORQkSnzc4TIFmwsB h+OYQPbhfxAz51v2zYSeJz5nMVDXBqUZmkvNhV/iHBSzPhMh0JVMgg5W35qw H1uO1xXQkE/5TcKMECmTRz7I+lX25KGlAvETVCE9vDitn0+bZZxipjA8AiYu pPGzoDJloJv97hNuOD+cCA6vPcg/P9AdeohEF5M/It4lHf/KcQQdeUTCRIL9 3EXGCRRQBMj+50z28n6207YhvCRkUPQtlYhAh8ykn0LPU4JNBX4m+Wigrk9n /7xvfAjm4E9bIA4jIVHOowxFGfiHi5zWm7Dh3/Bv+Df8fzx/4qOtT8G4nSH2 TFi8DKqdMAllIXgqiaYPLBrTaMCKgSwadfIBXFz7XZctbM6GBehs2y4A3SmY ZuMgoff/oOMJH1WiBa0qkQCLJMHK+zg7E+Rv2/km0gGU2nmMHp3GMz06ZnjL ilmo+0YS6pEjbu8ifSOovjzKF7CPgz7jM1DXRrr4fo+OH7KxNGoZFqRQAMhz QXULp2dm89ft8ilSAdHQZJPZ8EGKhxS5YcQNHQ/YaAIcPCBFYsk9/McdVH3E dol0fdBnkaEPe7N3Lbr5lVzpsStJ54p6PKD4Q+iPKZltUXMa5Xuo/6oNuiwu HGyqsTS8pfAlwy6rzq2jeEyzNjTTjLi7jdUtUv4Lucck9XmfII4HNmjZYECx m5rdtJ17VrQcRRWojhv+Df+Gf8P/b+BfdjC0vBwn6SWa75LjV1iByR7PRsfT yXMWnSnopT671I/PFUtn3eY9ExGflZRjzJ4nxT7pv8Ya/I5INjGuJs+Z8ExB zhf8XNk5BTrblbtOhuC2N8ncOVS+xOUe1iGY8unWkJk6ZdqnM3o+l2fzxz+5 5fN2vgXfzkmmb2F9m/QPap0qEgpj3RrWM6f07KkMny/5hSI6XSyetWv3tECK 0+4IPrqIq31c7OFum/slU6OjunXJBlf7+M6JuH0cXa1WruVPJ6GkTjBzk/Xu kuOPpFhlR5jqWWwHWnZqKMcjx2T0hE+e8NGTpcH8+ZSe40YwPcnVGVZukf4b nBKSE5zfbZnxOy64XZG7J/zecXS7v3rT7kyp2t81u07Tu6T6jPLFMPVJ2UNi h4f01KUc3ejT28dioC9uFUs33MaErvnbiYZ/w7/h3/D/YfxvF8s1/0gaSdVk lFzgxa7ov4KmyWCmN7GqJr7Y9qeCvAJdbudDufQp23xqpQBL7TGhL/B8T5y8 oj5fywgtJ9fs2IF99LagL/r0ZSVel/Mv7faaiqmNaT5K9TlWvGLlPreYuoCb u6t66rkjLyq816e7x539an3HbfxsBMpj7MevBunJB1FushRzGwg7tGZaL134 vGL7ff78OH5bLr11q2uqw7qCHo2yr1dp+Uz4KXwLmV8yPbplpj9l6EPO3pf8 ffH4S77w0ayuJJxrz/MG6w2ykwPhVmg3JD5bdNN76fQvOvhnRn7Jxcdc/pIt /suu7kFJuMRJi6tTsthi/Zc8QRjc/O6vuKkvdvbXHH3O+UfQ5S79061sGyZS QYpbTN0W/S+8WBKJzzQDacb21cyvDn3KyUHB35XxQb7wxc5v6drfu+Hf8G/4 N/x/KP9Fz39TUa4kS2eEOhO7F6J6FumAgO4oYpb87IJtg58Z/sKJbSc7ioHU qpDEtGR2Ki5eRtVOpKC4mBeRT81+Nu3NI/LsiO+nfM+KdRt2DIf7uymmznTA v3pH2hD8tzM654INhfZS/MLyVzp+5sR6HkYZYa5Ds9udZED2P8t8WWgMDqVO RC5cVeiZwi9S8ULN7aZ0QVFpsI/XJG3FXy/NZe/jYkPokPiICZzRvKarmm3B j1wyuON/CdmcIOlAp3c3rj7F5gnrYQqVgyD6EhYvuHBR0aUj/rMGK0Lk7w/r 2ybq1Fz2NC6fx7qNjQ/iEqwIDX6i8LISy6lcUELkhJTQn5Rndzu9G1H521z+ BDqWGg5NRQ2aM3glxeuWrNto0Qlhah9CJblq+Df8G/4N/x/JXwpoLsloymke MHVu0bxacytSh7T236M5Q4YFGUcFrS2jCU8icO1zPl8IeH5qyb5ZzlZjOI4n rKx1s85fzFEO0qmgwCFY0oHxHc5xZM8umbdLboEbjBJBU0oMD1MWJmD9hzPa drRtPUwiTETtZEdfXct/WXRzdX8fynKOLUOga+VIMZ8EBRqFiSAKDmWYmuXq /KJ5v5w9gY4GFnRcFL7fo9gKlHqMBIEcl0NVINTxjXfS22v28yIctVBuwIdc +Pv4xKrwAZH4RQHn8K6/knHrP+KzwvML+eay2+BJ6PcnmOlloECD83rFkAOL VxAt5IzqiCT+febGmvuyCN6tnhit/Tdqi29NSFbbdBe8/iWICmjW8G/4N/wb /j+Yvw8NPhjR2mJ0eFWvb1pOcl4faviLBeiyPMyChhll/nooGaM4jYFGNbhh 17eNpP73Dn7PK8ozLjR4n7YTzP2DNJx3E8156RdleFn567kfpPRPTChLKVh8 90AWhRwR0KSGsiPGUuI3AM1Gts3TFX+l9oPxKYwAd1NPCQxROe4S/3Ge1OJY 5R/ht8rImllf1R6aqK08KO8xpgg/4uiQ1dpgvxyMeLBdqCuh6dSm2lxQ2NPj 361WHbgRij4JMhZoIhUVCiy4salDth6btwvbpuMjPoisoOUQkK+/G+R+41E4 eSF+k2B/sb+tnQKdrQqhvTJIiGvJGawCCjOGwL22tp/1o0pra9mGf8O/4d/w /3H8BXEIxmn9AMCYDvy3rQBFqOeZEWlEbRw9Nm6WhlIBgQbEsWDTTUuGCj9H 4dMlCEYaxEisItTFIh2cckt3044fQ+1r7UOVj78UZ9A9IVIYfZMY+ntS1qPc MzwaG+ptzdRiJ6h0S3wU8/z90tcD0Bw7jC10rgF/bB/I0tFRtTqWUHFIadcP HkPdhF8UjaQVwr9LdDm8VGSUpJIpJA6nhrprLQUerUwx1mO851cf40PGD/0F FPsg3qs/ktZuq3/eHTa7wz5Sp3VFib8hFGhQKDBJZaz9ywBsWl5wv9mgRKU3 1FJro1pyGKcP8Yz534PNOIn8mwDY+vmgD6V2YB4LvYeGR8zmBOR6HFArkO82 /Bv+Df+G/4/lD2SoIv+ukgPjUyJLHuVUZFCXXetsH2FztuWeTalFCIuurr8A yw7ayWmswenCf8rHXAhJEKAZTc5O2e1Ju9nuBfSr8NP0zxWlEI5Hnn8R/pyw GNIZwv18zVSgr09a8N8mHoiHX4OKLJd9qP6L/Th9xqQ4WKf6lMc+DNJLk/Z9 yzwhXZC8Uh2CS0bCI4WkFlJxrkCv618taLfDXQunNybVh5lEQh73vUgwpZEl ccqiIxF1WeSXsvu9yUIssmlUnplyB9PZfJAgPx7cq4fqh+H3gxbcrzLUSgM6 lgvPE6uz0+Z1yy4g+93fg8L5fiGg5iJjcQq7GjahYz4TZNkMsVcm3Ycp08F1 pQa8hDT8G/4N/4b/j+dvgL/PIJDG0wkdUnzYRuNOPoLuMCFz4C+E9fl2+S7M 1ogKoc2Zg742Dy0aMWhAs9uODavowRHFUH8neP6IJKdDu4X6L1EaiB73AZFY dD9rD3bZra68ruM7Sk5aFnoaWrCjwTC5EfY/td0i6qF6xVlYofspGddkOOHD XTnRY8ERpDzQUrmYCNXVIH8fFJuBDkgKVW8+RrcVmUzxmI4mUzkFX7gh4TO1 o5ib2211Myh/Cf16+fGDcgA6yvnxT6Z0TIkxf73P3Xy26HeXmaNuqG0uBsWb oNpGaZtBnthhCcIaTVsyauSIEeMpeIlASyD4HnIG6TOP8jeoAF0x7EDnyZO2 JROGDhs5lLApJbBfSmhd1CHuXqCvhNWH2WIt1IQpn8RRoRv+Df+Gf8P/x/I3 nr/gtjWmJ8/aR+cyfLHiFyrQtf6Ur9+yETZ+tEPMXiTVW1ztYh0KH9TMyIid vuRmLxbkasWv9aPL1eIluzGSdrBPkbJpas6RbJ2dvCOp50loNjGjxm7p2Zsl G6zo3apzu1y+bTenDiOwzlM3mblNjz+QYo0eEtZr43R0RD+4ZsiV3N+fXSs7 l7OV62q5lfhcTIryHrPXafUK93dQEkISl45PptMXXXCuJJcqebHsnC6Wz5pV v5FoTzBzHZsB2v+CilWsEHdBaEeu65l/ZPhcTi6W4nw5d6ZYOmeWx2AdY+pu U3OVVC9ItYe7ATFUJg+mksmLpn2+wFcLdqWML+QLZ9zKgI1R1uF2FOtLuHhF qqdUhdy/nGTjw3bmvA3OFfhSKS6Wj0/nS+fNyhikZhEzd0hyk/Rfk/421I9b il1r1PM3j87lDf+Gf8O/4f/D+ENQQ250SU28tO2XJX3e5y+PxZty+X32dN/G kZEsH+bJRVa+FtW+SANuEXbjW2bqrWl/KMi7kr8pow/lk/dmbTONGZQ2THF9 lueb/OQtP0JgYWEfLCRTB/rRrxn7VPDPxdxv+ZMv2cKmZuxIEnsn0jdF9UkU a7KLaC/k3enNo5mDZPagoG8L/q56/LFYemcWVn2wNpJmQ9JeFeVL3t8VvaBO tSZWuq03avZtQV5W9GUFutw3bmtZxyyV1F4XaoAff2LFOush6h5Ke3dX33+T oWfHZO9Y7B3PvShXX5m1pUNJ0w41d7i+wqsX/HiHfwMdAkvHFtXYcxs8L8nT Y7F7LJ71F17mmxv2Z+EkcaNMX+LlK9rfYzrg5azMR1b09DMXPAezcfHiJHpd rb6wG0tg8RczMyC7N3j1hlVPRYKpQ8yMLqcN/4Z/w7/h/yP57/xf/kwavJwE e5q9NPy5Fju9zoplssQ0lzQfE+qcLD528q3IzhLHJeig8JylazbcsnTDRauW /6wQnIzAQfMjbk/H2U5cPev4+aY+T5G1ix1+YsmKlSuaPUmY6MFxCUsjakaj 5Gon++1x/pgqROCEWrIuiRRazvCG4uu9aEmJWIV1X05/qwlhLkXF+7lyUyZt sLYwYOg0p9CGIvspf6GjfcOWelRCY+gYH8H6RuWvj7MFqUOiYmroY/UIdL9/ 8FcJe6Wi3a5Y6mHuh5TExIzEyQXQCfe35CEC3axlPj9d1O2dXvhciWepeJrK FQPuGbTw8XRC2AtR8TYut0C3lgmZtR9btmTIC41fm+h5KncSsQg6YcqtX697 Mr0sq4O4XJfdgGpJNIs8/7Th3/Bv+Df8fzR/Wh+dYA3m2O2chuB97ZMCcJDG YD30QGbnl+2XVTsnc5Ck8hyBk2rOQF5bMuIEzgmGE2dany8Tmlx60n22apc7 hwHkR5mHBi5zyF8JtkUMwUxBjwruSXZGpDfX3fv5lBFTO4Hk/g4cF5TkIAwj iqOklq0aUM8iWN8rK+7DqnvME0RSCa7ahmEjQiuQBalwO0c4gfFDv4Z0VKpb y9mvS7o+3FeCJgwp8MQmXYLALoMHGvv5ctCDSZI9oMnFJ+btE7souxjMqTTo xzyWwPlhMKJAQItVrQfIJLaz3J1f9OM388Jg+IYwC/wWkpkMM4ydQBoDHzCD wsjvh9TP99xC9uWJ/Zn7fDPlQoEoq+Hf8G/4N/x/MH8O/MEflVs4YvaB0i8E 03XHAVdXJUBh9ci22dqw9SB9EpFBFzNaCFGEyPmnMF6Q7+fLYJ2aC6Iml5Pl DRsTH9SgdBoWixRUGBYoMWt9uOHIMmIZPfSoCbHTG2Z+KanNUR33wUhqyruC G4ISgM8TgnuY9jjtItKLwl5rPV1bBTUU5VrQFPvVYSAhY8iKwIdjTXgChqjg y2raTE/uqJ0FExAlwBnVwl/BMLDABKYJ5ngMRGiE9ASc5ncHN7o7GwmnPb8H oD6F1yosEACkhHa5+IOK/ybMX+y+W9feW9cbaz2PunZ8zcBdnHssWe1JaMFk VUAxCIb+nn6+6t623l1NBTmqlcOpwKbh3/Bv+Df8/xb+UBABpcd6vGVXRpSU 6t8865QK0EUO1Ee0qIsIMkQhCvuQOjxh10dNREuYiF9HkPKWvPa4ZlHO4Zea gBi1qEeS3RtXuyOagzAJKg4Y/0YomF0zlkC5BPMR8Bv3eRAULB/6hGh4WO1M KCI85y6PEiIV4j5bSSVURviYm1Coy/OPgII7n4UNjpvNQdWBPj5g5e1nQaFS w5LosLZp9SsIzXowNHfIfcI4M6RXZnwaaCPSxeSIsC5FqQgOw87XaO6I4S5k RlCc0oPQLNOpR+nciOqwPwj7/6j4ymv1mudDIs3nUr+ROGyqDPQA1CGRzQzb lWmNRem3AfH7xC8WWDklaO5Iduo7Q2c3JRr+Df+Gf8P/7+GftrkT0EAhOTft 3rTcAjHYz45BURv345cZkwWPChRBkzWPt+5KUMyS7OJ9+2Ymm8cGdK3M8/8G nRcEHCgw6eAbJ7iPD4hQ6DFL9NkH+vP9bIFq5PMOaqF7AlzZZbLHYv/zB43+ gG445FDwZCpILk9ln6dN7NMln4XhBNOUSxt1/GA09UsAal6fxPn8S0FVNXGn ZrI3LbseqpAl3K8m19D0RxgCatucQqYJTqfYZ200mwrNrXH7aVJD+wbeJeS/ KeuRqEtlKqAwpEeYgsVih4z97u8vRO/CjNoadxvoMIRkreszuO8ldeC5TUBO 7JNKaDBHdMRVC9lbo/aXKT/NOonz+4SnIvLbyW+wLhVJ7RxrI6YCbhv+Df+G f8P/B/PHzHaYCjGcC99H+nQ7e/uo2GqbEHvCKWQlgUETig1afs/yMU1nlZ8s InlEi8nQXQjyN+1yPQB/DOkzL67wrMGTGo0k4l4ih3viARyCUJpEzE0Qew4X H8JqK0x9jiN8cMcmbKng7hG7mYob3fjOt7mJBAeKkG+SqsGwdzOsPgTZEuoi H/6YITAYE95S9GoqrybRrSQesXQ2CWlXUjuDzNkge4mq5yhpQ2c3TQOLWxoN ddkdxe+aaKLHA//+4IF0JTu6G6jbqPxlNvsZxLeez+8RdHyzaLYnHxyy+1/Z 7CG8GIivlP8ufeqHk1Nt87RdPQ+SNs39louEv8DQ4Ag9TMX9Hn/U9esbSuuH GnE7MJvcCsp/PcrmsF9En+IZHjmCnUfEZnp0+kg+PMIUvvxEGKyuGv4N/4Z/ w/8H8xf+YmJj7kaRuYSK56S/h1IsIK+ZGFFTZ2xwLseXSnaxjM6UixfV6rhf lyJi5TABnaq/fodYLHz2lE2M6clLFl3O8PWSXe9Hl4ulS259PI1YN2LJMNEX UfkKVTskQcIvgR0aNxNXM3SrwgPH/M5JdPN49Ua+OXPI6FGEkwGa3KHH71i5 BpmLDUg6NKVad7JwsMQjx/zeSXS7v3g725lIO6DjTSZZcokVu7j/CtYXWjkP Tqmp6xm6XNLrlbhWPb6Yr150axM9BrNObpPeXXb8ARWrUCee+kW8P9Z7cCEN Lmhy0fILZu6cmr/YnR8+5KTLybc2/nqWZOv45E2YBHWftYf3k5nLaXDG0LOO Xcg6p93iBbMwbiWxPqW9jvU90v+M8mWqoT9daKfvmZmfLPrJoTMZP5/HZ+38 eb04YiRYHTb8G/4N/4b/j+a/MGLiGE5Vxri+yot91t+HzmgGMT28mk6+zdGr Cj/rs2fHj9+VKwdudV1JMFkqRoS5KooXrL8nLGJ9zLLJddX64IJ3BXrTZ6/7 8UG5/MmtbKiIZhE1Q0xf5uULVj6lRxi6EpuJrd7UZ4U+5/hjQT8WnY92+aOa X/pG8JGPdwO8d0f0P/BilaYILC/UzEZv5qMJDgz6mPMveec3t/CrXtxLmQ95 JJ0S3Qs836L9V7QXEuj4Ob2hJj7r9peMHFT8oBSf8uW3dnVFCfiqUN/mh3fZ yTuar3o+2IUkGV0+mto14U5FNvt081hu9xd33Pr8UYd95eLwIf92luUr7M/3 NAVdLlVjP/dGt2wA1x+zNbh+edNuPlYS5zHKrjN1j518YcUK1yHRbW7vrerp ZxnaLcl2n2/35W61/DzfXlWR9Flh3vBv+Df8G/4/mP/mivI0JHMtYS7L/KWs dqT28YVhDaLZRRM+dWjfyGdptGPF44xwg3kuiJkU9lJcvJTlNrchrYSw4E0x Z/BqircStqui9YQ/dghOw01MikmpL8b567jYkvBETi2cp0cKzSu2ckTXlJhP fdDHuEepj9d6KNY358p3Ml9Eum5qmUtkiB/Sz/8tFv+LLv0Xf/x/BD2iqIfh fNznXH9ceKyezlV7shdSx5mTKKVCB0uObaR0PeVLis85TA3MFyfDnaObcfFJ lsuRClgmWcJiHa4rtN/Dz7/y/T/i/UOxntC5hNLDGB8+koenYrcpT950VAh5 q2bRYbjye7D7R/hSsdcqeqHkRsbiI8KzDnN3pLonq3/OFU+4CYiV2PE5G2zZ 9l7CXnXZ6160343WNZhvEN3wb/g3/Bv+P5y/oTL1oVaw7KHQFxbN60W35DGC 1xw0i+d+7kFOkf+Hoe0S40JQRwlY1T3i9vK8e7lgl1ity/3uMg1n0JphEMTi MOX1+T6F7pMmkL1zK+b9sn7MerQ2zSbEIaT9I8BDG2cYW0K7YLXKVExdS9qB JfVqyUaR8TAJNDuoLfjwHyL8nYT/Lw3/i5PfOfX5mk/QekweXVrW22vpgvxK MCwlRd9EOxXtjD5KiP8H6HjBxKMWFfQe8qMry+5gPu0wE9Ks9tDW8NNOWXBI 0CELExJ8o+EhxYeSfuX425mF9OlSsdfptSn0cWDiKyX/zfDvtSxBY2RBkIyh f0RMjkY76u6S+20BnMOxv4AZjqDHKMX+BeCQhD0SJKydMA5faXLgbxr+Df+G f8P/R/IXQhEMlRE+Ctf+20YSKKbwQZPyHKoqRAa1DH7kpAJzOay+Vx9Qko9v 2uV1KB8Am24KfQQIaFkNQU4EmnK/uD6VU8xnT6QrcTq6rtc2Ekb/gGYHxODa N1twSwPHSYL4EWOHmJasNrtGxExtmdUlS33EhzNu6HFPuSP8kKGvLPiDcQ// /1DyFSop6BEPe615/fPaISO/E/6NkCOfhQn2jfFuOzSd0PhYzIkiUCQCllP+ 4+Ob3eXl32snqJKAVSxYuTJ+xMFztQddGOC/XwX/yuW3CB8NLR4t7ponrIvp kWCH4LPEFYVTmG8hAiGxf09g3PNP/ftMwNTkjnq6lEIzaI/F3xxua/xMASBN sA+7xG+/FJGs4d/wb/g3/H8wf+kjKUoZKxn0JshJx7IYWsPUrtT+B+KdT3km J8zKlE+jilorC0UHFFKGnEiHhc+k6uI77oA2+JSmoy29PupzOg2H7ywBy1Mf rXAOZ9ACijIo1UKYABrf+Cnr1rDZmkqQTH3wxf5ukN0kEMRFwQUU4mGac1LA JsE5o92xyaO1sa4UCSa/C/qVsZ5f95pJgkWPkSP/UuFXE8dpxFPc0fcedLcn UyjoqOMgKMTAbVvT6BsRR5QcUVr4lwSM/W6xQnRnptLFlk+jIPPyW6JW7R75 +OuXhnVAduXpeYwCwyk8472JqaP5iS4Rzr9m+K2F/WV+C6GSdZzgKaI9qAQB l/LaGJZ1pye7SxM9wlNGEu7z3H/zzxr+Df+Gf8P/b+APhttwpoxZLiRUXoAo CxbCPiDmxqR5P+WJ1cV00DIM6qwFSE8zLByoc6HCIoWl4Q6R5My0eTvpFpEC /wqfWwnLhaFRJSIjZI/Av63kFvEul70pqu5MuQ/TPYF9SHJEQKWGjHLaUTwq qf8RlX8KIT6byxku2zi9OqPeTpvF0AXg4P3Nw6F+G0Spvxv2axolREAc9Jw5 tz4Kn5m276bzxVpn5RfLR3MOu8VvLb+FUhIdMeHnDhYcUP1Njm7NHL2a0HNY 1aYc37hPGFlXyCPhQ63skjgFmTHLuH8JgVrsP65Md/cn9VzYAz/zuvSDSiMj P+uKwIPS2jw2qVs5uFncuzahXk+qOdL17xgS3k8a/g3/hn/D/2/hn8akDNsO T1kyqumYicYNf2QhKYM+yMVwqK/PFp9ni8UwCSn0HfbJF5rVZCrBw5qNqHjc yoeGQsvmzAfN+8HRudn8dVjtoKTNoZRbUofbBo0bNqjkUFeOpfIRfLkH5w7k cLR9eDMsP8+6J/gwJD4kVZLm5IEKhlI2YPiAH48jsz5Sp4gbyUyLqCu4eBOU 26EOofNmItAhmknDIUVuJ/xOL7rXjVopQxoTFzM9QdJzYf66Xe2F6iE7itBX /xqAHig0psmQlSNKTh9FgQ5JD9WWGg9DdaXtXjyqNoIEvtZj3yT7StERmTli E3+I8UMx2RWPoOSEsIJw+4D+n4uP7IswW2aQb/ooD28yj3qspfBITkdcNKVI WB8tQV1GPoHNFVy+DO0y+t2PX2IXk6Lh3/Bv+Df8/xb+9yf0zCUbXizwlYpd L6NrxdI1s9KycaQj6e4QfYtWH0i5RmzI/LroiRE9cxl0rfhGyW5W0dVi6Wpd iE2gm8CkSC7T/AU5foZVyHxKlU5M6skLrn2hIFdLcaWUF/LVc3ZztP6mjulB 8u0u6R+QYpkehTIJmJ0Y1NPnXXilotf6/Fq/c8mPR69Nfq+zU2M4vU6qfVrt kV7IfOp0NHH/29QV3b7cx7dP2K3j6Gp/6ZrdGk3niI/yySjrnhPVM3r8Gpu2 VDhKRkZN67LFV0pyvS+ulp2L+eIFuzje47C78nGsb+Finx7vhD6/OyT8v2am f/f3Dy9k9GLOLxbR2fzJabs5oOMA6lbGWO8CLV/jaosmfocgrMeH9IOrKTmf gb/35WrufLF0RS1NQRVJB2eDWN3Ax/u42MC1PwlT98cb/g3/hn/D/2/gj4hq LaUzz037VU6el+xZFb8qF1/r9WXVgcMCMyDSm7x6L/JVAQ5CSNqJLTX1zqF3 BX1TkTdl/K5YeGdX1kHUGqNsQnYvyGKfnbxkoCwiTI2tpRMfTPC+oK/74nUV fSyXDtzGqoUuyVzf5FAHcSDyJXpISPJImLEtff+DC99X9GWfv6ni9/nCa706 n3xvYTzG1U1a/dt/m0IxxeS6Gv9kw/eOvMzZuzL6lC98zFZ3bEf6/DFtycNz Mnsu+i+ECUJFcDK+YVsfHPh1v6jYm4q/yZdf6P+/vfNajiNJ1vQTrp2ZaTbZ 1JqERkFQVGboyCzoKmhBUIEARXdP76ydR9mLc3Z7WpEEIaoqZaSqAufYcU+u 7SOwb9KMF5jqFJFfhI2nZ/z++/IGpG+hUsmwE91SxSYvttgp5SeCH04sHY++ COr7Bds7U6W/9/wP6cZOrHXQ4OGYCs+r7KXo7QjI18K6DkY3gsm3mf0Kry/h +FdZ83mwvOhxFSgd3JfRddl/Loq1sq0PlX6tVfGv+Ff8K/5/An+iMATLOcNW fLoTyp3IXY/knA+hVpHUpea+E19xip90uiCwp7xi2KSezWV0LabrEV+L5HKo 3BTyC4sljp0+5t43jfSF03vqRKX/diiFz2a9+nrIdiK55TkrnpxFuzz0sqPB /YZ/0+3/6KRz6pSILva7dxK+lJAtj+52xabntHw+2+GqTRnEx6jm+Jed4o3T W3eCuu03UDzssdmOvdJh6yd641is+nIOnZcYHE+jRyL8q5PsO71tHT8WbUcH lIVMd9iqx5/4zk7I17tqvk0lVoU4LB7V0Q0n2xTJqvydqV+F/N3hn+jMKV07 prunbLPbWPHcpYg6CVWpI5Np5f/VTQ6cYgOel3mMxkqlbCmyt3yy25VPQnet zeZCLrtc4PhHnOCS29/T+bLjE4FvCBX/in/Fv+L/J/H3pAwEzxQxaMRqZ4IY BnFKFIoXLsumdHy5lfywmGh0zC4d+XA3PONWSm2DvRjQGTvB/WueS5RsdS8s Rc9byYoM0HcaTflK4auFDYgZCYXlcZLAiZwDunii4V9fSd4udJVE/gJSKhEJ mik7pAQZcpKhVZ1AnbASga26l1rJ26aZ1+ax47kqxFIRGgjicdrh5JTDU6Bt LExl6d0q/HNL5uVCsswNlSi+snGnKXJoJGnK6zGro/QX/VF1oFhYl51rzWBr zluQP0vyMxf/FPyToJ4kHfn4kIuy3SeJvjyy4IEtjs814/2WmRNdmyalDy0M PpJWymmOclwbBcmlXxMQCOrq8FILj5/VWIQuSIpS3op/xb/iX/H/6vzh6RTv cm0g+4C7MIr+qPCkQuRCpA5KZ5ORrWhtBY3mGMqWMsFzhkbWMVZbYO8ASNMM akpRsps6NBhdCprrsYt+dBHWqaFtNfryYb8D3i2b7/gC3VZjKduUf6xtnq4u fmLsg5AfuTzm4gQPkJEgCQp9tc9lB+s1FKyKSLNwaC1cb0UOLhJ03kOTVTTQ DjhrC9ZB53CKrnpcAyLPoSfDTX9xHSJ1F8VOWModMfTlSxAOj0vhAWoJYNYg geLEH235s0sfNPu/kv+H4L9K8RHoMdVR/FjbXqlAS9AtHKs5TiT7fWTpeGnp hD0+0WhRnqAKF622E2HnsBgkRydAwU9xErG2/XRi9XR1NWCsQ4AzJGWQRaqK f8W/4l/x/+r8ATu64cH4vZHxcGUU/meMMAX2u0HBrZ0IGJXEIELxd6zL5iyV ygwOxeujAcdNnEiy/5/ylG7Y+kuQMkgG7iIjKqPR0XC9BnPtlw54HppXyyPB Drk+FgqYt4X8wOUHCj9CSiXD2mC4Viv9UTEow1nYsBheAyDxkQpu5EkWlW0R sBeDlJ2hWrgy7CsVMOybhi8VFKsqQnRedWDYfrkYYNnAOFMu87GReHU0ZHA1 kTCZcp4Q7M4QSMitHE+wn5X4RUpYFRB2T5X6NDrlNYc8FysHsa4QpbwwMPre VidUtBkLHYFDYvB+wjNL5FMDpjntCxTrmrLIMUAgkJO6kdKnjLXLaB5I4cF7 RcW/4l/xr/h/Tf4M+cN1cOvZIsGFSbM/YWYI5C9l3sSNkpnQeRlQILZiMwVX RjbqSM1Dkl6cSN9MJbMkptgxAaOwcGLpwsNiz0qBXRsgQ4GzAiWiaRpenkhe 1+JZeszwo1MXQqfUXeF0hO4Ip83cDtOnXPzK2HslOhMkvDYRv6uFDvM49i8A /h1I5aTyIBBLJ2Qaht2WPGXMwHsC4e1vJ8zeWNIkbZvDk/oM/hMAR4VwxB1f aF/qGHVQsK54UrejixPJu/HYZfCOkQmGq0tBFuYEuALFEdc/C/me898lP1Gy K+TJhWn/6ViCfrPYqwiuD0d2mDpmCs6KZOOUlx/3BAscFY0Rc2c8eTeF2mOs v5M+V12OFtwGYi7XJxY25cGmQgIXScW/4l/xr/h/ff6+Kr8ajdvxZavYI8Wq FZPSMUPBZR/F1pDh90I9EDqjkbSw+ySlqaPMkB1eqxevSbFMsT4a8g5sbTAd kJEuu+OL24F7N9Bjsazj1owj4xEWXST5GytdJsfoyIEf2UIy2WFDp+ReR9/p OoNoSc10m8iPmn+4TzpX7d4Pj/Mm7VjCVwymrM15hz46ppNHohbrhx7ERKYN JFOO9KfI8TeP01d2sUUDG98oToE2Ex6ZDvlYKMd9PRUrEjFpKCwqZWrc/87O Dx7na3ZUl5nihulQ2qE91WG1D2ryP52HvwjyG1O/C3nqCP8h656zkidW/1k9 RN9y5kM8pY88e/SE3A/l/cAZDuUUViZyZVwR3K13B0jv+3o6Z6NSF9Yz5F+i fsInunTkRA8fsolQ1D1JA0EhKFf8K/4V/4r/1+bPadCwE4hfg8zc4L2npL8J kUgawpOJwaB2KbGvFfxu4dxCne3Ktbg1CcE01SK9y4I7ordH+5sC+OdCmpHp oHY7tm702J2+uHembveWrqc7o3GDxZrH91lwhfVe0WKDQfyNCQ8G7kcTFxKK ut8zeaXvXsjXLkQbwxAiT7X45RY/vsE+v2H9Tf7Jlh8pDyZH/emLETkPp6Ty fDF3LmlegIQogLivuDdMTi+R4gXvP7E9wruQr00NRePnosfnUnaxEBfyxt+y xb8mawPw8hAp0Rvk8RVa7LH+NiwDkVCWT47GU1ci61JCbqb6Tti4mC9e8Vtj n+DijuiOs+55mm2xzy8pBFlYCdH4eDh22dSv5vxWT9zqu9eK5s1otRbAOtQs uy2jQX52QNMmjwjrE5pMDIeTFw35Fp63UNdT52I6fzVujgQzJNEV/4p/xb/i //X5jwYzOlEkHOHRDZHvimJLBkTFlkxqa2bqICEHBXveQ93p27x1EC01cVfF 4dmADm+q3kvZ28KMLJM8mFgJJg4M+SEhP+bibeH+kC39ZFpPIq1Qajsou5d1 vi/726h08qg6Hdv1Jv4RPvoxZwe5etOD45d/TNY2DKRmWn68oz5dV2dvBFz/ lMhDog5HWscTL6L6sx7d/Cy2+3qnaG6b7cXAxSq8aFD6VyTwP9vlAYRdmK/B ZjT6zJBnfbb1We70nRe95stkZzWGYK15cF9EV2H8vL8jsX+QLZPhZlj7f/7b PbnZV0+yhe3TldYnRx5r8WlMdr6T2bb8vKuPbMvXxIy1/Ml98/htRl8V8lXP fZMvvY6XlmOJ8xUPqM59VeyLtIk65D51s7G1cHI/tfdT/qLHn/Wd58Xc07DV imZUxb/iX/Gv+H9t/vMlf8lypCe8myp74eTLostoSDFFyvlcSlZivumrjUgt hsIJyj7CsSOSERVc1dlBA/sLlH3EMJ+iOpWzEW0FfDXSTSAfM2awXyfDOohv GtlbN1/XXSLaWvyhhc/mA3szo88i+cR31n01a5gsqAgd3hl0O5cavdc6XRW4 u8FlWzinrHnyeOeUvDhRT0/cZ4FeD+RMDNHcEWbYCb9z8j33bBMGyULOITvz ybr36FlMXwT6pXGfxO5qyBsdiq4dyYg2F51i38nXUSecCVFwFdHlTn3TI5vH cuMPtfKzmvvfQv0qxB8u+21KffjGTV84Z9szpw+UmZGlheyMIa2ArvtyI9It I114b4HZ9x0eDir/tlO80ck8rDeeKJYJHdOFkKxFdDvk24DU53M+k5EA/iys +Ff8K/4V/6/JXwB/hd0NFDfTyru5kLyci2elx3F/GYVVghhpodUSsWP7ceri lrrPBO5TTOv2nQX/Tcu42hciZGiaB7OWapYKFjESMhvTLiZidLqDAMdPL614 B6tmTnWo6Ej5CW1OaS7tRJAYbUhJDwVdHLs8K9aZUu1LzexNM5xVJ4x1BGvD 1HMCQwo4h9M70jaMoCqYSrzRlDbn5pO3C+mCjhjzJfclLAkrZPVY2IFEF3H4 I0QLWelBtvjQMd8207cLyYI2NlqIx4x2lBVS23AWCHrE7V8l/VmK36X4RfJf mfj126XwZTNZVpGN66ojaIBW5AR1xRzw2ilHZRoiUjyacsMbrXRvznc5YMnR lwM40FSSHI4vzwUOPrrwVfwr/hX/iv+fxR/R5ZCwjKx0V5rd0m70VEAU5h4r LVW1hcJX4hpHpNhoAHdDsCfm+GZ3fSXgNED4vLTak4lwUk5CXvekSvAXGggJ 2RAM8mRq+dPialexTyWBTqlH8pUOmJUqeAS0gYVBpuVue4ez44HNcGPFlyzA Cg7U68J4zBfvO84DoQOhfFR50VjKlHBze93bXYf0zXAdoCOfSFBPqwKm0BtQ wsVlJNEfOywdxeN7q8HGWuDYEUHL8YDormCBgrHhxs0pl78J/p9C/Cz4L1Ic O+yP4eWT1mbgMojvKZGeVvBcuNvCSKlSUzGHycUbefA2Qng60upuLHUFapVT tBznSbkU4YUnxiWEOzW+Xc6LwB4NFf+Kf8W/4v81+Xu2RDNSgnxiqj8p9xP2 NZAfGT/i4pPgcEA4Pe6tTvm2hseMFNYvBEr4kibwXExi+xh4ZCxkgClAKVE8 MBYtDwUzPCQ8xClA6+kyYLH3QnyU7FCKrlAhFinAreV/3b+b7g5HTGFFHmcA AVIkODFgTiR1h1NYEiFav2I1d65UOjweNe/6rvBpKcqFxaMhgWKZNRvqBsRu +CWBpO+LyTbAnJzwFsZjpU3p4IH+sfCeIPF5I9Xw0UOVGxg5BEfInhoimJiI 52vvufwn579x9jvnh5IfCnYi1HvmHMPCgMtKdCNBI3GmkpFauDaGymQI3DjL AoW+2Biu4WkHfsywUk+U7t/w9qLCyVqnOREK1VYUUtFYVPwr/hX/iv+fwd8W 6INHFX4IUvKEq98gMxIaog9Eyd+5PHpIT+5MhW8mI8XMl+ILCqOFIOUaquB2 oXAgWYOglgNnTdM6jS9NmL0HWdOOKaLAgcFoIdHg6qNyfhfuEdcdLIVgiSN6 43ZxfsL8r/FkDssl4FIdiM4Qu7l7KkVbOB5vQECEEA9JDTxXbov8m6nk6ahZ q3tWKXaV8AoBURULKFAtLLWBEZZ94mDKIpv5F8ei1yPxLC2VtxTyrHK0GMrx 7YJhfYePYRSmgHUZC65Nxs8nPYceMXYk+Mey+OI35XziznvpfCQ6xPY9WI2I Sl2bheen4/2JeIahmZXEgr6M6wj+KZ0wJ2Wuj7WKGHwNoH7I4muT4d54PANz J08lPeYV/4p/xb/i/yfwb0t6oiDPIhF53ObTH+TkR+fRe0iRCPoFHUn9YYR+ uGvl7+rZLHaKwZ0LuDure3QspiOhHu+oSV9a2GLAlqnL0xqNLtJsr97bAP7o sB1K7tGHXn2oLe4f6lsnzh3PHfcFQT8iV5h7JLxAen+38k3Sq8tU8Y4gIanF 1v0uv3Pq3PL0PV/VupQcQs6laPqQxn+x0h27/7zuW2UliAOzTGLywPBJI8cT OQm5lcddCKaQgsUTljlfzw/qxYYFx8Okw6Tk1EapMJ9oy6lT/RiLIGzswvlF x+tfsfKX9WyJdKmAV4UjJT5I6wOf+IMP/yHvt+VwWz84hvcKAnkWC6dIeN7K 96x8jQS2xPgr7YxORGQoFLdjdb/tjJ/yx1hyDkFf0XiChd+RYq+erRD0EpGy C+uq4l/xr/hX/L8+fyW70zX/4eWYXIrptURdTWcuhUuXOksTbQXRgX+4xz8O sLM3NG/xEBIuCDe1gWDyQmyXftrOpcK5kC1ejNdGy49vPBtHnW2xy/tP4Hge UB6PjQVjl+P6lR6/dcZvfnav9FsXs+1hv8HbDvdu8+Ay733Pix2a2sI8Zp3B wah2PiGXC3GjL6/33cvF0iWzOdxtUEhVkglqviH5Fvu8D2sGYro0k+Omds5Y f03oN5k8lzt/yZb/Gi8PYJGdVsGAjGA8L0T/KYssjn0TJobN9EVjXcjYxVxf ThvfpgvfRfOj2FEOVtco8W6Q4gXtbYjQQn/vT5MTR1OXA+tizq/2xOUzfSlv Xom3h0NOfS29MYjvrPdM9LbRD9yjvDs8FkzdMOR6j906UzeKmQsF8Fkdb0tY jSodZeEV2nvK+jsEksoO4dHkeMW/4l/xr/j/CfxtFtWafu1ZZO0UYqvPtvuN 3Xz5abTSPBb8xBEnd53D++Lstcpa5c7yQxkMr0fTr4y11xPPz9SzwnmZN1/F a8to1q11Mqz9i7z3AnWtgV3uONRW/NpbY73N2F4uDwrnh7z5Y7KyFWoZOKJz T7Yvi/47VWypiAhj687oVqf2d2P/kLM3hX6XOz8V8z8mqzu+VmhkMSHMBZ2u 8n+9YSFFsVMy3DSjLyJrL6fP+mK3r1/0Wi+T7aXQFZlm0YCML4nilexti5jQ jIhkqBlP7sbWbsGe9vhOX+1mi0+itQXPgXSMpcM8viN6L1Rvk4YW8zk/nGie TO351quEv8jEq2LmXbb4fbS8fqIE9vQcluFlUbxU/S2NH9Oo7E6uB1PvYuuH nLxO2evM+T5demeW19pKtCFVHNbBNZnv8rMdHlIW2CIcB/5PK/4V/4p/xf+r 85ch9sFZjOyNNtt8r7bf640Pav6Qy2MqTjTtDKiT207/B8fMqRB9UHki3YQs efSJT56HYrur4cqzX5qXfelHE37n5ntusaljS8CPgWIRd43dbLO1P+TGB73a lXMeFUDPuCIZdPH4n9xsWcW4DcQ8wY5YI2CrIdvsinVPtXzROGWiTXEBZHUV fTMXr7n9l25E7FgxNNBjC5691SXPPPkidJ/Fas3wRlzqftMxZS642Ru3WNEQ fLHDGncyshTRrZQ9CcSOp7cj0WozN/6iOhvX2S0n39PZssb9I8GPFP/EGr+T xf9gzZ/lyj/V8nupDxn/wERHQTR3wvOz+YGbr2rfYhE+Lzdch3TRF2ueWO+o lYg3OlycQmhWzK9p/0Ijf+72NvA7YYytnCv+Ff+Kf8X/T+EvgH8iSCLsQJAT RY8YbQtsan8KqQcXnSl9crcVv50LFZqXxhT3642gvrJD24q5BWeFlODOgtSx oN26CC4tpXutcE6gKEsodNITNBWkw+33irznpMuJV+6DRw5LpnT+3Yr5e9PM YEcG3Aph/JRTT1pwx4TA2iDHsvy9tPJOhIgvLPjrLbPuQHw0mqENrCLoDSKs EFUBVsJQCptgvwORPQL+TbO/mMxrQ9A/PBYsIyTTlkE1LDOMZJSEcAuijGTZ A53emE/3ZqNZYRhMrjiCECzIB0Y+cPJRkF8F/Y2LE8k+Cf5Rii5c8+Jy/HI5 nsH3h5CLNueeEB3JTiRJKDyphfv7QnbQ+o/HtgwuNaPnS2YR+KNpeVjxr/hX /Cv+fwJ/iFxlSEUrOZQDfZSsLcQxXBbIAwfJfUsdTa8dryx2GPMkjRVAEB7j 8GgJAbwoH+oAYchE4NZUnXAZjayEa8tBabKEB2BdG3rNtWHkWvxW6ru66EcH UyYM0BvairdWDaMpemjjJ6xT3BDXh8oySFWeoocqz5lsczQ4zccXg5mtsAHJ l465hKnPSlWtkcDTStFMGxW8ablFnlKaDrWi5WY4QxKmSvNtHjGWooSA4F4J VyHRkZI5kbAgc86z0ZV4pVkqx0QH+aMODZbiEaeHkvwh5a+AiIljBasUW0t0 J1v+4jIWYnyBpgT8jt6DzIpVHf6A9Wy4CG2G7qyCemNL3dZqrGmMrSKwX4Op +Ff8K/4V/6/OH3Wz8P//CqKe6k6Pna6OwzO2sSMM62INAg8484k6hjty5mG/ Axop/APLCsZGo+VpT0Bexn2UnuKGS8RoBI/jOKjLVXA6XqHsVq+8ydqnjbG2 1McK4EMolBEXGY7NQbUSR7EW5ilc4lYFVcngULwz+qU5go+NGzhw6HDeY2jB HSoUtSb0i9TWTpTKhibi5fuhBsIUxplxLKnLYFptFUNC5NKIQ3RmKeMZlsvx dGQEdbPovIcvIZklsWhC0j5XKb5LYPLVZfxYoBQZsq0Ptdr7ldqHkv9HmBcp jgQWesOwYbmGOH6OdeJawYkpvKXcGwu3BkMHZcCnqNSVXSY7DJYW/AFnkVSi GTi2hKj4V/wr/hX/P4U/BEot/AfcvzaVHkz6LsDHm54IOEv5TMO/ttBt/KYk EsggNMdoO0XjqyPJu4lI43etqAydERpfiLSMibhZr7FPDYwQu9tg/fW0/248 XRSd0r+67F+gUqYNxGKhU+4mXHnIn/lYT217V2rJj7Vkhqao+OVdwg+1PBJO RgGOG0in9H0V6J6ncOs/PTcRv6yZZWKscmeEMWzfA7egOoXIi312WAY5F8p0 RV7nyZXpdH/SzNll0xxM7ry6k0vnDG7BtREae1LAjDMOC/L9Q/LznUn/5VR7 hv0uJEThI6FOZaMr4J8Di7DNnZg7HpeQmuGnyIe2+RZ4TqQrdmqJCFc4zBE8 oFPA+mQqkk4CT83Qx6PiX/Gv+Ff8/xz+RMYN6Y2QzhWreGNlS6xLRVti/8o2 nT5lox061NWDnq6dCBuCCARr3GcZtINrVvGTlS2y0MJiZ7i1T0nEHoRs0peT gfsYboo1bhi1eTpFjr+zzDur2CQeER0lA6U63IrqtVAMd/SA0TXIhgIb9yk8 iFn3iX+F5O/QH9u30dGoi+8AD07JYMju+vK2p+5GTi1kdkZo4bD0gZ2cJ8lL q7fxKCQ0crmxLZ9ORXwoIHcDOdDVoydq0nC7x2kmWTFJzBWSPa8X6ySikI7x kD4K62MpG0S/cfg3M+A7U4Gw/bIK42SEtO/SdJ+YJv2Dq48S1snjtjV0Yl8/ YVc68pLnXm/PDJ1y65CxNuRWY3Z40cpfkd4T23+EO0EdafvkgaEjvnUvVIOB HoHrw3uLgbyv4l/xr/hX/L8+f4ZN57uQKA0x/wbrH7B8hfkMLaO90bHu5NWE Xi7Yjb663nevpK0rpb80xuv0Dg9usv73dr5OQktkQH5quDN9ObC/S/nlVF/K Z77JFs5Fi4NR+dUuGqbtq6y3z3pPmUdkQHg0djea/Dfz6K85/66nzhczf8mb f0taoz5MvRLRLRLdYGd7rNhkh0Sh/8boRKd23VjXM3azL26f6Vu9pavJ2kDs klCxYJIml1i2TXs72JfTkHo8OuZP3jb2jYLd7st7hXM3WbybrNaMYqlm+QhL bvDeruhtCyy+sFg0VIunB1J7oBADn8XwmTtQNAdM60FbQ54luoOsMyiKFzxd ZR85P7HE4dB0d2zE2ON9NvkvMfEvp3a2PG7WHn2AYK3ZyYg4vSaKHZptWaeE 5VQmtel27WYM4+f3zuS9vrpdLN2JV8Y7uuJf8a/4V/z/DP7L4x0IJdi/QPo3 ZP9AZMu4A+JDilTb8CbfhtbblO7lcq/nHuTzr8zaEopgHZrdkcENeXbAelsU 4l1qqWCoGdZ2DNnosfUzuXbmbPVaO+lmM9QaWx4MSe+qLF6x/ksZQcZUl+bu ejT+MqMvevzpmdjtN17lq/vp+gq2KnZEcF2FN9nnA9Xb0tinmPLuZOto6m30 6F1G9lP1yui32eyPydJ2rHUkRXtKtK/ybEf0n5Q6LqrSydXo4X74+I1B3e9e 4b5O5/bN4koKyZcjeqMquSF6L3Sxif7hKRXx5Ho0fRBbr1N2kMj9RL+J5/fC hWXcbxLMG1aHg6p4JYs1dcz4CZOdRxvHD7/3rJ988mMs/x6733fn9o+dxX8y eoh+s7xzXWfbPN9FUS7kfd7Ukld7EZHXGdtL+F7uvsoW9v3Z1a7kFf+Kf8W/ 4v9n8F/pMuFrEdQc//JM8baRLamQiK7GT14JdzzS9AnM0bpRzUTMhmglIULI v4ac8IpbvGnky3A8zRSJmRvVlwN7p8Nf+eJl4D6L9KpRbrm7weMJdXjRSd84 xVPHWPxMylzMRtZOQvZith/og8h9ZlQrZspnsuvKzg3Xv6r7P84Ua45vMdzm lvwPrtv2vE9bh3zpgzOHn+CIyEozjfSR9q43/KdOseFENs8E/kuUDuhiRFZ9 0UrkbIo2HazHRF+LYlInV91838lXZGLjdkwBqShaMzUyOReKha6YgcwxERT7 h2rZHtPv7zr52xkzr04pPVL8VNITwfArHJ/9JGY/cn0kyC+E/EL5iWbmgfYv zaZP3d6WDAnJODeahbY2YiHmS23e8sVC4PAOgbcd4WkRVvwr/hX/iv9X5k/L bAviRR3ibyvea4YONlPuljrVVLCME9y25iTlJEfBEu6nYDeBBzr5rmXeLZqG TmyZY7NOnjI71STkdgR/SDuhNtprY19mFj2W7y8shD8202UnpbzHsSVlivIn OxTUFyRhVo5GpqWPt8O90YZ3Zdn8YznWyrdpW/JjLo+kOIRLoWwMY6KPZtq8 5A/0VHJ9qbvTDJbKDpvMwR1wxQz67LGQsASfhafIWfQk61siudUyz1thAzs+ 5BCUCS8oKyTvwYNLGA88OG6jxwJ9NjoP1af7a8GrpUDQE86OFZAXn4REtZXE PRpIyj4Q9X8Y+xX1zOi2Gl9tJZvL4byMKDUSBiyiUiQWKsBOIWPFyhTgyUqX kop/xb/iX/H/yvzRvw7jl8d5e2rZn19oSwoZATap4eie2ofQRoChHXOdKw7D Q+USOmCzZGjTrK2G+FyiUOh0l8LBSiacwrQmSpb741h/53Ps8vPL4Nqnp1tG IwGDNxVw8b7QqcRG9omAY2RZ3ME9xQPIuYZ34+0V32ZHjB8rlDC9h6yHqwDl XraPlYNoFZ4w2YP7QopXW4rmV0Jg7nJ0w6aozkXXO1qH2N2hTsAEjBymHgZ8 Jln+oBnPN2NBezCJgBrFuhCaVfrYStx6hDdS8LKRSwncPgl2/GDFW1iAiHmi xEfF3wt4HxCB1IH9qOs8PuX6AxEfbIk+HujCzfLp+WSmBeMBLPCwbViHqO+F XMwy9BGaxOL40XUcfvQr/hX/in/F/2vyV1/4yxSr3tBVu8tkG+KaoN2ylQwc AI9WDI1GG2OxlIkUAAdDFTwUYtcxg3+QvMA1GRyPYIVKapNRswYZU4T+q/xU sEPBO5J+5I1DpxEI1hOiL/h/Cf4vyT8T2Z+4F6/XEqpDifVrKfp4C2zEQ91M Kp/CqHQoVIrWrCxQKhh50F4Y9lzZFdhYAR6kYDKl8J94LBysKGzACqHwS4It GFQ8Mu49GQ8sHRBMKnMGj8B7kpcLDx1CMIhL0QM4OJU8GxgPt8dDDTPCDMeS 6pjzbmkDjsoEIbpSHMNzSXYsmUd4fHsoej4CfE5t0SWqANroOotuqylTKdZc YMMFCMqZQOVwNjhuWqOhKyG+exILWIB/UPGv+Ff8K/5fmb8SEQQRhX7RocSO NgaemjmRUPBQmZbFQ2q+m05fTyRzBIv1YPxAW6hMOLnQBivg3JTJgmNKBdfP CE+vTUfPx+JZGyIjVudJrEdOlIIcLYFThPMZgiDMI4RmVxSjVu/qYPyP0VhL dLRmos3xYJjcXKiudEKqTlEHK750MTCMRxenwp0Js2r7NuZTpbU1pDY6LDss GOqEUhkB7wDKl04ybftXp+N3U0ZacDyKgWFFSaendF7WWcB4YqIh7sO8FBA6 H9Dk+sN4fzqdJwWVZ7CclJvwRsFdGD9EW8NdOMVIhUHWEXGNmPPT+fdTZoGE BPvQwZrMUE6sjdIFRwvuEpGCi2OjikfMXH0cP32QLDGPSnjTOBIV/4p/xb/i /yfw94G/tBN7xJCbMb9unBu+c8c4Y+XXM5FomY2y6CLL9+zemh1QjMgJJhSP DBmN+P1YDETOqBH1jKkeE5mSxbQwF630hdXboDHB5mK5dnIsynhkxHgkRyM9 kUNuQmBsMnPV5+tWcs3u/Xs9a5LclkDeg3yHPozImMeGQjngq8ljZcOLwSkX oZTZNEvP2cku6T2jxoaVICDAZeRxao8FfMiXQ55TO1YPPUl9afuapQMkuG4V +/VswY4JHIxmI7E9Yex7obgV6Zuxvh2q4VDUIeNLXYG6rOt275VdrLIE+GvZ 548y676xbyEffcNv3DKNEey2SXnSkNE9GlymvTc0XyeBheOJIL2q11JyP2a3 I3XL6HthYzTmFgRlLEivseQKyXdIuko+EXmCZeAV/4p/xb/i/9X5U+Av/KHp ePxuRu6diaEzMXjm3Om1biXbE5HDIb7kQzK8wvKn5PMuC6gMGUvGxuNx9K8u 2KWevNRzz+fNb5PVgVixxJH5CMRHWjyjZ7sUngg7Y06O+ZPnIvuvCf1bJr/J G39Jl/+HWR0EFJlm/Ss0vs36f4fxU5+IxCb+6I3u1L8l9rcpP98TF/PGubR5 Ll0b8jX6dWQTPD5P02129grdmQwkOGOTZvxqYl/L2a2euF24N7OFm8HKqOey qMHSuzy4xYo9XqwIn8i0jn7g3tQdQwbO2BA+sjPQXxpO16cDLWNHpve5uSX6 L1hvk2WQjkGIvz8V1QZTOtAXg5/lwJlzt7d6x2xPRUrkrkhu0fA6679iZ7si ItiEIht+GIwPRvb9Pi95qvu9pdvp5phpYF1ePCbCq7z3hPV3ym9uMOlDU6bi X/Gv+Ff8vz5/W6TTa2bih9j6MRNvC/l97vyULv6YLG0kUhSu6A/J+JIunon+ MwnxC5KXrLYcjb2O6u9ysl/wvZ67XywemLU1GHzmiGJExhc1+ks/E4aUFhnD TX/0ZVJ/WtAnn9WTz87z3vK+2W2Fkncc2b0uO3dF/ycnW1YB4bitP7AdPHiT kv0ef9mTL/vO62L5wGyspxrznXBMBd/pfFN+3hclf5GOt8zYQWLt5+xFX77s OQfF/H66shk7TuSI9J6KbqregVMsqwiuT3UysRk8PEAdLD/I1dti9nsz/yaY W0u4xA2mYRXf1PlL2d9WEGFTrorp7XTqp6T+PzPyQ65/yBr/yJo/mMVV3IRy RHZDpddlf1/3tpVBt0CeTq0EE29N/W1K9zP+KnPeZPPfmybqhDN4dZlQ8WWd PpX9XZ3aMuUymVoH/qbiX/Gv+Ff8vzJ/iF+QpHCd0qWMr6SqlYp5w3XGGCZN Di8mnPjb2fS5U2w7oY37FykaFs3EdCVm24bvBnIz1IuGwimygJA06UbnZrLn Tn+3EVsCv6opFdnNE3v3mL3uqDfRzMvQXc9pA0VHriiuz0S3dO/f3XRBpRbO YCBnPWstok89/ryrn3fcXQOjovB0PNK8+0CF37jpjuq9cI3FYxgPrBM6k5LV kO3EcitUq6GcB24J5ZHLsyEd3XCKd042j2YXcDD6TdFGxpcMXzayZfRCAkkT ZQl+9xP5uDaX3fztbN50M8IixQpNM64Mn0/YciaWYzGf4hdIllGVOJDfuel3 bv69yle1sXEfB06JucrogmHLiVgJ1WKgGmg2TiE/Fdm0E553s5dY9xGWHeJg UpKKf8W/4l/x/9r80V865xr94iQaE+Wc5QL/wG13gahzWyXnm+bFsmnh9ZNS r5VxkknLKJIwO+d2JmkuRcLQdqmgKv7bktlrpqtuaAkfxUgsVbSjiSdJV1KP Wj322JfsMxM9h8VDOri+nPx7s9wZR1FWjMJa4isbDo6FHQkrg1NQCquMVCFR 8V8W0udL6YaDzYME+vihHkCyFD330NQ0g6Bc+somkELWnPj6knk3n2pZKq/Q gjsSLJI0YjQTNBH0ixIMXy0Uzx7p9NpSvD8bNXhOZYA+JOgumEhqFM0FxEqK Ii6F2/eYQj7Q2bmV9IdWMqczu/wRHgF3eVCE1hPYBhrLDyn3ULfG0bT2Usu8 XE3ndIANpmFmNS6Jin/Fv+Jf8f/K/LlKSwkraqhIPdUEYg1OBNwCfsTdChqP tszShoGxlYMv8JoCBa6MRJLgLjYqi1jJX+YAbWA5Xt2E3CdDnz28ciFUJlWX YTgzqKRSHbgyF/+SMn3Ij6Y2g51mZrNeucOelxcPhI44iSUt0F4V9bGFQDUX vhjcbZmVrbAByQ5+30PrVDxFlqPipjTTg7wMn0gzyInC0a1gZSnkFJUDOFlf VL7aUBuN8qSCE2Hq4USfyb7gZ7XVqLnsax4JVPbCLXB3XqmCkkTaQSmXhd/z 8r7YxGF43WytJ4TlDH224e6+EAG6jvNc2rFAYUBq60hR7BYqZTDZCpeW0XYV bi14UfGv+Ff8K/5/Cn/g+d8Kq85p "], {{0, 256.}, {512., 0}}, {0, 255}, ColorFunction>RGBColor], BoxForm`ImageTag[ "Byte", ColorSpace > "RGB", Interleaving > False, Magnification > Automatic], Selectable>False], DefaultBaseStyle>"ImageGraphics", ImageSize>32, ImageSizeRaw>{512., 256.}, PlotRange>{{0, 512.}, {0, 256.}}]\)], "RoughnessCoefficient" > 0.65, "MetallicCoefficient" > Texture[CloudGet["http://wolfr.am/VAsat6ib"]] >], Sphere[]}, Lighting > "ThreePoint"] 
Notice, by the way, the new "ThreePoint" setting for Lighting—essentially a simulation of a standard placement of lights in a photography studio.
The story of modeling light interacting with surfaces—and “physically based rendering”—is a complicated one, that Version 12.3 has a whole monograph about:
Based on the number of new builtin functions the clear winner for the largest new framework in Version 12.3 is the one for trees. We’ve been able to handle trees as a special case of graphs for more than a decade (and of course all symbolic expressions in the Wolfram Language are ultimately represented as trees). But in Version 12.3 we’re introducing trees as firstclass objects in the system.
The fundamental object is Tree:
✕
Tree[a, {b, Tree[c, {d, e}], f, g}] 
Tree takes two arguments: a “payload” (which can be any expression), and a list of subtrees. (And, yes, trees are by default rendered slightly green, in a nod to their botanical analogs.)
There are a variety of “*Tree” functions for constructing trees, and “Tree*” functions for converting trees to other things. RulesTree, for example, constructs a tree from a nested collection of rules:
✕
RulesTree[a > {b, c > {d, e}, f, g}] 
And TreeRules goes the other way, converting a tree to a nested collection of rules:
✕
TreeRules[%] 
ExpressionTree creates a tree from the structure of an expression:
✕
ExpressionTree[Integrate[1/(x^2  1), x]] 
In a sense, this is a direct representation of a FullForm expression, as shown, for example, in TreeForm. But there are also ways to turn an expression into a tree. This takes the nodes of the tree to contain full subexpressions—so that the expressions on a given level in the tree are essentially what a function like Map would consider to be the expressions at that level (with Heads → True<