From fc2286bcb654a178c73bb7efe7b4e2d45dd9c881 Mon Sep 17 00:00:00 2001 From: dwelch67 Date: Tue, 13 Oct 2015 01:15:22 -0400 Subject: [PATCH] working on MMU example --- mmu/README | 725 +++++++---- mmu/coarse_translation.ps | 2564 +++++++++++++++++++++++++++++++++++++ mmu/notmain.c | 105 +- mmu/novectors.s | 5 +- mmu/periph.c | 49 +- 5 files changed, 3142 insertions(+), 306 deletions(-) create mode 100644 mmu/coarse_translation.ps diff --git a/mmu/README b/mmu/README index 03997f9..da6856c 100644 --- a/mmu/README +++ b/mmu/README @@ -4,6 +4,11 @@ and how to run these programs. This example demonstrates MMU basics. +(This ONLY works on the Raspi 1 for now will get a Raspi 2 version +working at some point). + +-- NEED TO RE-WRITE THIS AGAIN, SUBPAGES ENABLED, COARSE 1KB TABLES -- + So what an MMU does or at least what an MMU does for us is it translates virtual addresses into physical addresses as well as checking access permissions, and gives us control over cachable @@ -181,12 +186,10 @@ of the MMU tables and addressing but the part I mentioned as unfortunate is that the drawings and descriptions dont have the same look and feel. They have the same basic content though. -I am mostly using the ARMv5 Architectural Reference Manual. Possibly -an older one than the one on ARMs page. ARM DDI0100I. Where the I is -the rev of that ARM ARM. The ARMv5 ARM does show ARMv6 stuff in -particular with respect to them MMU, so it is probably the right -manual for this processor, although you could use the ARMv7 and be -careful to ignore features added in v7. +I am mostly using the ARMv5 Architectural Reference Manual. +ARM DDI0100I. Where the I is the rev of that ARM ARM document. The +ARMv5 ARM does show ARMv6 stuff in particular with respect to them MMU, +so it is probably the right manual for this processor. So there are blocks they call sections and blocks they call pages. If we were to simply take every possible address and make a look up @@ -196,213 +199,208 @@ would take up to 4Giga-entries for that table for a 32 bit address space and each entry of the table would need to be more than 4 bytes, 32 bits for the new address then some others for permissions and enables, so that would make no sense to have an mmu table larger than -everything we would ever access. +everything we would ever access, actually we couldnt even access that +whole table as it takes more address space than we would have much +less the physical 32 bit address space we are trying to map to. +If we think about what arm did and we will get to the manual in a +second. Lets start with a 1MByte page. That means we take the 4GByte +possible addresses and divide them by 1MByte, we get 4096. That +is a manageable number. 1MByte is 20 bits, 32-20 is 12 (thus 4096). +So we would need to be able to replace the 12 bits of virtual address +with 12 bits of physical address plus have other bits in the table to +indicate permissions and cache control and ideally some to indicate +this is a 1MB page or not. And ARM has fit all of that into a 32 +bit entry. So if we wanted to map the whole 32 bit virtual address +space for the ARM we could do that with a 4096 entry (4096*32 bits is +16KBytes) MMU table. +So the ARMv5 ARM ARM (ARM Architectural Reference Manual) is what +we need now. See the top level README for finding this document, +I have included a few pages in the form of postscript, any decent pdf +viewer should be able to handle these files. Before the pictures +though, the section in quesiton is titled Virtual Memory System +Architecture. In the CP15 subsection register 2 is the the translation +table base register. +First we read this comment +If N = 0 always use TTBR0. When N = 0 (the reset case), the translation +table base is backwards compatible with earlier versions of the +architecture. -re-write in progress. +we will leave that as N = 0 and not touch it and use TTBR0 +Now what the TTBR0 description initially is telling me that bit 31 +down to 14-n or 14 in our case since n = 0 is the base address, in +PHYSICAL address space (the mmu cant possibly go through the mmu to +figure out how to go through the mmu) we basically need to align to +16384 bytes. (2 to the power 14, the lower 14 bits if our TLB base +address needs to be all zeros). -. (and we would have to access -everything as bytes since a scheme like that would allow the four -bytes in an instruction or other word sized access to be in up to -four different physical places) That is not exactly what happens -but it is along the same path. Instead of taking the entire address -and having a look up table, we take the top bits of the address and -that goes into the first level translation table. Basically bits -31:20 (bits 31 down to 20 or perhaps think of it as address>>20) are -added (orred) to the base address for this table we have to prepare. -The contents of the table are not necessarily the replacement bits, but -the way we are using it they are. +We write that register using -The ARM documentation talks about sections and pages, perhaps this is -not the intended distiction, but with sections the first level -translation table contains both the replacement bits (will describe -what that means in a second) and the permission and other control bits. -For a page, the first level translation table contains an offset to -a second level translation table, a second table. The combination of -bits in that first table and second table serve to describe the -access permissions, and replacement bits. + mcr p15,0,r0,c2,c0,0 ;@ tlb base -So with what I am telling you so far with the addition of saying that -we will mostly be talking about 1MByte sections, that means that -I can have a virtual address of 0x1230ABCD, virtual being the address -that I write my software to use, and have that get converted by the -MMU to the address 0x4560ABCD. Basically the address bits 31:20 I can -change in the MMU using a 1MByte section. Further those upper address -bits which are 0x123 in this example are used to look up an entry -in the first level descriptor table, and that entry contains the bits -0x456 as well as some other bits for permissions and cache control. -Assuming the permissions and such are okay the MMU then simply replaces -the 0x123 with 0x456 causing our 0x1230ABCD address to actually -access 0x4560ABCD. The lower 20 bits, for a 1MByte section have -to be the same in the virtual and physical address. So only some -of the upper bits are replaced. +TLB = Translation Lookaside Buffer. As far as we are concerned think +of it as an array of 32 bit integers, each integer being used to +completely or partially convert from virtual to physical and describe +permissions and caching. Thinking of it as an array we can talk about +the 3rd thing in the table, but being 32 bits wide that is really +times 4 (and plus one depending on if we are talking zero based or +one based). This will hopefully make sense in a second. -Now maybe you can see why there are blocks or chunks of memory that -are virtualized, the lower address bits are not modified between -the virtual and physical, basically a whole block of memory space -aligned on some power of 2. And the other thing to understand now -is that because the translation table ultimately contains the -replacement bits for the bits used to look up into the table, Depending -on how many permission and other control bits we want the number -of replacement bits left over in a 32 bit word are limited. But if -we were to have a second table, then between the first and second -tables we have 64 bits so when we have a bunch of bits to replace -meaning we have a smaller block of memory being virtualized somewhere -else, we will need the secondary table. +My example is going to have a define called MMUTABLEBASE which will +be where we start our TLB table. -So you may be thinking that we have a chicken and egg problem, but we -dont. We want to access something at some address, that act causes -the MMU to access the translation tables which are at some address -in memory, now if the MMU had to go through the MMU, you would have -that chicken and egg problem. You dont the MMU does not use virtual -addresses it is all physical addresses, it doesnt send itself through -itself. But this does mean that we have to carve out some amount -of memory for the MMU translation tables. The pictures imply this -can vary but as far as we are concerned all of the MMU tables, first -level has to fit within 16Kbytes. +So on the second page of the section_translation.ps file I have included +in this repo directory. This is hopefully not too complicated but in +order to do this kind of work you have to be able to manipulate/compute +addresses. So what this is telling us is we start with the MMUTABLEBASE +at the top, this is some space in physical memory that we have decided +we are going to use to keep our mmu table, which means nobody else +can mess with it, if we were an operating system we would only allow +us permission to touch it, and block all applications from it, but since +we are bare metal supervisor we just have to not step on our own toes. -So we can be looking at the same picture I took a couple of pages -out of the ARM manual and put them in this repo as a postscript, if -on linux then no big deal your pdf reader will/should also read -postscript (postscript is like assembly and pdf is simply the machine -code for that assembly, assuming unencrypted, with free tools you can -generally go back and forth between pdf and ps). Atril, evince, etc -can display this, gsview and others like it will work on both windows -and Linux. section_translation.ps is the name of the file. +SBZ = should be zero. Our MMUTABLEBASE as described above is 14 bits +of zeros at the bottom and 32-14 = 18 bits of whatever we choose within +our physical address space. Using a 0 for the MMUTABLEBASE would +not be a wise idea as interrupts and other vectors are there and we +cant be having both vectors and the mmu table in the same place so +the first sane place we could put this is 0x00004000 upper 18 +bits being a 1 the lower 14 being all zeros. We will pick our address +in a bit. -The picture on the second page is where we want to start, and a -picture is worth a thousand words, and although this is verbose already -hopefully I wont have to spend too many more words on this picture. +So this picture says take the MMUTABLEBASE address at the top, then +take bits 31-20 or the top 12 bits of the VIRTUAL ADDRESS, multiply +by 4 (shift left two zeros) and add that to the MMUTABLEBASE. This +is the address in PHYSICAL memory where the "First-level descriptor" +is found. This is how the hardware works so when we in our software +place a descriptor in memory we need to compute the address the same +way to get the descriptor in the right place. -The first thing the picture is telling us is that there is a -base address somewhere that we tell the MMU about that is the base -address for our translation table memory, where are primary and -secondary translation tables live. This is important SBZ means should -be zero, the lower 14 bits assuming X is zero, must be zero so we -must choose an address that has the lower 14 bits zero. I have chosen -0x00004000 which just barely makes that requirement. I assume -that my program is loaded into the ARM address 0x8000, I will need -to have some exception handlers at 0x0000, but 0x4000 to 0x8000 is -not being used (I have my stack elsewhere). +Now *IF* the lower two bits of the first level descriptor are 0b10 then +this is a 1MB section descriptor. the picture then shows that we +create the physical address by taking the lower 20 bits of the virtual +address and placing the 12 bits from the first level descriptor on the +top (31:20) and that is how, for this section, we convert from +virtual to physical. Part of the virtual being used to look up into +the mmu table, and that first lookup being a 1MB section, and the +physical being a combination of the descriptor and the virtual. -So we have a base address for our translation table. So lets do the -conversion mentioned above of virtual 0x1230ABCD to physical 0x4560ABCD. -What they are calling a modified virtual address is our...virtual -address the address we write in our program on the processor side -of the MMU. So that is the 0x1230ABCD address. We break that address -up into its two parts, the Table Index which is 0x123 and the section -index which is the 0x0ABCD part. The next thing down is the address -of the first level descriptor. So they take the 12 bits of index -shift those left two so it makes a word address and add that to the -translation tables base address. In this case 0x123<<2 = 0x48C and -our base address of 0x00004000 gives us 0x0000448C. Now the descriptors -are all physical addresses the MMU doesnt use the MMU to access the -MMU tables. So we read the 32 bit entry at the address we computed -and we get the first level descriptor. The first thing we look at -in the first level descriptor are the lower 2 bits. If those bits are -a 0b10 then this is a section, the other bit patterns are documented -not far below these pages in the manual. The first of the two pages -I have here shows the 0b10 in those lower bits and also says that -to be a 1MB descriptor we need bit 18 to be a zero, and so we will. -The MMU now knowing this is a 1MB first level descriptor then it checks -the other bits not shown on either of these pages but we will cover, -for access permissions, if we have not violated any permissions then -it takes the upper 12 bits of the descriptor and tacks those on top -of the lower 20 bits of our virtual address to make the physical address -and then the MMU sends that down the pipe and we do our memory/peripheral -access. +If the lower two bits of the first level descriptor, the first lookup, +are not 0b10 then we will get to that in a second. -These pictures in whatever form show the virtual to physical translation -but we as MMU programers need to go from physical to virtual, if after -we turn the MMU on we still want to be able to access the UART for -example will will have to have an entry so that we can control and -allow the access using the access control permissions. Hopefully you -have figured out that we can replace those 12 bits with whatever 12 -bits we want, including the same 12 bits. Why would we use the MMU -to replace some address bits with the same address bits! Remember the -MMU is not only there to remap memory space, but it is also there to -allow for control over access permissions and to allow control over -caching. Separate controls for each page or section. So working -backward we want to have our uart which is in the section 0x20200000 -be available to us after the MMU is enabled. It really makes it so -much easier if we have the virtual match the physical for peripherals -and actually this example starts off with virtual matching physical -for all the sections we care about. So we need 0x202.... to result -in 0x202. So our translation table entry is 0x202 based or -table_base + (0x202<<2). And the data at that address needs to be -0x202xxxxx with the lower two bits a 0b10. And the rest of the -bits such that it just works. +You should be able to find the same picture in your ARM ARM that I have +stolen here. The subsection titled "Hardware page table translation" -So now we have to chat a bit about that. The "other" bits are the -domain, the TEX bits and the C and B bits. The C bit is the simplest -one to start with that means Cacheable. For peripherals we absolutely -dont want them to be cached. Lets say for example we are polling a -register in the uart to see if the tx buffer is empty so we can -send another character, so we read that register a bunch of times -until some control bit indicates tx buf is empty. Well if the cache -were on the first time we read that register its value gets cached -then the next time we get the cached value not the real value, if all -we are doing is polling and we dont evict that cached value then all -we will ever see is the stale, cached, regsiter value, if that -value did not show that tx buff was empty, then we will never see -the indication when it changes. So never make a peripherals space -cacheable. This is a good place to point out the purpose fo an MMU -again cache control. Right now we can see that the MMU even with -virtual = physical, allows us to turn on the data cache, but gives -us control that we can mark perhipheral address spaces as not -cacheable. +Now they have this optional thing called a supersection which is a 16MB +sized thing rather than 1MB and one might think that that would make +life easier, instead of 4096 entries we would only need 256 to describe +the whole world in the easiest way with the largest chunks. But +the lookup works the same bits 31:20 are used for the first lookup +no matter what (well we could play with that N=0 register, but are not +going to here, that is not legacy, lets start with legacy works on +the most chips) so you basically have to write 16 entries for a +super section, you dont save anything. the super section is broken into +16 1MB chunks and each 1MB chunk is a first level mmu table lookup. So +it doesnt buy us anything for now. Note how the hardware knows a +1MB section from a 16MB supersection is bit 18 in the first level entry. + +Hopefully I have not lost you yet, we are doing address manipulation, +and maybe you are one step ahead of me, yes EVERY load and store with +the mmu enabled requires at least one mmu table lookup, the mmu when it +accesses this memory does not go through itself, but EVERY other fetch +and load and store. Which does have a performance hit, they do have +a bit of a cache in the mmu to store the last so many tlb lookups to +make walking through the same space much faster, but that tlb cache +is limited in size, if you jump around a lot in ram you will have +a penalty here. Cant really avoid it too much. + +So if my MMUTABLEBASE was 0x00004000 and I had a virtual address of +0x12345678 then the hardware is going to take the top 12 bits of that +address 0x123, multiply by 4 and add that to the MMUTABLEBASE. +0x4000+(0x123<<2) = 0x448C. and that is the address the mmu is going +to use for the first-level lookup. + +If you look in the ARM ARM at the first level descriptor format. The +lower two bits of the value read at that address tells the mmu hardware +if this is a page fault a coarse page table, or section or reserved (a +fault?). Above we talked about a section with those two bits being +0b10. If the mmu finds a 0b01 instead then we look at the +coarse_translation.ps file that I have put in this directory. Like +the section translation, we see the MMUTABLEBASE we tack on the top 20 +bits of the virtual address (times 4) and that is the first level fetch. +If that first level descriptor has 0b01 in the lower two bits, then the +mmu looks at the top 200 bits of the first level descriptor, tacks +on some more bits from the virtual address and uses that address to find +the second level descriptor. the second level descriptor is not shown +in this picture you have to look at the table in the arm arm for the +description. Here again the lower 2 bits tell the hardware something +large or small pages basically for a legacy/compatible discussion. +and that second level descriptor contains the bits that convert the +virtual address to a physical address plus the permissions stuff. + +So lets take the virtual address 0x12345678 and the MMUTABLEBASE of +0x4000 again. The first level descriptor address is the top three +bits of the virtual address 0x123, times 4, added to the MMUTABLEBASE +0x448C. But this time when we look it up we find a value in the +table that has the lower two bits being 0b01. Just to be crazy lets +say that descriptor was 0xABCDE001 (ignornign the domain and other +bits just talking address right now). That means we take 0xABCDE000 +the picture shows bits 19:12 (0x45) of the virtual address (0x12345678) +so the address to the second level descriptor in this crazy case is +0xABCDE000+(0x45<<2) = 0xABCDE114 why is that crazy? because I +chose an address where we in theory dont have ram on the raspberry pi +maybe a mirrored address space, but a sane address would have been +somewhere close to the MMUTABLEBASE so we can keep the whole of the +mmu tables in a confined area. + +The "other" bits in the descriptors are the domain, the TEX bits and +the C and B bits. + +The C bit is the simplest one to start with that means Cacheable. For +peripherals we absolutely dont want them to be cached. The b bit, means bufferable, as in write buffer. Something you may not have heard about or thought about ever. It is kind of like a cache -on the write end of things instead of read end. It is a thing somewhere -between the processor and the memory that tells the processor, let me -take that write information and deliver it for you, you can keep -doing other stuff. Now writes in general are "fire and forget". When -you perform a write both the address and data are known, in general -the memory controller can and depending on the design, will, take the -address and data and tell the processor, I will go and do that for you -you keep processing. Well that works fine as an optimization for the -first write, but eventually the write has to end up in the slow -main memory. So if you do two or a bunch of writes in a row the -processor gets the optimization on the first one but the second one -has to wait for the first and the processor ends up waiting. Well -further down if you were to have a small buffer that could hold more -than one write in flight at a time, and allow the processor to get -this optimization for more than just one write cycle but maybe many -or several then for situations where the processor is doing random -writes, you probably can gain some speed. A good place to use this -is when you have the cache on, as a cache line is not just one -word or whatever wide, it can be several words of data, so when you -have a cache miss, need to read a cache line, but you dont have an -open spot and need to evict someone from the cache that multi-word -eviction can go into the write buffer, allowing the cache to do -the cache line read. But if the write buffer is not there or not -enabled then everyone has to wait for that cache line eviction -to make room for the cache line fill to then finally send the -read data back to the processor. Now do we want to enable the write -buffer for peripherals? Well probably not, even though the arm -manual may show a combination with B on that means device access. Lets -take the generic write buffer case and not necessarily an ARM one. -The write buffer absorbs some number of write accesses for the processor -so the processor can continue excuting and not have to wait for a -slow memory transaction to complete. So the processor is operating -ahead of the writes the program thinks have completed. So maybe we -poll the uart status register, it says the tx buf is empty, we write -a byte, which lands in the buffer behind some other writes, we then -have another byte to send, we read the status register, if the reads -and writes are not serialized meaning if the reads take a separate -path from the writes, then it is possible that the write of our first -byte is stuck in the write buffer waiting on other writes, so the write -has not hit the uart, the txbuf still shows empty, the next read -of the status register shows empty so we send another byte, but -eventually the two writes hit but there is only room for one. So we -probably dont want to use write buffering in general with peripeherals -unless we are sure we know how the hardware works and we dont have these -race conditions. +on the write end of things instead of read end. I digress, when +a processor writes something everything is known, the address and +data. So the next level of logic, could, if so designed, accept +that address and data at that level and release the processor to +keep doing what it was doing (ideally fetch some more instructions +and keep running) in parallel that logic could then continue to perform +the write to the slower peripheral or really slow dram (or faster cache). +Giving us a small to large performance gain. But, what happens if while +we are doing that first write another write happens. Well if we only +have storage for one transaction in this little feature then the +processor has to wait for us to finish the first write however long +that takes, then we can grab the information for the second write and +then release the processor. I call writes "fire and forget" because +ideally the processor hands off the info to the memory controller +and keeps going. Well the kind of write buffer I know about and hopefully +this is the same kind, goes beyond that I can do one write for you at +a time type of fire and forget, it is a tiny cache like thing that +can store up some number of addresses and data and allow the processor +to continue while those addresses and data are delivered to their +destination in parallel. + +The description from the ARM ARM is: + +"A write buffer is a block of high-speed memory whose purpose is to +optimize stores to main memory. When a store occurs, its data, address +and other details, for example data size, are written to the write +buffer at high speed. The write buffer then completes the store at main +memory speed. This is typically much slower than the speed of the ARM +processor. In the meantime, the ARM processor can proceed to execute +further instructions at full speed." + +Eventually the write has to go out, and that far side is generally +slower the write buffer can fill up and the processor has to wait for +some space before continuing. Like a cache helps the processor with +making many loads faster, the write buffer helps to make many writes +faster. Now the TEX bits you just have to look up and there is the rub there are likely more than one set of tables for TEX C and B, I am going @@ -411,7 +409,7 @@ there. Now depending on whether this is considered an older arm (ARMv5) or an ARMv6 or newer the combination of TEX, C and B have some subtle differences. The cache bit in particular does enable or disable this space as cacheable. You still independently need -to turn on the instruciton and data caches and need an if cacheable +to turn on the instruction and data caches and need an if cacheable and the cache is on for the access type within that section, then it will cache it...So we set tex to zeros to just keep it out of the way. @@ -447,7 +445,7 @@ the MMU sections domain number 0. So we end up with this simple function that allows us to add first level descriptors in the MMU translation table. -unsigned int MMU_section ( unsigned int vadd, unsigned int padd, unsigned int flags ) +unsigned int mmu_section ( unsigned int vadd, unsigned int padd, unsigned int flags ) { unsigned int ra; unsigned int rb; @@ -463,28 +461,70 @@ unsigned int MMU_section ( unsigned int vadd, unsigned int padd, unsigned int fl So what you have to do to turn on the MMU is to first figure out all the memory you are going to access, and make sure you have entries -for that. Now if you do the math, 12 bits off the top are the -first level index, that is 4096 things, times 4 bytes per that is 16KBytes -thus the reason for an alignment on 16K. Now one solution you might -simply do is fill the whole 16K with 1MByte sections that allow full -uncached access...Basically completely map the virtual to physical -one to one. I didnt do that, I was a little more concervative on the -clock cycles, not that that really matters here...For this example I -wanted to have the memory we are really using around 0x00000000 and -then some entries I can play with to show you the MMU is working and -then the entries for the peripherals I am using. +for that. This is important, if you forget something, and dont have +a valid entry there, then you fault, your fault handler, if you have +chosen to write it, may also fault if it isnt placed write or something +it accesses also faults...(I would assume the fault handler is also +behind the mmu but would have to read up on that). - MMU_section(0x00000000,0x00000000,0x0000|8|4); - MMU_section(0x00100000,0x00100000,0x0000); - MMU_section(0x00200000,0x00200000,0x0000); - MMU_section(0x00300000,0x00300000,0x0000); - //peripherals - MMU_section(0x20000000,0x20000000,0x0000); //NOT CACHED! - MMU_section(0x20200000,0x20200000,0x0000); //NOT CACHED! +So the smallest amount of ram on a raspi is 256MB or 0x10000000 bytes. -I didnt need to cache that first section, but did, will leave it up -to you to do a read performance test of some sort to determine if the -cache when enabled does make it faster. +Our program enters at address 0x8000, so that is within the first +section 0x000xxxxx so we should make that section cacheable and +bufferable. + + mmu_section(0x00000000,0x00000000,0x0000|8|4); + +This is saying map the virtual 0x000xxxxx to the physical 0x000xxxxx +enable the cache and write buffer. 0x8 is the C bit and 0x4 is the B +bit. tex, domain, etc are zeros. + +if we want to use all 256mb we would need to do this for all the +sections from 0x000xxxxx to 0x100xxxxx. Maybe do that later. + +We know that for the raspi1 the peripherals, uart and such are in +arm physical space at 0x20xxxxxx. To allow for more ram on the raspi 2 +they needed to move that and moved it to 0x3Fxxxxxx. So we either need +16 1MB section sized entries to cover that whole range or we look at +specific sections for specific things we care to talk to and just add +those. The uart and the gpio it is associated with is in the 0x202xxxxx +space. There are a couple of timers in the 0x200xxxxx space so one +entry can cover those. + +if we didnt want to allow those to be cached or write buffered then + + mmu_section(0x20000000,0x20000000,0x0000); //NOT CACHED! + mmu_section(0x20200000,0x20200000,0x0000); //NOT CACHED! + +but we may play with that to demonstrate what caching a peripheral +can do to you, why we need to turn on the mmu if for no other reason +than to get some bare metal performance by using the d cache. + +Now you have to think on a system level here, there are a number +of things in play. We need to plan our memory space, where are we +putting the cache, where are our peripherals, where is our program. + +If the only reason for using the mmu is to allow the use of the d cache +then just map the whole world if you want with the peripherals not +cached and the rest cached. or only the stuff you think you are going +to use. + +if you are on the raspi 2 with multiple arm cores and are using +the multiple arm cores you need to do more reading if you want one +core to talk to another by sharing some of the memory between +them. same problem as peripherals basically plus some other issues +if you have the write buffer on then a write doesnt happen right away +it depends on how full the write buffer is and basically that is not +usually deterministic. But worse data caching a shared space you +dont know if you are reading from the actual shared ram or from the +the cache for that core. And further you need to read up on whether +or not each core has its own mmu or where do their memory systems +come together? You can and I will run this example on a raspi 2 but +only using one core not messing with the other three. Ideally making +a generic example that can be ported to other arm processors from +an mmu perspective, from a peripheral perspective you have to use +different code for the different peripherals in that other arm you +might move this knowledge to. So once our tables are setup then we need to actually turn the MMU on. Now I cant figure out where I got this from, and I have @@ -494,42 +534,34 @@ or MMU to finish something before continuing. In particular when initializing a cache to start it up you want to clean out all the entries in a safe way you dont want to evict them and hose memory you want to invalidate everything, mark it such that the cache lines -are empty/available. not mentioned yet but the MMU has a mini cache -that it uses for things it has looked up, think about every access we -do through the MMU, imagine if it had to do walk the descriptor tables -every single read or write could require two more reads from the -table. So there is this TLB which caches up the last N number of -descriptor table lookups. Well like cache memory on power up, the -tlb might be full of random bits as well, so we need to invalidate -that too. Then this dsb thing comes in, we do the dsb instruction -to tell the processor to wait for the cache subsystem and MMU subsystem -to finish wiping their internal tables before we go forward and -turn them on and try to use them. +are empty/available. Likewise that little bit of TLB caching the MMU +has, we want to invalidate that too so we dont start up the mmu +with entries in there that dont match our entries. -After we invalidate the cache and tlb, and you may be asking why are -we messing with the cache? Well the MMU gets us access to the data -cache since we need the MMU to distinguish ram from peripherals before -generically turning on the data cache. Second in the ARM the MMU -enable bit and the cache enable bits are in the same register so it -makes sense to just do cache enabling and MMU enabling in one function -call. +Why are we invalidating the cache in mmu code? Because first we +need the mmu to use the d cache (to protect the peripherals from +being cached) and second the controls that enable the mmu are in the +same register as the i and d controls so makes sense to do both +mmu and cache stuff in one function. So after the DSB we set our domain control bits, now in this example I have done something different, 15 of the 16 domains have the 0b11 setting which is dont fault on anything, manager mode. I set domain 1 such that it has no access, so in the example I will change one of the descriptor table entries to use domain one, then I will access -it and then see the access violation. there are two registers that -hold the translation table base address, I program them both, not -sure what the difference is, why there are two... +it and then see the access violation. I am also programming both +translation table base addresses even though we are using the N = 0 +mode and only one is needed. Depends on which manual you read I guess +as to whether or not you see the N = 0 and the separate or shared +i and d mmu tables. (the reason for two is if you want your i and +d address spaces to be managed separately). -Understand I have been runnign on ARMv6 systems without the DSB for +Understand I have been running on ARMv6 systems without the DSB for some time and it just works, so maybe that is dumb luck... -Now I can start the MMU. This code relies on the caller to set -the MMU enable and I and D cache enables. This is because this -is derived from code where sometimes I turn things on or dont turn -things on and wanted it generic. +This code relies on the caller to set the MMU enable and I and D cache +enables. This is because this is derived from code where sometimes I +turn things on or dont turn things on and wanted it generic. .globl start_MMU @@ -555,8 +587,10 @@ start_MMU: I am going to mess with the translation tables after the MMU is started so I assume we have to invalidate when a table entry changes so that just in case the old one is cached up in the tlb, we can force the -read of the new one by invalidating all the tlbs. - +read of the new one by invalidating all the tlbs. Depending on the +manual you read there are cases where we dont have to invalidate, will +just invalidate anyway to be clean and generic, you can optimize later +if you want to dig into those features if your core has them. .globl invalidate_tlbs invalidate_tlbs: @@ -565,10 +599,129 @@ invalidate_tlbs: mcr p15,0,r2,c7,c10,4 ;@ DSB ?? bx lr -So the program starts by putting a few things in memory spaced -apart such that they will be in different sections when the -MMU is turned on. We write then read those back. +Something to note here. Debugging using JTAG makes life easier than +having to press reset and wait for a debugger, or even worse having +to remove some media or a prom and stick it in some programmer to change +the program. Depending on your processor though you have to be super +careful when debugging programs using JTAG and the caches and/or mmu. +The openocd support for the cores used in the raspi2 imply that when +the openocd server halts the cores, it disables I and D caches (not +sure about the mmu). But, for the raspi1 and quite a few other +ARMs out there, here is the problem you have using jtag. Instructions +are fetched and stored in the instruction cache yes? Thus the name +and data is read through and written through the data cache yes? Say +we have a program we have the i and d cache on so it runs for a bit +instructions go into the i cache and depending on the size of the +program and the addresses used some percentage of the program is in +i cache when we halt the processor. Lets say the instruction at address +0x10000. Now we want to write a new version of the program to ram +and test it, so writing to ram uses data cycles, which go to/through +the data cache to ram. And lets say one of those instructions in +the new program is at address 0x10000. So ideally the new instruction +is in ram at addres 0x10000, but the instruction at that address from +the prior experiment is in i cache. If we start the program again +at the entry point, and before the program goes out and cleans the +caches and starts stuff (assuming it doesnt know it is being run for +a second time from jtag it is written to boot into this code from +reset or power up) it hits address 0x10000. if the old instruction +that is in cache is at address 0x10000 is different from the new +instruction in the new program at address 0x10000 the cache is going +to give the processor the old instruction because we left the caches +on. Much chaos happens when you do this. Now your processor core and +your jtag software may automatically or may have manual controls +for disabling the mmu and cache, or maybe not. You have to be very +very aware of this though as you might try several iterations of your +program and they all seem to be progressing fine, then strange things +start to happen, sometimes your whole old program is in cache and it +is as if the new program wasnt being loaded. Or maybe you start to think +you didnt compile it or save it to the space where you pick up the +binary, you repeat this many times but the new program simply isnt +being run. I recommend for the purposes of this example, you use +the reset button which you soldered down on your board like I did or +if you didnt, then power cycle the raspberry pi every time or often +or do the research to see if/how you can disable the mmu and caches +between runs and habitally perform that step. I use openocd a lot +on many different cores that not all have caches and mmus so I dont +have the habit of doing this, instead if I get tripped up I start +resetting between tests... +So the example is going to start with the mmu off and write to +addresses in four different 1MB address spaces. So that later we +can play with the section descriptors and demonstrate virtual to +physical address conversion. + +So write some stuff and print it out on the uart. + + PUT32(0x00045678,0x00045678); + PUT32(0x00145678,0x00145678); + PUT32(0x00245678,0x00245678); + PUT32(0x00345678,0x00345678); + + hexstring(GET32(0x00045678)); + hexstring(GET32(0x00145678)); + hexstring(GET32(0x00245678)); + hexstring(GET32(0x00345678)); + uart_send(0x0D); uart_send(0x0A); + +then setup the mmu with at least those four sections and the peripherals + + mmu_section(0x00000000,0x00000000,0x0000|8|4); + mmu_section(0x00100000,0x00100000,0x0000); + mmu_section(0x00200000,0x00200000,0x0000); + mmu_section(0x00300000,0x00300000,0x0000); + //peripherals + mmu_section(0x20000000,0x20000000,0x0000); //NOT CACHED! + mmu_section(0x20200000,0x20200000,0x0000); //NOT CACHED! + +and start the mmu with the I and D caches enabled + + start_mmu(MMUTABLEBASE,0x00800001|0x1000|0x0004); + +then if we read those four addresses again we get the same output +as before since we maped virtual = physical. + + hexstring(GET32(0x00045678)); + hexstring(GET32(0x00145678)); + hexstring(GET32(0x00245678)); + hexstring(GET32(0x00345678)); + uart_send(0x0D); uart_send(0x0A); + +but what if we swizzle things around. make virtual 0x001xxxxx = +physical 0x003xxxxx. 0x002 looks at 0x000 and 0x003 looks at 0x001 + + mmu_section(0x00100000,0x00300000,0x0000); + mmu_section(0x00200000,0x00000000,0x0000); + mmu_section(0x00300000,0x00100000,0x0000); + +and maybe we dont need to do this but do it anyway just in case + + invalidate_tlbs(); + +read them again. + + hexstring(GET32(0x00045678)); + hexstring(GET32(0x00145678)); + hexstring(GET32(0x00245678)); + hexstring(GET32(0x00345678)); + uart_send(0x0D); uart_send(0x0A); + +the 0x000xxxxx entry was not modifed so we get 000045678 as the output +but the 0x001xxxxx read is now coming from physical 0x003xxxxx so we +get the 00345678 output, 0x002xxxxx comes from the 0x000xxxxx space +so that read gives 00045678 and the 0x003xxxxx is mapped to 0x001xxxxx +physical giving 00145678 as the output. + + + mmu_section(0x00100000,0x00100000,0x0020); + + invalidate_tlbs(); + hexstring(GET32(0x00045678)); + hexstring(GET32(0x00145678)); + hexstring(GET32(0x00245678)); + hexstring(GET32(0x00345678)); + uart_send(0x0D); uart_send(0x0A); + +So up to this point the output looks like this. DEADBEEF 00045678 @@ -576,31 +729,71 @@ DEADBEEF 00245678 00345678 -Now the MMU is turned on with these sections mapped with virtual = -physical. - 00045678 00145678 00245678 00345678 -Nothing magical yet. But now we start to swizzle things around, two -of the spaces are swapped 0x001...addresses point at 0x003 and vice -versa. 0x002 points at 0x000...And the output confirms that, we didnt -write anything to memory, just played games with what physical address -comes from what virtual. - 00045678 00345678 00045678 00145678 +first blob is without the mmu enabled, second with the mmu but +virtual = physical, third we use the mmu to show virtual != physical +for some ranges. + + +the next experiment there is a system timer in the 0x200xxxxx range + + + for(ra=0;ra<4;ra++) + { + hexstring(system_timer_low()); + } + uart_send(0x0D); uart_send(0x0A); + + mmu_section(0x20000000,0x20000000,0x0000|8); //CACHED + invalidate_tlbs(); + + for(ra=0;ra<4;ra++) + { + hexstring(system_timer_low()); + } + uart_send(0x0D); uart_send(0x0A); + +your output may vary, I am using bootloader07, so the human is involved +in typing and clicking stuff and downloading the program and starting +it so the time at which after reset we hit this code may vary and +give different timer ticks. + +006BBB1B +006BBEE1 +006BC2A7 +006BC66C + +00000000 +00000000 +00000000 +00000000 + +why are the cached values zeros and not the same timestamp four times +which is what I was expecting? that is a very good question and worthy +of a research project. + + + +--- REWRITE IN PROGRESS --- + + + + And then the icing on the cake, one section is marked as domain 1 instead of domain 0, domain 1 was set for 0b00 no access so when we touch that domain we should get an access violation. - -00045678 -00000010 + +00045678 +00000010 How do I know what that means with that output. Well from my blinker07 example we touched on exceptions (interrupts). I made a generic test @@ -612,14 +805,14 @@ a data abort (pretty much expected) have that then read the data fault status registers, being a data access we expect the data/combined one to show somthing and the instruction one to not. Adding that instrumentation resulted in. - -00045678 -00000010 -00000019 -00000000 -00008110 -E5900000 -00145678 + +00045678 +00000010 +00000019 +00000000 +00008110 +E5900000 +00145678 Now I switched to the ARM1176JZF-S Technical Reference Manual for more detail and that shows the 0x01 was domain 1, the domain we used for diff --git a/mmu/coarse_translation.ps b/mmu/coarse_translation.ps new file mode 100644 index 0000000..234265d --- /dev/null +++ b/mmu/coarse_translation.ps @@ -0,0 +1,2564 @@ +%!PS-Adobe-3.0 +%%Creator: cairo 1.13.1 (http://cairographics.org) +%%CreationDate: Mon Oct 12 21:45:25 2015 +%%Pages: 1 +%%DocumentData: Clean7Bit +%%LanguageLevel: 3 +%%DocumentMedia: Letter 612 792 0 () () +%%BoundingBox: 52 149 478 736 +%%EndComments +%%BeginProlog +/languagelevel where +{ pop languagelevel } { 1 } ifelse +3 lt { /Helvetica findfont 12 scalefont setfont 50 500 moveto + (This print job requires a PostScript Language Level 3 printer.) show + showpage quit } if +/q { gsave } bind def +/Q { grestore } bind def +/cm { 6 array astore concat } bind def +/w { setlinewidth } bind def +/J { setlinecap } bind def +/j { setlinejoin } bind def +/M { setmiterlimit } bind def +/d { setdash } bind def +/m { moveto } bind def +/l { lineto } bind def +/c { curveto } bind def +/h { closepath } bind def +/re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto + 0 exch rlineto 0 rlineto closepath } bind def +/S { stroke } bind def +/f { fill } bind def +/f* { eofill } bind def +/n { newpath } bind def +/W { clip } bind def +/W* { eoclip } bind def +/BT { } bind def +/ET { } bind def +/pdfmark where { pop globaldict /?pdfmark /exec load put } + { globaldict begin /?pdfmark /pop load def /pdfmark + /cleartomark load def end } ifelse +/BDC { mark 3 1 roll /BDC pdfmark } bind def +/EMC { mark /EMC pdfmark } bind def +/cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def +/Tj { show currentpoint cairo_store_point } bind def +/TJ { + { + dup + type /stringtype eq + { show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse + } forall + currentpoint cairo_store_point +} bind def +/cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore + cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def +/Tf { pop /cairo_font exch def /cairo_font_matrix where + { pop cairo_selectfont } if } bind def +/Td { matrix translate cairo_font_matrix matrix concatmatrix dup + /cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point + /cairo_font where { pop cairo_selectfont } if } bind def +/Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def + cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def +/g { setgray } bind def +/rg { setrgbcolor } bind def +/d1 { setcachedevice } bind def +/cairo_set_page_size { + % Change paper size, but only if different from previous paper size otherwise + % duplex fails. PLRM specifies a tolerance of 5 pts when matching paper size + % so we use the same when checking if the size changes. + /setpagedevice where { + pop currentpagedevice + /PageSize known { + 2 copy + currentpagedevice /PageSize get aload pop + exch 4 1 roll + sub abs 5 gt + 3 1 roll + sub abs 5 gt + or + } { + true + } ifelse + { + 2 array astore + 2 dict begin + /PageSize exch def + /ImagingBBox null def + currentdict end + setpagedevice + } { + pop pop + } ifelse + } { + pop + } ifelse +} def +%%EndProlog +%%BeginSetup +%%BeginResource: font f-0-0 +%!FontType1-1.1 f-0-0 1.0 +11 dict begin +/FontName /f-0-0 def +/PaintType 0 def +/FontType 1 def +/FontMatrix [0.001 0 0 0.001 0 0] readonly def +/FontBBox {0 -219 913 737 } readonly def +/Encoding 256 array +0 1 255 {1 index exch /.notdef put} for +dup 32 /space put +dup 44 /comma put +dup 45 /hyphen put +dup 46 /period put +dup 48 /zero put +dup 49 /one put +dup 50 /two put +dup 52 /four put +dup 53 /five put +dup 54 /six put +dup 56 /eight put +dup 57 /nine put +dup 65 /A put +dup 67 /C put +dup 76 /L put +dup 77 /M put +dup 82 /R put +dup 83 /S put +dup 86 /V put +dup 97 /a put +dup 99 /c put +dup 100 /d put +dup 101 /e put +dup 103 /g put +dup 104 /h put +dup 105 /i put +dup 108 /l put +dup 109 /m put +dup 111 /o put +dup 112 /p put +dup 114 /r put +dup 115 /s put +dup 116 /t put +dup 117 /u put +dup 118 /v put +dup 121 /y put +dup 169 /copyright put +readonly def +currentdict end +currentfile eexec +f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467 +b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de +800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f +2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b +9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799 +69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5 +8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251cae0ac3010658cd +e1a4844c12fb0cd14fd4a2c9c58012fbf272e44437b866a4eaeea0e6b037c92f2e1dbe27a19739 +46359d0d1c8e5025535f9925211a0553ed517cb35fa96efabe7a8cd9f3dff987cc68845af7d36d +50c04656bd303e13f7faa5291890a954e7662bed076ad2dac68430023f1f76b8c2db4273ac81c6 +8ebcee61a8b8ea1a37efb5a61f0ba912eb40fe7ffc7c16139b31e9ca164ac2d21de6eeed4c0a27 +500258c40f79c513a9b67ce47da869e676e52680371d03be7f2893914b5da70ef62327c2dc24ec +a4b9766b93f7f138e4e64af64c9e66bd6309e5160fe5fb6f0a140961b6ba69711608cb2c26fef6 +a91ba0d85843292858ff4d056774df034f5810b772fe3752a2ec135c4e86a3ec6369d525d8f4c9 +cd176c61257138787d92964c4f43a1f4df099919b0fa75ad2cbca796aa3975f1449ef1ffaa63b4 +0a33f37f07443a035b5c9b6a243a586e7203e5f534ad8e36679ebc7cd178f8e7314934f65c216e +b6c379880de860f1591216c5cfe15e51df7fd7979c24c7e72edec3958748e054d85a6bdbe35098 +2b8cb1503d94e577bce4815c2c67252c83409a6dbdfe93f70853cfa551c53057d13c43ca0519e9 +4586cb9f814ee86ce75cb5402826c529490849a17dfb9b50ac40fdc7cbe7eef4fee6e02953e758 +0b744361d05672b7698e6051c915c4c3b2c7ef3231f31d5a927b75cc347f4956c70d5bdd087460 +cc8d52b9f978d5600ea17d77b1f146b0afa96fe1ec21c7e970edef98b8b0822e80217f02e622f5 +c9243713bc579ca8c9e5b9515aa360cf24e715413c6fe61a7a63fa76d85ef2398c1debb418a577 +913639dcad71923b90203a0e91a13b5eeb2c80beacabf0de807da148d9f272726458de0dd34a8a +b9e7744d4ccf8c9a10335900f5b062b3b182d162bbba221f82cac5245e68138c70d9efda4c3409 +58d49a8c5a6a3b408a7f684a13804182512cc38c27e32fc0c1e0fbe4c9f9177cf1630ed7cbd867 +910736827e9722fdf6155dc02032b99311a997d947286a542cb98d3436dd74c5bbea714ebb581b +614962f255f4e8c5a88b1e2d5bd296089266ef09ed8a114c45952544f5ac6e3605130159b37da6 +3c24c71f8ee6f4707f63a8df81e537b689fe459f349ad2c2576df95eeedc5efb6d408380c5166b +58a72bc2a64ce7d11c634c9ad1ab5595de264b5410bcc8340bac8c6a868e4e652b9b5e057b16cd +966dfbdff2cd52faa9fede1734eea212373217b5e415c5f598c56f3e256996d44354422b8815b7 +e3a0d03e71726bd1fda24758471ffc465b8d40faa412aa1601901cf8950b2e7030fea253908dd7 +8b608b3dffee621e7c1ad5bc1109045c471790f027b638abaaa2117102d50afcbb82804de6f802 +bb421ddc6abbcedbf35944f99ada440b8ee1755216ebaa33fc666462a7af8c017f40510eece62a +61c5e224b2f208bec54bd72d6cb20b37ec3ec5870e704f81d9846ed040c9568cc2ef261e4daac0 +28147b9a70babe738b8a6f80803cccf2b13047f6672382a6bd37f8b1f4d272294857de3306745e +cdf84b4930acab97758d178e6554bfa4db46c92ca284025cfff4e4c840b9d907dae324e9c2d67d +95f4fe43462e0d0d3e18f63d55031406f3c848327ee14907573c2c7a684fca14edfc0ae92aa036 +ebd2cad10f7b5de29a486efc6a8f9475c2f4feb70419a87edc11054d00320eb1f5ff0f390e2dad +e1ec4848fe65488d62c0e792a491caba52de94fb9f1c795fcf66288771959cb5e41e5a35f68cfe +48c4495e9b2e55d57fc85cd2c57a53896baf931ea8cfb3489e02700d84c00fa30ff984c90d2096 +c336367269405e06bb89d8a8f98c96012bed86e8ca5a043a033d3abf0273edf08bb1434460dcb6 +0d4f36f5f95be1968ccc45ca2eae6ae965d62c33123e88e891f40c9969c9e1cf07796cacbdc940 +b66616126439aa61b5ec0e5e7121c34db07bc0db4512da2444f1e1afae97c9869b3b744c5ce267 +b94504bee4fdcafe4e208c4adea47692c3feabce623859aab2ebc5d46231135b32fd3566727b65 +049a979524a92bb3eeb818454c615bd25218081aab2fb95c5378f4f04afb6221301bbe5d309ac1 +2f64261e2e88185e0022609f4aa99e1c0560a0b88349d03bf672cfd86abe8e3abd92e236b945e9 +57e6d5fbee5768453c224a93acf60e9e8ae4b2676b91422f245c926d3d566fe7d8fb75e726e622 +fac5c5d9ca5f2b5a9e6d439931b13fe63c4c64679efb309c562c18d84fe7d9bc11930f34f89dca +91a77e7d53034d23737547533eaacde57ca896f06928d0ab800b022a9b591ad7830ab352d95c67 +5e564f3c0423208fd4d255ce0ed0beb6bbe42280d4e2d72b89536c305a968d86ed57f1b099363b +6d78687d6d97e479b44405d77d9df005aef3426cb2d6aac1a9352a4582c0e67ba1a63e4674f505 +e4d3b4dba1d63c247a8e9fcfe2c2d547f1b7c432aaf54bdd1a874ddd1dc2622ac5bab0bf2abdd5 +6b296eb22e16df77d73416486252ff9d6c43c5250d11e6c66739bbb1954b46c31ca38ce6bd5879 +3caa8257bb41c185ef2c29e88b76c9619ec6d46f945427d5d832e7a8e1cb81221f5c1ad629242e +905e453a27fbf6ed990ce0122c1e049502e703b1b405bf589e758e47908c6038f026e99ff8ce07 +320f7e4b8aa52bae952f7980661a800cfef840a2f941549f4d0f310b7c163f72011dbd1fb4da27 +c38d75971a93e6776383ba87d75aa0c907f7d5a3aa7f71399f642464f431cd4c5a368d48befbec +743eebc0dc0be8457574665b577258d6698a7f037c9302ffeee83daa447dca7a3dc317080b103d +e632157a8a7fd4bff7494bce6499b3563dc5067503e7c2951f826bf7a08679cd9e1975132d81ad +0af228cda05d11f71a2ce3d079ee9a1f46f6fbeece580b59383835530afa0511663bb86df8b736 +06f54ceb953f0c167b01a45d3cdcc78bc8b76210863e0a41cf354a4ac45810bfb3b28033fda68e +5334c193a7103bb234fa28f6108f9bb17184dfa04995acb84b569cd21a3f42ad9cf7055ad0b6c6 +cc79b65ebe55feb365132a12827ea619cd81f3551022567e73c8c6854cfaa9bcc8edcecf6b943f +12ff852eb48ad59539929c39e2743bc5438e51038b86484f1ef06f2b90713b90a2d0435d77b7c1 +c0f65445ae9da4e8d2bf169dff8f8306e220446e5ccb325bf943539602ac2d6866662e71b57e59 +3a8f72548e66ffe8c14a2517f08f591415ccd34293f977dca3e9229fefbf10f4e3e106f8fe90cc +ee2a3aca53b6fdd62a73e3fad312dac45f579bda0ede11e34c8424793625facdfd3104a073bb9f +5136fc4bb0ca45f2c7b12c0c705e0676148eaf052554d275430ecf1f949aa28ba7f7ff52611bcc +b38b7059a80bbc631761e084097f58b010d8c1594777750e49f8c0f1ec0bc12260983a6a909771 +7d36313d38a14188ae4dafd9b336cf8957137f0840f3ef4274510ee8069fe11964203ba6524544 +36e01b191df5e69e4377f707db07080ef04d93ab9da529d361e296de5869147d27a5a102795b9f +5e8b47f7f1227691555a8a575e542e079137e8bc9c5170da9b545552ce172132979eb5dcf3822c +6cdbf27bc2390c128e75b106e9ef3de8a199cbc56eb2b9b06b020797df613c751659396ed4bdc2 +6a7e093697848d473e8c3b7cd167ce26a74d550af2c0ab7fd23ae02bbc59fe6fb31b9e9adc2d2e +387f3a46904b7c6954c36e4fc22331a232c750787a1135c9a6480512c0b54b22ad5019da101ed4 +7f36a3678f9656bf04e1885bd68ceab8a4703340fc7d4273fc7c2c64d9e99bbcdbb9e7512dcc7d +73a4efb714e947d779d8d205ef4e55ca9cef1c5a64e5343367628f45ce0a194c74927e098bb689 +5f785a2162540199b76267b76acec314bf4a22d9da3c05ac3619381bffa3bd8a0284d7f59ec810 +25a053e31abcd775e2882f36a95fb8b4c724caaaf39385c5b98ffd7ac9a0688a766a22fb707ed9 +526ed05427d861fc7328e92592f9d6719289b2c269bf4d19c2d15133b21a7cd75fec28d55da41c +efec8412fe893df6cc9b504e1fffcc6d66fb3eee334fa81bb7352ea75f3f97c0f944035f7a55c1 +7b1f1dbac30774a73d60ce075bd539d223a2f9d47e221bdd2338a7e7161519fe8da982c51d0720 +cf4216ac047d5c9c9bafe79ebfecc27dafb2a6b8ba21e00e15c190ae223e9716f7fcee202f927b +6d236da5922675ffaccf1a360fdb0325e02d1726cd26e7cc3dca95eb2021032b8dd947e130011e +997a5dbf6d1638e0f8176e6232e28160d4c0d84df4765d694bd8a404b8b45b2daf63a4d303e046 +c9d7f1ed5275e12db797024dab144c1039a1069be40e15770f90ce07ff2a7423f67388281ddcf0 +c37fff447d3fe4143e7596e464dac055d267fd347fc0acfaff999c5d03d2ae3e95d0f41751de82 +5db3f2fc58220090a535c4e39ec87f4823b2a86ccab061830ef1d9c04be138b0e699ae9cc59e27 +49567be0bcc57d17a5b04b8c81c44e76781b3fd6c09ffa21477245cc16bda2a585f1489bf9934c +1454b35f27862e504177030ba4ffcf9a00a98cfa3d63439313536dc8b26b2d9975ac9da9accc81 +716d9456f8b69dda6870e5041c96093ed60f6ec363752f19dd76adf40980576692fe8caba23bae +a9b25714e15014762bc5c8c9ae12b08fb2f61a9f92eec5294d6cc0ac2a833168f40afefd72d82d +1eb5a7e83b12fb4f4969fa4f596b104c58042448a9a8c47b43e5ddfcf924995c031a97e39ea662 +205f060ad61bb0fb9cb7ece7cbce4af7640d2c767fa6b31f561991db072426f681864a151e83b0 +293ea97b6a59aefbf62b70c5e45f019be977e58cb89fd3438fb0aa8eb482712398db75781c963d +ea472258aa28ccbd09a638edc5487bceee82670e9570153a8df81b09b2081022c1d98af4a13e5e +2b966bd0e65642284ac64c77ecd66a6cf267aecd7f6d618ddd6c43cc4b855af19d6a5978afe829 +b059d73de9a28e84fb98ca3251d388c3852ef22f34c6b7a6bbea545c3ba182014cf26bd171aeff +68ddf1601e05a1a79a78b67a4f979636cdf0122cc90a82f4e169ad883f63cf6dcf3b95d7376bba +e519f9b94ea04b104f0fab9b7055065fbc46cfc9854498c2d71e9995c851aad211f980cc74d1fd +3487a38f63f4aac96d8fb223b39ee23d6a547da3829eb19f3ddaafb569ca55336db334f7c7e9fa +aaf92e2c44b1b47f7edfdd78aa19ff23f8d7482fc1e8641128cc470f0f192a96d07c54c975b01d +de8c903aa4e9fb6bc9bac25cf2754fee1fd54d8231172a0bd9d9d53d8dd0f4a812b5d85d24a531 +fe5c927c55882fe8588a668052acf1f966ce9148cdb185b3985ec8e75de9412081439211ed8ca2 +39383430b34e32d540379091b1f31a12078611155108bb477354c8f6e442c5326e1f1763066ee5 +c841d4f7e9cd9f71cfc4e4075a9d422ff07477aa04ba9d9e10eb5e7d449db54eedd6c816ce8978 +0e689573b02ede5223b3154d62c1901abb24271e7a476e3d9c1f21d84570a1ff4f3bee0279f8af +f10142e2c83b4dc365cbc412e939c61a4eb90bbb9b34fc8677387f0a94d1c71793b1d0eebe910b +68424b52a2983ce971aeeaa4f60af32e39a7df034255a6ce6e2bcff5c1f375365ce3a583fb1c3c +739c3e5067a89d2f5518beedee78dfb3bc3f1b4162ea1112c20e4c2fa1ead67e5f396ed4c3a6c6 +4996f2b55a4b3856e59c57965a745151ac810962e292f167dd32ac098d2deb899609f2daa8a5a0 +48cd9e100000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +cleartomark +%%EndResource +%%BeginResource: font f-1-0 +%!FontType1-1.1 f-1-0 1.0 +11 dict begin +/FontName /f-1-0 def +/PaintType 0 def +/FontType 1 def +/FontMatrix [0.001 0 0 0.001 0 0] readonly def +/FontBBox {0 -18 761 718 } readonly def +/Encoding 256 array +0 1 255 {1 index exch /.notdef put} for +dup 32 /space put +dup 45 /hyphen put +dup 48 /zero put +dup 49 /one put +dup 51 /three put +dup 52 /four put +dup 65 /A put +dup 66 /B put +dup 68 /D put +dup 73 /I put +dup 77 /M put +dup 82 /R put +readonly def +currentdict end +currentfile eexec +f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467 +b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de +800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f +2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b +9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799 +69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5 +8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251caca21eeab10af3 +33b3fa4b86f309b5b8af72e7cce435db4069be2ca1e1df36d3705e771e937976c16404a81390e0 +9dcdd22744c080024d85c73135133a1c8418b3fa9716fe0c216beb3b04a2e86b5c6765c26f0488 +1eb911f0d9581589003a269db0ffd51beb4891d84927bdab8f81f9db184ba12404619d1dbaef48 +65a0f6a661b563fe23336c567e174276fad600a13a99a906cbb0a74dd4688ba24c4e63a3e0f52a +f71e2cd98ef5e8fe8eab5660400fd8ca01e3bb3c176c01f7d4a0689df68098dc85aafc89aa3312 +8c6c74dab966353cf553f8466b303568d3d6a531b3010422946ee0743e99799e29097f5468599c +b9144639dbe94d15097341b837763253e9c88730ac932d22968f17d3f8d350ed8e636729acdf3e +3fb39c1f05ff8f316ee9cf330adf25820a392935814d01e6599e331c42590f9ec208b96bd492fa +636b15585695a147f57bc78c3bb28d26b8f817e0d1bcde29bfa709faaae3c063d1e1abdfe850ef +f9bdb849b2691855c3d9dd4984c72cdaa4df5c3e9959a91c9b9681b53b35e069ec037269dc95b1 +c85eea826f1816fe5136868626656e1b4637382668584189d11e19e8b00120d5253393f1a87f44 +28c4ebb77b127a4cc63d36d4a8cfb393b46a31bba5f1cc2ee1c1411978ddc3faecb36f517901c0 +1c6386dfada11055b9c8c8ec92e7f3fef8041c8357bfc5d35599214368ecee2c16b0270c86abc0 +997f983f45a3bcfb50d7cb00a6775e6047ee01019156d3e1eb611e9cc28c8960ef63c63d82ce48 +8cc0881c64504964a1377317607ce35edfcf775e1d18b0a7b7a2b9d43e7aa72ae365ed00877813 +01572a148fba1db65069644487b786a6381662204d7166543552dd19eb11705ba5763ad91d46ff +3928c702c293e351ccd7d4ed2aa33dcd2329c4e91165c1e31d54d52cf54ff145ab5c5ae0139bc8 +591364c62a8d6560ddab5c7ad5348f07afb51f8940cb65d21b6b8c0afa507ec5ee4338a2746020 +cbed2c73968be96b2e54ec0c1f22a0629fadefca056e72e5b4d13be6bbedc8e1358bd9f67d5700 +90ee1539a0dde88bd0c290757790d8437f1cfc09963641301ac5533bf268c3ede2f7c42e732c21 +b2fa76255575ed2adea7661ac95a697825b7fa527c64bdc3c0c7adaf092422f8550342e5b3319e +0ef261585ecfc0cece09d82d4e82678fa89fe83413e74c75a11c477929943891bc4594bb669592 +298ca13c5e633e0b04eb02aded5e5bfec6be486b88e7f15713588075e49ff63175d8271e9f73a1 +496812fe37937e68bb93f6a2c342499f2d57b79d9ea5e23cc2a3bb44430ca57fb08148b6af05e6 +ced421bfa54ea636d35161b3eb6c40e27ce3fb27828b599d8e23924dcd2741449663dd94e1d97c +3f99652043ad541a66e30fc6cc59b1bc3d533b72daffca557320925d36d4f7a574bed9444cb354 +0644fc85ada26a4095cbf6b19720e87f7e79440c7631669f79ef6c45273365600e32c046f22daf +f57f11c8abf413275f95764ccbab271a8027f167879f709f16fb77052507b7559e22271a75c0a3 +fbba0b4152b1b4a39e996ad34dd1909e8e9b61b4bdb1efbac29f261ef9c5f8001d87c1d913dcb1 +7eada71fe794c20f1edbe0c79feeed409f263cbf5371a39c2db7a228c06735c77ffc30c5353914 +c8dae6e410f8ad57b128dd50639c919780af57d8e90547f14e4d527875ffff1c52946445f42ca5 +faba4db658b4458d18b5567d7ae769952eb345f6c75a928bee033c0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +cleartomark +%%EndResource +%%BeginResource: font f-2-0 +%!FontType1-1.1 f-2-0 1.0 +11 dict begin +/FontName /f-2-0 def +/PaintType 0 def +/FontType 1 def +/FontMatrix [0.001 0 0 0.001 0 0] readonly def +/FontBBox {0 -216 702 737 } readonly def +/Encoding 256 array +0 1 255 {1 index exch /.notdef put} for +dup 32 /space put +dup 45 /hyphen put +dup 46 /period put +dup 52 /four put +dup 53 /five put +dup 54 /six put +dup 55 /seven put +dup 65 /A put +dup 66 /B put +dup 67 /C put +dup 70 /F put +dup 97 /a put +dup 98 /b put +dup 99 /c put +dup 100 /d put +dup 101 /e put +dup 103 /g put +dup 105 /i put +dup 108 /l put +dup 110 /n put +dup 111 /o put +dup 112 /p put +dup 114 /r put +dup 115 /s put +dup 116 /t put +dup 117 /u put +dup 118 /v put +readonly def +currentdict end +currentfile eexec +f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467 +b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de +800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f +2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b +9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799 +69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5 +8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251caf38b5733b65e1 +ae5ed9ec42ebee256077e561ea069a72fa6ddc3792643c08a3ebdf22fefac73964d48a836434fe +f44aaea59093f253673c08a3ebdf22fefa9bf8965783cf1162dc89096cdcde6cbfb3ed0531c3d6 +5daa9a8bd3cfad87b41a2b5869a31acaa1762b8b7e1a1dc08a2627e9848effa8b5bbe83438d57d +92e7d247e353d5a22889b63d987047443f7915490a361b2679acbe948ab19493e980b7d6b15fb3 +943d78dff4d9d7dbcf128a391f0725d543302178de465ec3aa40acac685bf2eee29043ae113e46 +2de26893f3c142b57f4b904ce7cd47735ba1f8b2981130579482e20e0c9007b42e7824a8035a3e +99267f385736330fe326603a114b63e5c6e3596d7a710175208a1f925b47377fff3fedf68fa422 +15d39d4354a594dde7dcc88d4b70f8bac1fb7fc9d911a20005b8401cb27e024ab01f791a74d00a +f835e8901e5335f30a5bbed55b89c989f0f175d7358e479e8b6566bd816c96d7ab50b4a797287b +9bd79af6198be0ff18d29b7ea5b7a7a1e6ab346b8e355b28ac2a68f874052b9edd9a196f74ad76 +593949e5a1f4071957ff8f9890027973631fbdb1032ea0c0ecb7bbc0e5275ef435069aee994381 +88f924b4a519f6426c7acea07a39f4a4d8f11ded1c24126c333d26faa41b334df81c63b959a38c +5b50cae6bde1ce7510a3188a26e60a517ac8293b0ad618fda48c5124a7f5476cfb4500438d1925 +32b4af3b59190af96c582f0f2586d28482417965f58199dac6cf7fa4ce234d9d56330ec74481cd +ef2fdbfb030d45f1aa8d5feceac8ee8874dd1d5d4c2311ad5125c19e42a0d530746012f71cd8c9 +871381ee92099512470bfa6b65c3d9379a47e8205a9e963f0e41088ecd8da33be27fc9e43c87da +452d4e65e51e33b5267ba7ad91067a645b17eb5db60e9cd12e10184884a881a7ed6f84b7e329a9 +deaabd30a3cd71a95070a9fee56a442d953243b9ba90da27b0ff3523378522442be2722c8453b6 +5ccba09be12b4b8cff4296c0a824c95be7ff80ab7afd63406406559261a9e82e864298f1bbc22a +feb55962e9cf26733a69a5b2301ac3d001bb61a38e3063c76e5fb39213c73681278e3a350e9028 +97e97404c39facc331c93a9603a5bc1d06c083251f5c023210aba5558659408def34a120d4e44d +010e12e12abfa0637ae345cb465a6046b5a2d96227553e9517ff67671c958174ecc16217197c56 +f0f1791bc9292f8497ab333b07ae23c8395687442800d07bf2b28a8af45370a7b1616835cf2e3b +16834f6dc5a4da47166127d3d6e9053b0eda82b733517267df8963e13b3d3aa13f968bc5f3ef5c +d025b395c44f55fb17879e96fbdd81a6a717623437b82ddb167531bf6802cc7622f0ed5a80e823 +37d25b54fabf41a9250565d1c78504e404c4700ce7bf65d82a61b68f532233a572f84a34dea998 +ed6d4d29bfb96beecf7729009495af32cb3c8ce4b79933b585af38ef9629f23c339174ec609051 +6adeb40188b3ddb7adde0e4834a363e70443e118e0ab0404cd3f4f63896a34a404ade7cd373f78 +a8a9d83ce747cb934b8d17b524636cf6e81682a77b2610ffde4ff3cd72447a6e1bb7de752ff387 +d5fa7038098c7a1c63d46dbe523320172dc627587030d77df429a826908f7bbfeaed471795c969 +9199dbc934524b6246dcbbe386417caaa2ddca89f89ae0f5b3f5195ae69ad0ef80e17c6ea14d9c +a206d67a1f0916b433a670d3a57cf47321a1415ef08b3bff71fdf8a140fa6e6a3c9e728a09490c +650763519215076c3537a742e6bc0dd381cfe39b1ad08c4ddaf5a5b2cc1c7b3d28251a392315fe +3284186cc6ba6a41d221b5c1f3f97c1c91e15e3db63eb4968f96ad0037f883e7f6f1dbcdcaf9f9 +368bdc095aae67c05936274d78cf51663fd1794ecaa126e30f9f1acd2de5fa7a652ab26faf63cc +3efe4af0b9765536de8cefcc90ae523ed0b3bc17d90e43ee3f6f84cf230d1aefbd3de2ef94acf5 +8358a22a311745817b56bf7db93b510f465d8b36ee723f45a74e67bc960b6826ee2aad59eeb032 +75a23bb747291878ca9f632d72b9471f461611afd73f0c44bfd15579e92e3d9366ce8fe37a000b +c9125390d977e1f791e3766c403b5184e787c49db741e8d930061a632d037462bdd715d3264c0c +d8adb7d6dbf5924d41609404722ffa003faa2c42dcba5d1aa15eeb3fc615454a63ab7dce7ec15d +c75d1cbfddf557e170e61e6b7f4befefa92ad6fcce059773c93459be224625f8eabf8c980817d5 +f6de4148df31d52588ea74b3b3004ea272a019acaa320527c30f062847ff07188f4ae909276277 +1fd1d4c6ef46485eb5f93baae0e23b3c6112cb99acbdf89adcc2af3149f279cd160dea693ad05f +6fca6d1f680072271fd56bf168747662274302c8a876ede8943c4a81e19548e481b7163b28f621 +8bf9c0a342e0eb3908d4d68421121c2038c3737b3f87a91f7305157de1befce92cd649d678f282 +19fa4a85c6820da754c3faabc6e4498f4f1bdfb3c3659fbee09e3138c459679f50aae5fce7ae83 +bd27f7d36af35898b77bd7e4e17684803512d08d1dd46f450d38f287db7cac2d62acced724a55b +2b386a037c7ea3e071f7760c0b265e6909b7b4771f65ffb1180eb65ab05515999baa5e7158cbdd +f9bb7e6b3bcb1ccfeeca1529b0610a641515d280611a57567d3c89199eb304544c45b08caca6c4 +8c37ff450870b4fc497cd8b8234aab841e5a5df7087d2f87c3e6913491a7eae4aaa4519aebc466 +ac20c55bafe9d902ba535d26492d1194b6f7712d99317e1330539233aaee66c600e6e8cca46f69 +d36edb4ebaf462cfec531694b24bc48b8bf1066bd4c6b491ed7752f75ea541236dcf03db361884 +ac8c43fc90881800acbd2b03d0dd33d2322cc557b6b37a2e165177869493e62f7d44d52bdbf6ad +9d201e40d48806f82b4b5a7de983fa23b56ad4bf98fef607fc9a65018490e67f77af14158d24fc +65bb6ad93212e65eedc981e31c9a5efb1fbcff7871b334fc1ec1f1488e0908556d21f5764cf53d +988533428eafbd5de226741db292929333835aa0e238c42f236413ccf8eecee7bfc53696d04bbb +d3f4a85a40895e1f5b5287b7048b00ae9793269864277a9afd2339bd6a11ffbb555b4440569626 +07c6153336a1ca3eeda8faaa1222784dede4dad07642ca80c7499ae5add41f362d3646901bf64f +a39ba095410acfe9f61c40dbd9d3b165cfbb5431c3981765eadaa236afb5cb20a9249f2e8878ef +ae50276f8595fc6e2dc9d7698a3a12950b16df451a98b842346035ba709c2f97c276a098767478 +dd94030d9a25bdd004bde852fe18687c4b7d10a12937eaf4ddaf4c9f8931470f9c3ff547aef514 +b833ca9edbe69a329780c163b2c0c745f65522280c9f68e242030307825324503b2c68a0d883b8 +5d1145b33488282b86439f43ec86756935011a1e329deeda55dfae7f5abb1b72a65209c4e9cf72 +a8c5aba77735678f059035966df37f808b2c02b0b8d9eb3ba37cb97ff050873885f628288dbb0d +bb12f8fedee37cd9f696d3d161c9b7a618c45199affd00efb35aa510c93f4c5863ec5ed5c0c516 +191ed0c7a6a6e33bb657ca1eeecd30f043ff90db5d660bdf12824857de02f4e28506194176baf3 +e120615c61c6a7cbaee12e04518298838ebf5fa06687e02c4a5f3ef1295d8d5752cffd437d1aea +3e225d3bd442ab56f3e17a51ec097822b9f348fac722b9abd52681454e67083037dc3dfb6ab9ec +c6dee2e7e1a65036ab986db54fefb6254b1c77e098ce908e703da68e899082a1cd1b8622677008 +49c2dec69d3b4382d9f65a69626e5b6c5d921b0a36c0103dd0d03e11b60e04192d823737cbcc11 +00a5cfadd79a5ca45ec2b0cc8301b4bf2647c5ee233c8684da2c656b14589b44854feaf50100d4 +528f414de3b1d2eafdabdc82311d75b019f2ec387ae2fcfd42b9f200ae84bffc1698146ed431ad +69f3e2b2e00000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +cleartomark +%%EndResource +%%BeginResource: font f-3-0 +%!FontType1-1.1 f-3-0 1.0 +11 dict begin +/FontName /f-3-0 def +/PaintType 0 def +/FontType 1 def +/FontMatrix [0.001 0 0 0.001 0 0] readonly def +/FontBBox {0 -218 863 688 } readonly def +/Encoding 256 array +0 1 255 {1 index exch /.notdef put} for +dup 32 /space put +dup 40 /parenleft put +dup 41 /parenright put +dup 44 /comma put +dup 45 /hyphen put +dup 46 /period put +dup 48 /zero put +dup 49 /one put +dup 52 /four put +dup 53 /five put +dup 54 /six put +dup 58 /colon put +dup 65 /A put +dup 66 /B put +dup 67 /C put +dup 68 /D put +dup 69 /E put +dup 70 /F put +dup 73 /I put +dup 75 /K put +dup 76 /L put +dup 77 /M put +dup 78 /N put +dup 79 /O put +dup 80 /P put +dup 83 /S put +dup 84 /T put +dup 86 /V put +dup 90 /Z put +dup 97 /a put +dup 98 /b put +dup 99 /c put +dup 100 /d put +dup 101 /e put +dup 102 /f put +dup 103 /g put +dup 104 /h put +dup 105 /i put +dup 107 /k put +dup 108 /l put +dup 109 /m put +dup 110 /n put +dup 111 /o put +dup 112 /p put +dup 114 /r put +dup 115 /s put +dup 116 /t put +dup 117 /u put +dup 118 /v put +dup 119 /w put +dup 121 /y put +readonly def +currentdict end +currentfile eexec +f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467 +b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de +800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f +2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b +9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799 +69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5 +8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251ca86f95a94833d0 +8d0b2b6b81d435155923ee9c7046f10fa5944437f0789b343c3728b26aae735ea3940b2bc80830 +be8dc2fc98d2216521f2c415b3480fe8480031282e63dadafe2e40c856b872ee52d67f864e1323 +b1d451d25c651be20b560595565871247a196e066cf9f22a4f77b5163b70864c1728f4154ae6eb +bf6ae1d795a59d5ae1f95b716c5d14f37f654ea4164e2b9b4dcbd34d3d470afe7a7bc11b11d7cf +be43d3bc4118d83b63b6978c13a3a2737b17dc58c0f73f094697fd9a1a67bc502ef207697352ec +1815bc8ff639c49e73922a19af2c4618cac565bdbb66eecb40fed26a26f11f28447a12a02a21cc +bda5347d6744a61529bd4f06003a785baab7418510706a7d58a56e1a95ff11b58fd6f83b7343cb +1f70e02f3e8f85865d88b83654f2b81ab5b39419480e1f118dc8c5de58aa1c6830b4ca1d6a5b8a +3e1f843556d7ce3178464c94bb38a9f0fdcabf412cf3112c29ef8f08468844f2743482b860962c +6ac3a8ef8c7625e1bedf2ed9336ab3dae37995505c15b19d428f8b5daa57af42ba7b1bf379d754 +cf55e146b877850bf9813148510a255027d81c4c88e270c055a8804622822cbd827327384db221 +c71e2ae2f049ff77e6917e221ff0feec0f10afb6bf09554734b420fcf048b73fe314c15329c537 +6cfb891b6563b574a816e6eb61341b1df88b3c4e315d8f94e11a2739b3a772352ccad3b303325d +1df6e421bb8a8c1776627abdfbe89fc837a99c8589aa8c2541284056b6b76d414e32b39e777d68 +51e26813c19a8dafc0aad81a0fc95a433eaa684798e2e022367f6215bb60561df62dc1e397e16c +5fe50a86a74862753bf9509b9e4439e40a9b9d0c253375099ac2666cbaa743b3f99680cbad1f9f +28c618ebbe1731039a86420be28ad2efaf22ba6b26c3a0422f9103a887b3c608cc02a50a3335d0 +b00e5b9dd3b40475e13be96a55b5c8ec59fa6b6e97bf56b878ab1f4691634984684a806dca243b +f0d3042fd31180ca1a448efb877a09c24b4f42a51f04fefe5ebd35f71c9c66f79adf9170fc65cd +eba73694d23f165c9b4543785339d341c5559562cec1a6896113ffcea8d1c0aedd050496ff1472 +44175ba71024dee93301d73f7788700bcd143346fb36261c48addeb290493ada42557431717dcf +88388dce150b882cb3777fbb4af33fddb37c1aae49298168831e9e1385c733cc18e07ad34641c9 +569317fd19caef36a2baf03952801e8a6f486ca23b60c4f2780fe43aab8956053f595a88362cef +050f63435ba040dbfc40638e728655048e10c191c317dd9f40bd0a86aacfec7c2df909eb701ecb +11680cbdccb4fa0b5832eb2f06f1db8ebac3ba12e64468fb50251b9da6a4267b5a487f561898bf +60f963559812946797018ada18f8ed7b453108a15ef1160dd1a3979f90e87a86b7afb3d8cfb8a1 +37edb947f9a0ed0d0f124e9358770c7e4c17f209e4c194202c238ab36995f8ff4e70dc7504e27a +60383a68efe2140d96cede82cdd912a681ddde7fd8217e2eddbf91ffb087a2eee987396991965e +2ca82ea1d5a06915e9518acb56edcce9f7717b47a3596dfced09bf713194ba9109af138130f18b +83d8ae0cceb51a59d33b3e275e3bdee9018d6a08fd19eda4bc18665273631755d1920013a5d89f +5e9fbc7665cad0f39631b24043463cb525036552242926a6542ee5df0b3e877eb7140edef3c1d0 +180d0246d064bb5928ae68403ac7d2827b443e315de8aec00cfecc4e630ec86f9d5ac786e9bae1 +bd3c20da4a48510c1d492548dc490411433daa6369e6c90e2336d6d2ca820f00c1ea152e62e4d7 +e5d8df02010aa5fcae1f73a9bee1a9d0e88d7a665dee54adeefd541864e34457ad5349f74e01a7 +f6a84a7fa50fc2243ccdb114b11698e10284f38b54ffe172e267b06eb0784c3cc7432f10506750 +12bfee4ceeffa9c8fb4722150d534082ada90cf9e865277a7a91250233794887964ec5cf3e0bb5 +0add4fbaa13079db14ff017b826b60111069cbf6670d7298ee78a991caa1cdd35eaadfc214b8b7 +8ebd6535ea829f51aee17997a71d74141849c2911c9769006593c300f4f8d6516199c4e5f9e78f +2c0df99f5b2d204757a50a81883149c18b85390df9ce91a369f897dd1cfdd5b0d851b37375270b +7f0a4d00d1f6c1f50734b2b81acb0928491fcdeed5b4aa4f6cce8ee697642b7740cbde0eb0f700 +c207172ba10f4b3736eb9634997ead70a0fe5759a850ccc463d115556c797aa07b8410bec4923d +1dbd86993cb7dd85b7baf72635b8ed43f1c097c1af30dae9ed88dbd836ad0221157867b823ee82 +291b22d148a21a2cea6e32108eaa96913c2738cb5d7aeb643271ab695d32119bb23349404a66d9 +b440f6e07ae280cb6f28343bf6d6a813a2f93dc72e1af0c9b14a6c4f198a2a1c13093c82ca61a1 +1245a3e65d1b21bacf949d433cdfbf0436c98a3d1101f0286ad23e5e31e32e914ffac0846280aa +ebd69c374e657458e34a1f62669b8442a493746839fc1388688c42d0533c6214558a318fe982bc +c535aff08d63d648e9c29f21c283a9a6e6d4e69a93e663ae6e79bcc70942ebce84c603a46e566c +39b3b52862e107ec1cf14b1788d80877a1fbf480440f0c8320c167f3bbd8d84e4380920c955865 +3ac2af34e664f095802fff98131c910207b85c892c1a53effcbdb17d34c090bead2a6959f12c1b +a7fffd60da6198520577a36a06f07b42cd53965e4d982ec5e028a8bbdc4a4c7eee31104aaf1746 +d015770c116c27374263339b49990a88271ac21fd1af0c6f3021d81cdb82c88ace90ba107dcf5d +1c2a5ce7aa19054cc5114f1799caec6c61130a56fd5299ab782119eb5c333bfea8472f5fdc392e +14373d24b03e6cfa99d9f2ce4b9bb05d6b01ca46f28adb6043b5b29ac31fb563ef3ca31e878dbb +a889fc5b81462d886703eee88551410abfc1bad97b5d09b7aa62ebfb781d9055c8c645ada7bbcb +f322083ff8a82cd2c8e884132b5019395ca19b39c2d56ae5b3b99e17994328661ce93f29a04629 +d34dad4bd2845d5f4f67716d85e8a60d4f6f622bd065a56486931ccdbae656b5a78701391cec67 +b54693af9456c89422a15050663b5306247455b4fc75e3d29f322dbec4ede685ef5f7b429aecab +a4953ba05caa4be1743a167397507281d9c0ec064e2cf0d95a8108e14ef72eee5c552c0060fb82 +2ebf473cdad87602f424c10eaa3ba2fb8514acb56efc81293adfced484ca321ca362f8270401f9 +de2341a745bcea5265788b73705274644023d5a64959d7e758d521493f4a4093e529f9182cce19 +c84281c77de62632c691488c92115b969d60716bab3fd7a6227f5cee1de837bd6071ddbd05aa5b +56593e941630c4a0192ae609072d1d607e9bb491829fb1ffaff10c05d34d16d27ddf8b26abfd89 +0e599754de64f12bd54dfb5e36e7e8972b5c5a7d3ed1c189cc4c17d02879ebf236b4d6f4854ecb +2fa37205182932315445ad348089ee0a282c3ef108a67ad72f76706b5e3023e28f0ee666f990d9 +edcae6d765a6f5a7beee6f59997ed1d55601cfb3c058e6e8714e2801aca0fcda0ed402a40be92a +aa799595b41d5bb131fcda50593e5786e1f279cfb43cd2a3c8d526c434a9e5b64d7212e52a7529 +9f9ae455ae9ae24d821da2073a55517f0fedc4d981bd48207167c707ac313f2aee221136746ccc +9e6ddcb54ec72ef56ed206d5edabb3be99c11aafd1be017610865b1169a1146896bd5897e91168 +42e14f09cce33afaa27a312e4984e4cf7c08ec35e2fd5c11328a8d90b20638c55424f75fe0f0d0 +ba5ac51b13849aca66ba864c4b99a2afb4104bafba33f822c0f9a45e49f8aa4fdf5ad8d8f25746 +6803dfc534ac21617d037156866f286f2883102eebd810f1e4bee63b4c4ea0fb1b23aad2a00033 +5c83221447cd29e4f7867b2c53b32fd7028a72355658e69ccd2e6a8de48472db1b16467d3c46da +75f8c6688b79ed761ff5f48b83d7c17f6dc59f209e7ac8ef6176cad7b60f389f8a5f102dcb4e8b +6fa1117baa54876d7a8e9d404bad915d2f9693a135fc816802d9905d57991f40d48806f82b4b5a +36e8f550145c4c9dd8b228205069aa567a3c9b2428a3d60a219be66d0aafd401c050828b582d24 +d459b11c45cbd006e94890901c08802b88414baba4ea1adfa490826e51b4547d96f10f093d4f9a +40f5e86a259124a1da167c6c9032d749e4ffc9c35d33a21ec60a328aaf7ff1789cf399065d8d51 +6535ac306ff1abb9dc27d1c379ad58d098c112f9d21e333146ef54109572745b1981cef13860d3 +fef2f28133cd6ea34e1375837b9857299c61fd9e8570d661c920d248890a1052b9c1b257dc379a +5e61411bc2e06b5a62e71ab3ed9f0be788f6d726a04a5dd1774ec45d60c70e4d92a30bb555459e +9b7b864e2fa2eaf3960b69593c2140a07530444055eefb86704fb75b57b37dcee77df572f636ab +9cbb0eedb18167329bfaad5dc31fa1ab3621068bd8309c19000695ad2e26874b900fe2081725f4 +aeb2875759d2c936b67418334b2331da3def41a91a9dad7002c3368dd376e8060aa05758ef822a +c9f4d4dfa850a8808a56a20009dc7dcc9c8cc2ebe9bc8a1eb0babb8388962fb958d2afced9061f +533917fd5aeb4d59b2c9170b292e59ed09d0bf0cd2455690481a252b883f3a7a4f099498682abd +cadf942f4256988d5d9055ede536508ef15d137715184619836d198a29360a9d63b9d72ec8af97 +1d0005c94c00a2e8b33ef488e344bb04e87f4a4da23385263a2ffce2403c3869a43560995c1ae6 +4fad972e6c4ad85e79ef9d7a62063ce4dd3b01b10cd300d1fa43dcb1ee1600d57d0c1b6cd40ed7 +5db99a6a150897ddf24cce810172abb39397d46120bbff8bab25feb1a161c8b70a85f37048d84c +dc460a6e0e58bee51ed5f5352ee2285c18d38ae50a227684c11aaafdef97c4b1c9b55fe861af82 +5936d6161b377ea659ace84b7fc58cbc9c73d820c59968399064bfd29c16aba6479a63dccd9dd8 +fe321a307a1b43eb06c1cb188fa1fddd50fe2136bc1582731d1219796f2bb69ad43c159be3cbe8 +97cba9d8a70ebfbf468dff2e42d9d23f02a8c156bc6e56770ac27584e467115b07552625f093c2 +8693124fb707abcce7a399cea7b8c79acae216dc09694d2406bd515ee240943f7087bf3cf60250 +b450b2e44952fda91bca7ee3601696c76befcb7b5b93c3f0180c453f419bf3c4f78bbd17a28ba5 +ae2beb407da2b1fa379172f2e43cf8d5b42d233c95f4fd856d7657a0029561b5f5731e5606f466 +d6140b4d85e20f5a2a1d18867909a7e6a9249d6a105524c4be530e843c91721396642e3a376bbf +e0a1ba158b5828fe09d5810792f20849183beb7f729a472a0194a088693e1080fdbb905f297195 +3b2b8cd3cbb487cab9a484a0d4acc8e073c690a8f3342f0347b8eca11cfc10f272a08f5e6e4718 +863b00be5d12f69171148f58d513dd45ba561ee3ad69a3ade00bbc530e05cb780cc09abe864ce1 +5508c6792282c84cef6e9caf2e60188b3ea531adb52e3711a58fc8fb38ab35ba24fec79d3aa417 +b425b35365abfbe85323a0eaffc1b6d3ff5bac216906823e0b3c2c90715aa02ae4dda44376e7d2 +35c2729b698b1eacb6bceed9171cd880c8f1d4f16540bf7b5db5b86e589b06086d0fc131795148 +05ef7d3d6c9c19ca47942c7f7b1062f140d13c20bedf359300eb4118aeeb4b15256404d2113bff +a5b0c4a43e39b010f56468cd635ce10d5213a0eb6444628200bd79ccebe2b7e5b6a41a816466c9 +49fcb816fc7e706edeec287845d39713629a4c899da989ad8074f1f38917fc817c1939a22679b7 +459b6882963677c24d852b70a13ca09bb09f49fd0c8b8232d5564e6e0828d7465e6ecbf53f5e7c +7f36daacc5d84bb3fb5919d7f9fd036985d5c4d17f8cb61fc80f8a680b74894f609d5ccafeac2c +c31b043f27b3fc2060389eb92dcf6c921066653328b9fd4afdbf33d9bfab87969b75ed0ebbccb0 +3e6576befc61e5624ede9b72054ce4aca9c528787c362543d400dd43e57ba848145e3cc07b7ce8 +7faefa4887a9222af1455b847d990fbd60f049580cd667b31cd35ffcdaab1d5117506ca8222459 +d38173bbbeb48e77f42342dda4bf8e1f46d22d2cfeaac8a6e8cef685ea66a0413deceab63f9490 +cbe5d17dd2a24ac653c653c5c205478bd4a37e1664998e83e5365136ac6b71b8eb713bbae9305b +3bb6d2749e4e9f4d00a49e94b4faf031bc4cdaf510867602868f208c37f133d72571dd9a438a4d +c37ca42a71dbee00706bf1b9d87741214b2742918da849abc1217fc9163ea5ca28fb6e5ed506ab +18f3f0d3a0612899f38a999cddfbe593790019b09e187df66c6e658fdd8b7e6b46aa4c4ab9441f +cba7e13442419f1748f87d61da65e684861fe4b00caa610b0fcd0f960b2f19ee3a601678530fd9 +7fcee51cda2b52531bd4f96b29890d431b7a99aefbe95edd1346a239f13b830df8106eb4d31168 +bc8fdb392a969c0c1e469a2809cd06dc45049a381c0887a4a1173c62877a9f73015247cb344545 +e6e9d3602126c40d56f3f7b0cf2dcf9e8b17d01de13fda488790774c03b5ae5ccab9146d05fa51 +5a77a504c1979640939fb6293c193df29da0d5911bdb5108b8815ada5c2061e7b7cc722a000ed9 +ed4e12f9a7de81f5909d124a06ae4871c10776e18878f062e655c3bc80bb497b8ea0847a31b095 +0d36b24f27ce5ba3b6925b352a88ebfd40f3293e79cd0191ae1c03597e6610c6189f4a5c0bec35 +8fc11ccd1a950ac35cfbf5831c11e1e58626060cc03d8344ce15cbcc92bfaf4840a2950a24c844 +f7c6a640a63625dda61cb36c5761de65f11973e9da0e3070cb8a8ba456fb704c313c2fa3624a91 +e89d713d16ae326896e3ec7feb454d8c03c75552e0a2f50c29e068fd30ed95bb1c99652e6bedf3 +d93aefa23f1d0e9d0d05796996f286bb5922ea918e9e4b590abf896305b0937f1b03ecd8a0f33b +29246cf85beacb2f81fd0e851f91f58c75742ab7604a3a52b567c3effd67816df673025e34e84f +10755876db690f50a3c7bafc64fcbe419d004794523f3cb46218967e3fd08d15fda3fbd5c4368d +5124c2efb5381856f76e792e80d33abf8b86d0f43a39ae8b369a5a22ae53eed52361aa7a4f0bd9 +f949c02f4eff174f8901e1a6d6e259cb105c338673ee18dd29ae63205501df93ad1123491d4160 +33c3fbebaef1dbc9c4094b8845f114a5edd020fdd7d2122429b0f5d15bd1ca939f3febb7c62af8 +fb15e1aef578cdf32d6fa848f4438aec4a814933845964c3570455d794c36c728d778f476ae173 +e50c9db1f77796af16d6129755c9ce641280818bb071ade4d23cf8fe2db3a184be7a8a0a935984 +a77aab024c9135b65feae6597e780a4a25f244190a63c881a2425d7bbac57735209948f6d108d1 +1bfc031f70cd677b3ae6871811e3e63fdef0f0e76e7fbf2298f30de8b4abd8ced098b34112737a +a5cea6bd18104bf2e6420f6c71fe25ddf1ad3bf69ba7f9c414a2f6733ce0073c7c2a033bd1e2c2 +ab0b733121512035ee4f7a820f3b2bf2df3504d2125982f315441a51213f30a530a82930d1d32b +a193cf34251887ea3b66835ec363eb16562883db3ad1d832ee066212c61354405749871ed80b21 +819e209efb56ffcf0f66209746a2a6af0fa9ec13d82d38091134d3425427cfb15adaa6794bdf43 +8fe90c5608c57ef653faaed0164fb7ecd3dfe826da96c33d12b4c1577cefbd88a0e26709496035 +62aab942fbe3cda252b813dea89ff34db3290ddab8d3f112b03dc091ad9a3f52c4e859bd5506d5 +64b5558b9de604bfd101c4808472c0b1415a594f84537922ab97bf44a5c7a86df10dbcd0885539 +794e57e31f3fe6a7349bfb91277f2060e7e4a90fb6302442c9e52dc4937b8b1a1aa14f2a832187 +41df30fb09a245c22fea67dab8a747b2ad767525e3119503b176bbceb90580ab5cefcce78f7ea6 +e4a9e4ceb386cdf25c0e8bed746364f6098d3c0f63e6a9b338f08ab87d06da7f0b0b46eb749df2 +09f23690f440e36e055cbc13013e94942cdc6f90f39356b340191b9c33f1ba874d99ec82b16000 +600d6bd90656dd1bdfb677ea1a677810b23e8809dc701f32cd1248af36257c8655421572f6c32f +6892675809a460b9c61134d8204d553340b0911a45aab8ed600e3d764ee4ab9da1c0e8f9f2b1f8 +0becff64858ae24f42fd8a0bd4af3429d2a9808c07a038b6f25fa9ec80bf6bbc8020f7ea4b192b +915633f73f4f73f93e854519bebfb07a4ee2e27d65966c868183b992f8e6bdf8674d52f13b5b69 +dfea9e68da5ab759caddd711d91244c5b542e9e503e08bea1f1c3484867bc853070acf80e17259 +e78c6a4d5e0b21164a642237b2b521c4c78c77fbbf6eed6b03b7739de718e5b40a3e89f72f8738 +1d7b6a964d4dcc86d3c62fe9e0c5e45e077eb24cf3514be9d7bf23072f79656778a133675de8be +f2e9ef91c03d6c7cd78e8e6a843aa144bef9eecff8a044f66272148792c206a20645edf457c8a8 +e054bf247cbe33657e6376bc391e3da791328198cc1e94b27109e711e454958d8868ef910609c4 +11fa2a1c31ee8f1953b87496ce0cf98b86b9c8ac451239e34711329a9dcb9c435a7843a2814af5 +082756fa21240d06475671a6f95ce10d6dbfad13d66d05d4a7be360597aba7cd2ffebefd111c9e +ece937c1c9587cfbdde2c7d81434b8c529ceb93f337ed1becf482fc85a8e8200f83699b029fca3 +c98badb16c9daa6cd0caddae9739948b70a2902b6b377ec21cdcf2f5fe975d0d9685865cc94a2a +00554667cfaf5ee5225370ff06a439e9e3f593b4d436781464d52474fc11f00b413e1c13422663 +1f2974721d8045d26baf7a3a1f3345ca37e0de72c06c5407c47ab5f49fa2b3666fff35831e10d0 +e68e8adfc2f08a5a8a996d3091cf9bd72cf8b22102d2152695c11b0fb6b41aaf35afb0cb3f4618 +788648b1d74f0c39140b34384f4eb8a230079e602dd038ab5f8560a70e5c256db8fff38486ec8a +e38ed67f9082f6473e381d75649abe8256bfc6a306acdd863259b9e7435178f8260bc6bcd5124b +d0480d0b40541fa35d0c5632081700dd658f40996983127429919b3cefa7968c03761b71e51268 +08e9377f03af83a9af5c9640be298ff88b0f85ee2ef6ec4910f4a10ad2771aede8aa97262ec0b7 +0625f9de59716162228161e8cc09686c988f0ba98395b552a1094b1181309e2d02e6038c10fbf1 +b7529fe648230996f698cdf465e154c4d0f14fb6fd57c7ced54ef7401ecd2370f636ac0f176600 +2387ea8eb418f6584192d7b2d640b9e98465056daf1f40bfaa5512404a83150d52194476dbe031 +601b1820c0b184ea71b57bb05d52c300f02dfa4c7befa0f116204a56e7c36b783dceb9ee1934a6 +5d479af0e6f65e08d35a029ccc1df48411b029809b39c367a304c6416f16e59cac7b02e7699af3 +4906b9cf28a6b01860794ed6ec09f26c198526201b0cc0000b953a0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +cleartomark +%%EndResource +%%BeginResource: font f-4-0 +%!FontType1-1.1 f-4-0 1.0 +11 dict begin +/FontName /f-4-0 def +/PaintType 0 def +/FontType 1 def +/FontMatrix [0.001 0 0 0.001 0 0] readonly def +/FontBBox {0 -149 619 691 } readonly def +/Encoding 256 array +0 1 255 {1 index exch /.notdef put} for +dup 32 /space put +dup 48 /zero put +dup 49 /one put +dup 50 /two put +dup 51 /three put +dup 52 /four put +dup 53 /five put +dup 56 /eight put +dup 57 /nine put +dup 58 /colon put +dup 66 /B put +dup 91 /bracketleft put +dup 93 /bracketright put +dup 105 /i put +dup 115 /s put +dup 116 /t put +readonly def +currentdict end +currentfile eexec +f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467 +b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de +800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f +2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b +9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799 +69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5 +8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251cacaecc7da90d73 +c5ec91557783f026804a22f6155bc35b68d0fe30ee1adb3f3edc5fa135471f083bc601ea841425 +caea0ed68b052a4cd3bceb50b7e52debb6f0ad756da1c2984ccd06a099ad167635926039a511e0 +aaa942235c6be1b89ea4db21038d2cd11e42d4744b7219e9ae01967d4b45e025ffecced90c5666 +0b21f58275fda554bdd8a960384de6a3a918e349ef0581d670fdf6e77803f84bce3511b8d46da7 +b3157ccc3f032c1a5ffc104c4aa3e7c7e014f73adf568eaccfb99c65a92b490873110c7788ea92 +a0e856d5205d1d324341c8da5184c463b9f904400179dd51175ebeeb8524215dd6860393303f8d +244fb914490f6afdc7f381bd539ee49b055f40dba188e4c179915c5c71d8244890b1df6ff4c9a8 +f14d3287fdf20769543c831c2189924f8417a5f48708f7955b9f19843ff55b33836718afd62f81 +753e05cc9754ff0f25a13dad43b79a13292f368251bd867c7b054f3a65e395152a50fc211459f1 +e3fdcc46d9014676acaaebca1c9901de89a2725b2f8177571263f5c29bc442d908ab02534266a3 +3001adbe4ed136c79268896e1a5bae78df0ed46d3666e28ddce96f88cf4e48aea4e44dd295df46 +7b6ececc2e39218df6f96c61d473aa853b2df4e3e1692183ba90ee3efcc0467a12e5532aae93be +85d3dd975e4954a864fbd765e3a30be0bcab47699d292666bc88394c1bb43ab4ef38c9d5ce4b12 +fe174d6d60a4c41bc44725659f7a165e726ee2db5b0a01d13edf73fdc9e2027ce1089386f9aba4 +b855bac325d7bcb6f9f639c3644b8e06f85874182b0ae0986bd86ba865bbd4e3d44dd6ee526e6d +b8edb72d3f8bbc55116917457527541c187c9367121bc5c326e917fbe799daa4a881fdc5ead71d +5452566aa265806c519ce4fcd24884c57d263d8b67724fb63c713fa0e977c77a9ac03d9875621c +86d960838b0e9c5c3f109504b13f3410da6aa7e02443e4722e9e0ed83d0f9c1b6ce1361aeb8ef1 +7d4f783488dd12cbc43f9fcf455d865bbc2302a560d5a383678330c938d860431a87405e2df06f +d0140252fa9e61fe097421bb668269d6639941bd80fcb4273949dd6cdbacd5f797985b9070da56 +3d65fe24da7c5c3b9816d9308971136aa66b8f26acfe4f654adb9893e4c4b34ecff3f4ebbce1d7 +3b5f1bcf3e3e2ca41d5593d02fa042d9ab73076f3093bfdf7988aa105567dbfbb4045f7c324ec7 +c577add97c283c2d8586db8e96efaae384431799b1f6eab504f7ede80b7cca9e1d07b287454fd9 +89a7cc17127e8afd2291669a72bb0a44e381c29770e2876ada11c25a095d50dae90f05f4c7af89 +4fb64ae85cc81affd577bca527bd669a72a405249c198b9bddccef4da288b9973536bb95720d52 +60fe73ca93791f77596566589cba34def33931a70110a480c0ca93ec01de2e8cfa2a4a05967eeb +6eb1e914bec7d83cd5b96b3e9f686ca66332e959d8910203a1e880f1535fee6eebc67f10d09087 +7fac75bb8e384ba91bf2667689bb635b395df0e9989ebd4c7dee166061a1644397a03392785c73 +8253d6a1764778fff4652db845b95e332df288d7e3ce56b752e2a8099a6bbf8fbe8b4c6c2541f9 +6c25d1efa18e9ba6034208198b3990dc31559699c22a3d616a40480bd63ff4962e5cb8f653d93f +7858fa73abb05b47708ce3c3ac649262007f174e6d5f9b987824d27c8bb08d416ff13ac9a42df4 +4b10d9fb9c2d8016a69cbb358a3ae0c3f6ac14ac7549bea5929c556ee63a2e13f3242b926ff61b +319603e05554e1e444f6561d7edbdcd97388960efcaa573c4fa651805f599b28e53bd39765251b +f406df9f7c6cf164c2564bd1fce989468044dd6f33f6d495ff68194047885e6f9cf6cc2157132a +5adfc1670f1b72fe0e7f4ef1a2c445a994f1d3293e02cbfdd983e6f16feacdd81587135fcd71a1 +55b7885e7cbacc6f5a9e044bdf3011e1ae5b10f6c1b4ae7abef36e5dbe6e507d62f127fa78a50c +a073f10fd2a9fdd0d39fe1f845586ef05cc7e79053981c92059b356b3f8ea3ae442b7da88bcdf2 +4dd5efbadabd93005455ce49848865cf657db6a215655ef4887a08f6fb79f426885b2f805aed11 +ab2184f3f5ae05d81583febccda15ca56346e83f3e444263b692cea22d8f834fa56963c69024fe +b1bc660d46846ffceaf7b55d8710ad0266f97494eda544c1678929bd4d9f8885ee5ed5635e5abc +6ae15fd7ed5abae36d256ba0402b03e4aed08b27f58c53ca179342106d0a08743e292243c47d7d +35ee3bccdfca7e301859a1f692514b949bfaa7b017b6cca5c74a4e573ac82ab98812c6fb27100c +91bc05332cfdf2935b993ce91f03dd7877fc5e8b4027abc9c9ae3380f8e3e62130d7a8b2a9305d +eae567c91d6159cce42144919b84535e8d4a3f0cb8168616af05ebdcf9077bdb387b1839f69b39 +9139d4c82403fdc5da687cfa4350958d0194706d4d9ecf63c28a4fcf7d163e2cfc962af54d65af +759170eda5b64754950ffe0eab9ebb37cca60fb322f0278b02d2567b8e077724da7ec79c31f8aa +4a5fb455a9eb474e449ba885e4439af0de9581ccc6b06965fb2ca887315e813b29ea2423c34e60 +8446f9652a0955f89521b647a22bf2295a846d31157827f47600c6d65d9c98e4b247b05c63e016 +931566a8a8dac6395b2d0a8f840292dfef9e4876ff63511d6390557eab5f57df96ee6144207c68 +4a541d51c9e14a22cca83be5376a56d3631f07a49b9dcea4438109d854ef2964146ff8faede30000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +cleartomark +%%EndResource +%%BeginResource: font f-5-1 +%!FontType1-1.1 f-5-1 1.0 +11 dict begin +/FontName /f-5-1 def +/PaintType 0 def +/FontType 1 def +/FontMatrix [0.001 0 0 0.001 0 0] readonly def +/FontBBox {0 0 598 718 } readonly def +/Encoding 256 array +0 1 255 {1 index exch /.notdef put} for +dup 1 /g1 put +dup 2 /g2 put +dup 3 /g3 put +dup 4 /g4 put +readonly def +currentdict end +currentfile eexec +f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467 +b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de +800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f +2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b +9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799 +69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5 +8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251cabe8722c0ba224 +7e4445af50cf2457d0f320e3c977464560877669ee2c12b26a2295e90061036d976390cd9e8aa8 +60e283b4b9ec3d54810572bf19c1c0293f6e626621ad493b8bac5cbffb1b6e4f4bbed8dd30c403 +0238cfe9ca871165403135f7d094e98e1613acbbba0490170e78c32e773343854d58974a818fd8 +7a58cc2616a13b32133119fc75de0319d440b77814459de10ef97665747620b98b49e7b4f16934 +87f7a6a10749dd2bc5429508df28d061a4c48d3b66bcf61e129ff887e575214bed25bcb37c2423 +ed099f4bc377ddcf858a40686966a3380f67c084bf9b331b465f844ce3688d569de2a8507b508d +6388de0b7c58c430d6fbb45548555ada2d181eaa218f324e513fcbd64acebc98f1814b8c162575 +b97dbec5e2c55466f35e74664e26fd8b7ad859491c0768cacb2f9e57537b4da94de9bd871a5725 +2c00c78d46fcd47bec690832433feb71c1f93f58f843aeba0571b28ebdf4a9d8566d4847e23fc7 +d72c1aa549a0d9598f03d7acc286a3bebf3dc23e54b12e813590c425130665fb440a2315e1350e +b268673716791b0a1e48e2198dbe06c4c761e5bf97c6ec4e1ba78a9e509463dca4bc002e6ad030 +e20000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +cleartomark +%%EndResource +%%BeginResource: font f-6-1 +%!FontType1-1.1 f-6-1 1.0 +11 dict begin +/FontName /f-6-1 def +/PaintType 0 def +/FontType 1 def +/FontMatrix [0.001 0 0 0.001 0 0] readonly def +/FontBBox {10 -207 765 727 } readonly def +/Encoding 256 array +0 1 255 {1 index exch /.notdef put} for +dup 1 /g1 put +dup 2 /g2 put +dup 3 /g3 put +dup 4 /g4 put +dup 5 /g5 put +dup 6 /g6 put +dup 7 /g7 put +dup 8 /g8 put +dup 9 /g9 put +dup 10 /g10 put +dup 11 /g11 put +dup 12 /g12 put +dup 13 /g13 put +dup 14 /g14 put +dup 15 /g15 put +dup 16 /g16 put +dup 17 /g17 put +dup 18 /g18 put +dup 19 /g19 put +readonly def +currentdict end +currentfile eexec +f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467 +b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de +800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f +2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b +9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799 +69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5 +8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251caf30017b277238 +efcf5771340938fe80f4a00100eb95a658bfe12cfa81b2ff0bba147bff00ce168e6420a3dc8e06 +6aa0bfe90cbfb7f057f1898c86d3f493dbb2ee898f02195a2ac28610f02e3efc4bc51f799ca23d +48f929a97cd8a5dc21209e768d572734c27ee95e0b879421e7e160e9169e0cb328cb105e6f165a +ddd03371cecbcbf2c23093862ee0687e97b8da45dedfa4406597b9fcaf7c53d837d3c18cecadf4 +96e0ee48da1e658e0a5d4d5dd795009de9bb997f7d287d98eff1348b2f930c2f488c79bda1809c +2c69c3d8212b97215e4c266d8591681d57a76188e2593c955f5f238cc2b936b41fda0f82a3e74b +49fadc77c72fb21041d2bdb7383c5fa6476f6c53a83bd9e364e4ee2fda0d01b7d729d89b17cbf4 +92ade6e8ed3aea9a476bbe0b6e6f7522a3fbf599c5d96c252e0ee55d5ebe56705f000792cd4035 +0d135cbb40eee958a0515b7e6f581943b89789efc2279b97e5b473db7786c54527b20b7f04f84a +d410a73b3b3fae1fe8adc962715bb9f78113bf8474c6a5a706362ca8188103484eab2893173ad3 +58b06ded359ff892c776fcad797deaa0808da173200e5ce8c1b231993f297251d4093d13186690 +67f5b53f480868c1b311be85e8893b02e7e5fc512b4d4c49e38a620a297b211c3951b9b5d038d3 +16025706231f3da2e4f1ffde9c5ba5604957c8ffd6614fca2d40270bf3b125763fb74c18a85a15 +6a3509ca2fa520a39c8a670107a9cc898278868938a941e78bd3fb287f05a79a59124b075921b7 +5193f48ccb2f8a95df94c5019cd15af87840a2efd048afb0aa8d79350841db6e3e498b4312c63c +e480d5839ba33e1e72c0d37ca7dc218455601c05108c9670a5f38aa1eb020d1ca244066f2391f3 +253b920162164ae329c8ba6c6bd164d7d40c5198b74183cdb14548a5a1cd6c80a428edb3569976 +8e303df4bec93944c1a54e76b9bba8a04224f2fde975dac5f6bf1bf13862d1b63e0debf5f4c3bf +f52b7bb3fa99d6fecb9aa0ce10052785215a32abc7345d1b0fe2764407e2a3fa98ad388635a731 +446a231e24d6f8b46ab63904d5073380477f02dd5cac17ad1a7092c206c4381d55e5003fd07f3f +c2a6c59d239606ed62a37adcd2255540315556087925480495187c2a211c62b4049acd52b2edf4 +247839659c5b8010c95a52eebde35eaa567e2731155e87ed3d870bee3c9f5d2143b5b853a718fa +1e67f5c7985969a91c79185ce19c411784e23f9e056923b9b32073a3cc567135bf96302c60195f +a1728c098c7430cdf020db8958352ac37000a33a52fee54af2c983c1a7347f6879ee684c063c55 +1cdf464418fe97553a964f302099f952cbab3135b04fda1b9f201d6fffaf7007e3ef852be20ca5 +461678c3036d075bc5d6a44e595e165b0e1d6cda9e1d359dff4a13cd74d96d4a7cb7a8395a416e +edaaca4ace065e906063c1430680f8c24fd4979a4ef85c5fb0afdf4bef57a7d8399424dabcabe9 +6d04b4df05123c83b821df8aad7e1f660563553eb5911ac97a3026c7ea54bdfafb92c6e8526de5 +75f6fc05aa958caa9d8708dcd755393d00f2b165e27983dc5dfe8e85f1ee5b8acb6441d225ba80 +1bcab485bc092c42a1c638dc5bcbe82d5c230b8b489a468738d77d8470c387f982e08f0854e306 +aaa909b040508802dfb69bc7199dfe6253198f2f827eb735a5ba52cce99b4a5524d94ef300d573 +b4f3d2eb4a59a3cb49b3c7c7c4631b341180852aa973ddb953eae7b6875a71b36bb98e8d08368c +7e713931365e12fb3d73160aed387a011cf3981bab53d777fca3d35e4e52f71ad3fff9c917c9c4 +31502adfaf9c4ed4eb6454a11932f07f831eff8fdace324ae241fe240a609d98d0f84e3bdd3b33 +f4912848517cf51b61edf4fddc2da77765d882c4900f616f8dc45879aeaf0d0738b6563e70be4f +d4a6dd73d25df0ad26d315ba42c2fa25b838bf1db3e160ca9a65cd40105d4fb0d1d19444ed663f +d4cbd8bfd66acde42208838e9d880807024bf00bde91477e68631211b715b6c058c3ff903114aa +454ee1c272a89fa64891e678cb319596fd550e01416cb87a59bd146698235204655f970bcb40d6 +48e4b617d1ff77373f03f03bebd7fc535c46f777b1bf8d8b84e2a394e948692ef34a90674f206b +90b5f2345a2496376f03a9a7f823a0c3b2da6a6f780d9acda51e5ad5b0f01c33421fffade18aa9 +dab7008970426715e6836340cd31856acae4448130e2dd6acfa441dd2132eac05f309f16f202de +349113ad736ec41fa9e4693f77006a570773e625f3c91652502155228ef947b415eab32f95c7de +448faa415a2b022cb675a1ad63fb1e3a29e621720c0468a91f98574918f69cdab811a3d40c3c61 +a4700f93fbf01cf1140f52cdc03d0f7ad89db843535b0eee3a5ada08b38aa84291d0575e60d3cd +51321f15bc7815341b40ed729cd18f34f67e28eedf5c4d6c8e546d3d816fd5ec9afe5fa0f0e458 +421ad48997873511b7df3821932c36c0abf6762a39a7f88ef5a2b1621ac46e4faa44317a9c8609 +e85e4bcfe8e59e626df40e990c5aa340eadaea637fb08327748a5a1e77b9f508e24b60f9088b3e +b6b9e7299c7efa30319dcae68edf5baf28fbb695f4e6632a4b6922da29c68faceee512c7865e60 +ab56e988205cacaf754a713af7ebf446a51a5af6e35ab856e730a88d7787883b66c83aa53c9369 +518b1f536cda8c5bb9431e2e15b8b94467851922aafbf3662feeeabe727ca85ef96d0a87f9d2d2 +ecf6b2d65b38687cbf5e7cc1f5e9458ae6d50d872b41273d0c648be84540a1faf3aa0db95c45e8 +06fd6fc31556454ec3670308ad32f51081f54b78d0fae5381fc9596b4e86cee88336faf901cb52 +ca864698979db1b953bb265b9a0479deae86815b8ab414b2a1b3ac97bc6ec1b5ddb7f9bc49216f +b73683c4f3030f638e70416c75b5549f73efc2bf89c98c04b02991a4ac443905e2e6b362b658c0 +b94c5980cf4469b6a7d01150e5b38fa778e93112e547d46e41e555f0de20c9310e74daafd5db63 +3732dcb6571ea7e927255036f2042d3da872b32f8a224368808f47fac3bfff4814bd74cee62d08 +cf118382a92ba96ea295840b9d9c0fac6d0faa319971dd54b74008f5ef2951cf43bc3549f14e9c +022d4972885ec5b4cf9f6b243e40c04db6e1038e02830fbbc3a535fdb6de0112c730e253aca067 +4ff0791290a3d088c41d36c08fefbc3e179f181b8825f45614ccf6ec36f5c86bd6c1bfa07f149e +caace252a03f149d89be9574e1365d63facadfec8a1fdb3def6b40214904c441808d97fbbe24d4 +c5e5ec13997fdb96d6a8c4bb09230d4cd13408b6d065816e48e7418ceba261c9cc3bf8961ce930 +e91470baf0f29ffb322c9947ef4b9d3d2344668d0edee32e3ee5dd0defe3f58037377583383a9b +c45e4714efe4af908a86d82d06ff120fa2a50a849779aaf046d04c7b3148aee8453003a30e26b7 +56ebd574319b657cee7e12f8986a12143ec399212c196b46a2f5d4c6dde2920a95738ea2898843 +4dc9d12942674e34d4d77dd3400ed6db17c5ee823bc6d7d6ab44e8a62eae05edc8e928c32e50d2 +fb840a8a501ff094e3272f601c651400216c10f99bc7f221cd9effe711ec49522c441d00822cee +8533561d408eff1b8079017f2a8b7fdb687d7d2d8d6f5c13e6f86a8d8cab39047210eba871f3c9 +d50f8a0041a2b87e30b016245e817973b050c79b3a32d291d531bda12f1be2861c1343cbdca2e3 +8fef3bf4ddfcdd3737e1c5daf454cb04f7a84bff734791f0c5cf3910672bf0bc889527547588f7 +e081fb20eec7c9cc79d1ed94151c5943b3774e6c97713adfabb12ea41a2a8b84cb79c4b2374d42 +06389302be0a05de0822f6a5f3aaf25495a955b2fb19bb5348a1706ee893561430f571ab5e3e7e +19e95c11b6dcb8b53525f318a071cde853d8eb15dcefde5652e3177256c1470db1dd98b8525880 +8e35285a36fb6d5c0d84e87dbb897837c54b4ede44720ffc5e135c197ecc836f0517ab09e5463c +24ca6798146897e77b8d0a774ce04a63380e174eb0c719c3fbf27b8fa6e4798576e1cfc0f5a2cc +a661266cb4195743058a3fe33476c2d266dbde6c4b802b087f00b47e00c88af69b51a832eebdcc +2622e49c97c96e79024323115e8ba6824fa2f14989745dde26bca3a5d8af0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +cleartomark +%%EndResource +%%BeginResource: font f-7-1 +%!FontType1-1.1 f-7-1 1.0 +11 dict begin +/FontName /f-7-1 def +/PaintType 0 def +/FontType 1 def +/FontMatrix [0.001 0 0 0.001 0 0] readonly def +/FontBBox {8 -19 622 737 } readonly def +/Encoding 256 array +0 1 255 {1 index exch /.notdef put} for +dup 1 /g1 put +dup 2 /g2 put +dup 3 /g3 put +dup 4 /g4 put +dup 5 /g5 put +dup 6 /g6 put +dup 7 /g7 put +dup 8 /g8 put +dup 9 /g9 put +dup 10 /g10 put +dup 11 /g11 put +dup 12 /g12 put +dup 13 /g13 put +dup 14 /g14 put +dup 15 /g15 put +dup 16 /g16 put +dup 17 /g17 put +readonly def +currentdict end +currentfile eexec +f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467 +b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de +800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f +2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b +9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799 +69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5 +8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251cacaf9a06b6a42b +0a4043938e24416c9f587b348e8ab9cce1d9dd4800f67cc74ad17a93d320d894de36921693e3b2 +87119b6a796a7fc043f3d0f6e1df8984565c4b5392a114ac5f057537d91adb72b79483de686ece +82ea3c32a7499eb6750cd240b3cdbcbe60969f3d59ae560c8a3a9c8bba3fc5dd714ade580bc451 +bfb3bea288781859a15279f9447bb0b478da1ae57e575a5326c2f350a04f00f45bed8a1c2025cd +9e0f071dec104144e67d1f70cae90e7a3283b44f6a266d90e43397ad1f0b320415a30af8d42a44 +ae5c0404017cb1f06f60d1a86743255d74daf73592493a514b2e4c91798f5efe24512888cd2e14 +07383ba2c8919be8027a13c91a82757eefa6c8990cc399817ff14d4c7e899eeeb7c568eba0c156 +8e1807243056b14e701b29ac4e417e1eddad54379d63cea8c456008f6d282528bce67216e27605 +ab4ca0049dd6e295ddebf71d7bcab0723df05c41a1d78132e8c118917569db90c14f6d3155a02b +1f19b808805adb0acefd0c9adb02ca937d4d9088779543a456a125ea8a18a671e3694daeeb5c13 +5d2f7091885286bfcb7972295373aebab0e334b0e776f305fcbd228b800dd00694942c0ff58667 +80c4654d65593ae4421c4416638c3bb45709136fa655cfdf7257f19e5ff4c4958172e3a38552f9 +60e7d9825f292e5192eb4c39962f07d320ac671f402715915483490abe18e3fedaa821193f2e9d +192a3dc13427c32eb9443c700f05dfad35ca227fa235e58a9b2c1cd3ba28f84a3e317e6b8c5069 +0e7990f7a372c3599001b32c11ff841baa5efdf864239ab73057a211fd923d9c273fe16e68c5da +cfcce2ec4d7cf8b9ecd316ca20454eeda23577867c2efa0d1598f01daf600f2cb4628550ad4fa1 +2dbd212e1c8cad6c49aa65bd431fa0e8632d999ae16c74a561b86f1d6492eceb6fe2eaaab2bfd5 +a93241494dfc25d3bf6fad9122fca293195ba5ef49e782cee634f59730047050bfbd4a3677e2fb +070f9b00ffc42409efe73d01eeffb757ede7001cfd62acbe2af65acf27d45a6ec036aee652acf5 +6babc8d3951e2957971bc005d5fc27d5445de37e962166fd125660bdefa4184fef7a41cba49a68 +ae7ec31ed6f030545a5fd8cc37fcc9d6c3400a3de51fadd34722162d6bc4414a84b4fca6482e2c +f2ebc61e2c6e7ae1bee5e8bbb9a550cd111ca7f5021f7a9fd0e6655bc2666b52828dd1c63f4e34 +e83e24abb4e05dd64e24f56ae451b0bf1960af95718511869b22a37921af7fac3a62ddc1d4fef5 +d9fb9ebf70a854e319630b12e259091cf392ecbbe4a95321a817c1f101cda36ce7a15b88200461 +efe9b29183a12ec915853060dc2e1cfc9f697e06ef492a93b249aa6db7b9ed8ef63e263352f584 +a16b8d5e928223f7f261dd131da40e1bd477b876c325aec3c61ad0779c53131ad4a2903eebc73e +4ad9dc21d81edcbacc6f2cc75954f12614694bcca053f8b928649a8f3ed1da05169485baa7ec5e +267d2f9102358270bc8e8e1639dbac472c462de60dda0ee60eeca10f8c493650859fc3c0f62a67 +4a297146493e6f4065f860561d02aa89cd66f5f0cc0c05d5fe35f4848b50e1b5db3dffec0ffb1a +f5da5f9a5f0bbbce70177803971870907e021be8595f705831030fb14862c17e4c7becb89313f8 +0813641462acb17df1cb701e3804a22bae165bab6cf09efaa6b942075a5effe397be57e98decdf +4f740c1abca01610c3d3f084a0ef791dbe2902b1d39bbc991cb419764f4927944858c93bc2c0d3 +b084238dbd15037d2c05f1141175ef423b12ccde30b3bf812f7487614f9c8857a110e6493e6acd +fa9a76436e0988d4f0df0d8f3ba6761f5dcb5a80595fc1901ebaa1ceef91bf4d1ec4645ca4376c +8e5b847b9da3660aacd87723d0213f732c447f6ada2da9e8b8837d0c62d792e29c8c1d475a8b62 +b8e1d0849954020132cae3b67c454377438bd8c45594845d6df0eda9fb8bfe11bf4c151bdbc559 +f32f30774fb3905d4b6fc681f5e748cc8b712f97b490aa800597b34d9a729c7fe7804163833213 +994cf7d99ae73789ca43dd13761efffe710e92f5e836e8003841e0cf69c7e7773dd3bda280b8ad +759d6a7acab592ae4f433374d26f6cde3e819cc4934965c0382c721d12721dacf6e76e651cd040 +fa4e06381c45c478766ee5062837893f3f9173ad0ebc155e5f60fc4640750bffe5b359cbc97b98 +4f0249c17a272d07b1c69dbe9283b9511bd66fc49ca3ff8af6fc529b5497c10b43ce76ae7f4e6f +6068200b84f570f5a6c2b40f33a5aa9d72ee949ce7cd0801e5c97103bb931d80fb3a5179e4290d +33997c9e2096ce237440bbc4040a3981bea879b96028a450021112eaa19ee73c5f3282e475f5ae +f62a9f278f1453eca566edca7257d6962253c20aea0275622ddf15ee53652ca5cdd13e60d0de05 +cb5c6ce7c22148ea03c5a7c08041ab3c4bfd31f1a9fe57703967fdf64957b2becee25db6b038c3 +4c245f6522ebf6e609036029e91b7bbd5f088123ca7cee3a8adc80c33371ccc5b8fd4de68490dd +acbc8fa2daaf60cb9dc1c4f83bab1e7c50c1ce4180a8013d9ea8ee04abb0eed426f1624de6e003 +12a47e6d17172f33df24f2008d619db7febc97ad33795d161e0cbc61f2a8834150935eecebe9c1 +2a1c7a4266fa7b33c27497e3896ded5c485f04ead84466d740d9704e22cc9717546be26793f59d +3bd6673cff39b15d9df75e32e3f4b32cdfd7575ee3dc3706e31eb6c6af90570bab7161ead1a4e9 +36345364b5cc1743bedfcf759800a70445ff6dfabc7f254f932e2ef63e07c1f58396906323b9e0 +b5156ca9a9feb19b8a2ab2deafad9dce7e6745711e86c6c07add73928743b25c037d3a4541e3f9 +b1e0657b97eec8e38b8ec051b45b5b77bbca9ec1f2c79a01ef58ea3f502712bd7dafde8aca34ef +ac91b3e31e12a7e7225bf1e10a68098c3c8639d015fdb777900c853caa47c9817871e3a3436e02 +ae6e7db638a6de9197ef6e6755669047ab991d413d78a76c5c2e3f3e273477aa1d3bc7e1918b29 +18e356c6f2c15bb04356c75af00f35869b2225616d7aed0e7d57d1cb50d975ecf49e267dbb00a9 +477752a918baccc198fcf64f5526f7fad7f4268c1c0653237662d61ae3e48398d081e8bd889859 +25d71d6279d72c911c314ce2534c98ab180733f6d86b95ea258d6c11f9bdbf87a9330c8be9fcb5 +81057119fc94c8b09a07519e3009f1e5609c896b2ebb40d21456e9a8f3befe75b2d389f8ed51b1 +94284d8221a4f9ddff11b05b12656f1571c502a42381be799a5c013fb17fa8dc6d67e1aecdcb79 +8354802af50bbed0bbe3baaf4aacf1d1f6d67e3e37dcd20ec350c8f98d07a4bf9b70136546ab16 +7f185048d0e3961726f60cdb52cf9e175b459e707ff81dada6662bad9520683532512122bba84d +87b43018ba9148cb34574f41ae8feff876329eb217b81419890c7197ca57cfc3c1ffe417586b02 +ad689bd6d6a784205321aa308bee0fabd15869bb10d09875a6798c2a78e439a976f106fc6785c0 +e1cd34d6d07e493a612e6630451557b09f6ecbc65eceb89841c0a1181bba46ae974e9b7f733fbb +ae7eea822584dddacf66e7911c7a7ce25e52ab751c24881276a24faf95fb2f1785c472436f4ba9 +ac577f7ad71fccf5f1324dd8c6ae328f2377e12b5ed7ab77c3af347c71a7d27a2d2498d5072609 +28209fc5c37630ab7bc3c83a94246132aaea1b388afcd12d0f722a32430ad2afcc06c3c238fcf1 +0cdbb151c142524087748233ec1a7cde6d7c4ea6c709cddf9be9bfaff594c31c2c78f2b129c891 +d0c1779e0bab5c0268aded4d2622d3fc0257e45fd6aa393ad099eb7ffcaf40066b79c4b31a025e +d8adee74db1a6805bed8eadd8397695e13be0c01163c9ccabee68b7b05d615cd1bbcb29ba9f6a8 +6f1d32f97eb268d027d7b427a4059d2d02a0f9a0d4faad2fe126cfe595dde0541a5d947dbbc91c +572339743904994c502c840d0ebfe4bf891028d6425951bedb411c65734533b5b8e9d205ae01c0 +c12a39dab370ebf2aa7a3b762528f5bdbe76817aeac970c028e15484caf43c38358bdb212f6d11 +8946b908f1bb440c5ed14d29d027307d703331399ddf46c7a9abef729d70288234d490653e9451 +f25c548efbbfd39fed6c4f1d32b4f5eba3329b77e564e0f6883b5a25e365b0125142d997d6df3f +06dd7413b2c169a4cc15f684cf7dff4fe5610d9e71bed400ff6a7fec17df7e6c5225579f205bea +b1606e0a26f63c8763b2d517fa3a9b5b547de69c55ecbd06d0fa3964f040c2e8dc8da1a70ad1be +9645e9ff0b2932154b2b5de32fd2c8cdfad4f444c360aabc59100e4103c2cd4b6dd5cb9ef10560 +8435d066bf44c7f05f0457ff85856acca1aa8ef42b73f5afd35e1a0bc7c4d704f7419d8bfb92ea +6ecce0b321449647b3bfcb3bd7937805687bc1d5678a0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +cleartomark +%%EndResource +%%BeginResource: font f-8-1 +%!FontType1-1.1 f-8-1 1.0 +11 dict begin +/FontName /f-8-1 def +/PaintType 0 def +/FontType 1 def +/FontMatrix [0.001 0 0 0.001 0 0] readonly def +/FontBBox {0 -220 648 718 } readonly def +/Encoding 256 array +0 1 255 {1 index exch /.notdef put} for +dup 1 /g1 put +dup 2 /g2 put +dup 3 /g3 put +dup 4 /g4 put +dup 5 /g5 put +dup 6 /g6 put +dup 7 /g7 put +dup 8 /g8 put +dup 9 /g9 put +dup 10 /g10 put +dup 11 /g11 put +readonly def +currentdict end +currentfile eexec +f983ef0097ece636fb4a96c74d26ab84185f6dfa4a16a7a1c27bbe3f1156aea698df336d20b467 +b10e7f33846656653c5ac6962759d3056cbdb3190bac614b984bf5a132dc418192443014ba63de +800d392b6fea026574bb2535fd7bb5338f35bf15a88ea328fdaa49670c7852e3d060f3c5d6b07f +2ef6d0f22646c5d18e19a2ae3ee120390f6dd96f76dcf1e127de5e9299077a00c17c0d71e36e5b +9d5ec58fceda57739a6a4214d4b79d6c48d2784b60c320323c7acddddf34db833cac0cf109f799 +69d114a330d372e5c978a66acc84e3fe5557f6240856a013ffaa0199444e5c5036f775eba4a5c5 +8cde66cf604b9aca2178431127b8a1ff7ed633a65c04600af5f573483112251caca58a17e699cd +2766bc78db0b6f567873ef5f087c2938ba392f51a4f5b5f42e3902376029b8afe12fe2bb0c4b0a +bb3a2ce347fefd672ed783b52392e5e476204f34d807db584b01cefd77fefac9aab39662e6d18c +af367f24b75dc14ae565faace66da41d4e7fd3a566b1ed5da18709be155f0db9a104d2085cad2e +d78cf66ac29255807c7f3c26ba0de204c987518b08767105ea691b49f85c935542ef4427c273b2 +cba3188e2ee4e2c3f4be97ab95934ebe6bd7d6002747bb836b736394bc08e64f11050b692032ac +e9f1970df6dbea5bf0331895b210573111e72922bb8afe54288ee9cf30d7bc94743b65a44d5558 +3ddfe8149dfa3defa121f3afb19eff01f9038a5f943da17724abfff553ba1049c67adde394f913 +a14343913be1977a0496ee72f5911fafa690f16e09cd3845ab630b494c27472bd34bfed463ba93 +d2e39af7add1d29a4d1f46955f30a76c6b24a1b446b8246f79e96094f78df15b45990398924318 +8a9c47ba6ff19ddfcd97c506c361c0785ba517000b9b63716256ae650e39b43503235802251a79 +285350d759f039745f6870fa0262d25506adc99599f188fd2cb5be982c82f759f6353b263f70ec +8274f6c4446050f7ba20ad137d5743c85ee570d20945115ae87d94297e3980cc2ff675a1d3bb4c +e87396b3ff181058a15087688320057719da702fee41db8e1fe4c9ef19148ad38ee0e2c928d799 +d54721a0b321821924f6ab4ee9ef216ebebbe059de08bc056f739e35cd6b67ebd36ee0ccb64988 +59bd27483dc561d1267b6a5ade0a75ca4badd760b68951453be6a5934b07997e2a71e7b429e71c +cc5d82a38fffd724fff87eaf9946d1a91feec458ae57469bfd607b8719d7f5d8335d7b19a50d0b +14d0392f51a23fd976192429283e984e3cd003a8f93b3afce9b1df975cef31d039cdde71354b04 +2f672dba01b98501479472d49c639d8bd6b1ef05f457f42ecd0716d78ca2bde6bb5075289425b6 +9fa5d224a753246c4ef8483eeaf348c6460de1c54a26c32a540e57228a95440a1a179f2429d4a4 +450ed6cfe4ff47f02cd410e0959d3cad670dcd5682532a61ca243915b710ecaf5f8a61f72efa3e +013a056c088d892eace9f0906c39e12db890b08364d4cd6e962b426f56032cadb0adda4e4bf9f9 +5a9804fdf321c9686fcd8a39e1055c48bfd6e0415c0ab45640cb398b5101d07e0aaf0f2f339b5a +24569b5b1fdb5ad8c34920391a27fa85ef7f34722cee5d7e98dcd5b3bf66124c0323939d79df80 +6947cec272900e737cf361e7be13223c769d6830e0daf87d09c39fff3ad94ae5df0699ff2097ae +e837b7f041cbbdc5d23404929c22059981e5928ab5f0bb4d7d277b09687e93d3d7e776e90c1992 +6986477472a662465a16ec2d858ab6a708715059af6d5bb8ffc30de84faa37ff69f41390a254ef +71a356ff251d630dc7f3dfe5a309c0d198f999008d6e31333eef14012dfc5e16867ffdfe071fb0 +4f516bb454c9d076fd11c16185093001df5f96f5d83e5c5ae9a2836f29cee127607a926d9f1ee8 +5676f5f2520e9dd4705cb0c6807f2663e6325983b7440a39490fed3aeaa794890f69c4dea63d5a +9d6a8626188a5c9b39f528ee0b3994c916a2dfbc6beb36e17f46b1ef47a216084a5d8ee3f4649f +0a653889136bf2d31eb8593b9bce964a76c8dba09cfe90dccd1f64ffe1b42be4dceac6020629af +5f07ee884ba160ad301ee38d9f4532040437c03ccf136c05dd3ea456eed92eb24100b5ea3e37fc +4fce8f949275237454a18cf7b0279601accfd6d5f627c28c6f37b253f81a42235a18adf0e24ee7 +6a453fd5e2b7782d5f74c7bb404c16d37f4f3c04f8fbdd35258380723b632a716db543a3c7a99c +e5cdda7b196a778820f678b5c4584a1e41da29a19394daf732fc22d410efcc3b2d141b7ae8e7fd +971f56bc82287cfdd54db740d3b093ffba804159ce15122f357fb11760093682440b8c035a96dc +3c8364cf40fb84af7844fe11ea6e80432949fc4f54c62a31341576b49ce7eca5da2b5df210c452 +3e406821b704383c63055eb87e8c82e68abb062487c8834eb31641ead4d56c6ccd5b99ef9ac29a +4457117c1ba98f35e8fc44a5d40000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000000000000000 +cleartomark +%%EndResource +%%EndSetup +%%Page: 1 1 +%%BeginPageSetup +%%PageOrientation: Portrait +%%PageMedia: Letter +%%PageBoundingBox: 52 149 478 736 +612 792 cairo_set_page_size +%%EndPageSetup +q 52 149 426 587 rectclip q +0 g +BT +7.98 0 0 7.98 52.44 729.539981 Tm +/f-0-0 1 Tf +[(Virt)-3(ual )-10(Memo)-3(ry Sy)-3(stem)-3( Arch)-3(itec)-3(ture)-3( ) +]TJ +/f-1-0 1 Tf +0 -72.3233 Td +(B4-30)Tj +/f-0-0 1 Tf +[()-7174(Cop)-3(yrigh)-3(t \251)-287(1996)-3(-19)-9(98, )-3(2000)-3(, 20) +-9(04, )-3(2005)-3( ARM L)-3(imit)-3(ed. A)-3(ll ri)-3(ghts)-3( res)-3(erv\ +e)-3(d.)]TJ +/f-1-0 1 Tf +[()-2832(A)5(R)-7(M DDI)-3( 010)-9(0I)]TJ +ET +52.199 167.879 0.242 -0.48 re f +52.441 167.879 425.457 -0.48 re f +BT +9.96 0 0 9.96 52.44 694.199981 Tm +/f-2-0 1 Tf +[(B)-4(4)-4(.7)-3(.6)-1317(C)-4(o)-4(ar)17(s)-4(e)-3( p)-4(a)8(g)-9(e)-5 +( t)-3(ab)11(l)-5(e )-4(d)3(e)-4(s)-4(crip)-5(t)-4(or)]TJ +9 0 0 9 94.98 675.839981 Tm +/f-3-0 1 Tf +[(If )-3(the )4(f)20(irst-)5(le)24(v)20(el descr)3(iptor is )-5(a )-3(co) +11(arse)3( )-4(page)3( )3(tabl)3(e )-3(desc)3(rip)8(tor)38(, the )3(f)20 +(i)-4(elds )-4(h)7(a)17(v)13(e)4( )-3(the )3(follo)26(wing )5(meanings:) +]TJ +/f-4-0 1 Tf +0 -2.1133 Td +[(Bits[1:0] )9( )]TJ +/f-3-0 1 Tf +[()-2137(Identi)3(fy )4(the type o)3(f )3(descri)3(pto)7(r )-4(\(0b)8(01 \ +)-12(mark)6(s )3(a )3(coarse )3(page table )5(descriptor\).)]TJ +/f-4-0 1 Tf +0 -2.1067 Td +[(Bits[4:2])6( )]TJ +/f-3-0 1 Tf +[()-2384(The )-3(m)3(e)-3(a)3(nin)3(g )6(of)5( )3(thes)-4(e)3( )-3(bi)5 +(ts )-3(is)5( )]TJ +7.2 0 0 7.2 255 637.859981 Tm +[(IM)5(PL)5(E)-6(M)6(ENTATI)3(O)3(N)]TJ +9 0 0 9 319.32 637.859981 Tm +( )Tj +7.2 0 0 7.2 321.54 637.859981 Tm +[(D)-3(E)3(F)22(I)8(N)-3(E)3(D)]TJ +9 0 0 9 352.14 637.859981 Tm +[(. )4(Fr)3(om VMSA)77(v6 )5(the)3(se bits)3( )-3(SBZ)3(.)]TJ +/f-4-0 1 Tf +-28.5733 -2.1133 Td +[(Bits[8:5])6( )]TJ +/f-3-0 1 Tf +[()-2384(The)3( )-3(doma)3(in f)18(i)5(eld)3( )-4(spe)3(cif)21(ies)3( ) +3(one)3( )3(of )5(the)3( )-4(16 )6(poss)3(ibl)-15(e )4(domains f)4(or )-3 +(all )-3(th)7(e )3(pages )4(controlled b)19(y )]TJ +6.2933 -1.22 Td +[(this descr)7(ipt)-3(o)7(r)53(.)]TJ +/f-4-0 1 Tf +-6.2933 -2.1133 Td +[(Bit[9)-3(])7( )]TJ +7.2 0 0 7.2 151.62 588.839981 Tm +/f-3-0 1 Tf +[(IMPL)3(EMENT)4(A)-3(TI)3(O)-3(N)]TJ +9 0 0 9 215.94 588.839981 Tm +( )Tj +7.2 0 0 7.2 218.22 588.839981 Tm +[(D)5(E)4(F)23(IN)4(E)-5(D)]TJ +9 0 0 9 248.76 588.839981 Tm +(.)Tj +/f-4-0 1 Tf +-17.0867 -2.1133 Td +[(Bits[31:10])6( )]TJ +/f-3-0 1 Tf +[()-1384(The )71(P)16(a)-3(g)7(e)-3( )70(T)85(a)-3(ble )77(Base )78(Addre\ +ss )72(is )77(a )77(pointer )79(to )70(a )65(co)3(ars)3(e )71(sec)3(ond) +3(-le)26(v)14(e)4(l )71(pag)3(e )72(table, )78(gi)26(ving )78(the )71(base\ + )]TJ +6.2933 -1.22 Td +[(address)3( )3(for )5(a )3(second-)3(le)31(v)13(el )-5(fetch to )-4(b) +7(e)-3( )4(perfor)8(med)-4(. )4(Coar)6(se )-3(second-le)23(v)14(e)4(l )3 +(page )3(tables )3(must )3(be )]TJ +0 -1.22 Td +[(aligned)6( )-3(on )3(a )3(1KB )3(boundary)59(.)]TJ +-6.2933 -2 Td +[(If)-3( )-3(a)4( )-3(c)4(oar)5(se page ta)5(bl)-3(e)4( )-3(descri)3(pto) +-4(r is )3(re)-3(t)5(urn)-3(ed fro)-3(m)4( )-3(t)5(he f)21(ir)-3(st)-3(-) +7(le)22(v)20(el)-4( )4(fetch)6(,)-3( )3(a se)5(co)-3(n)7(d-l)-3(e)24(v)20 +(el)3( )-3(fe)3(tch is ini)3(tiate)4(d )-4(t)5(o )]TJ +0 -1.2267 Td +[(retr)6(ie)24(v)20(e)-3( )44(a )43(second-)6(le)24(v)13(e)4(l )50(descri\ +ptor)40(, )50(as )43(sho)26(wn )46(in )50(Fig)6(ure)-249(B4)7(-5. )44(The\ + )50(sh)7(aded )45(area )44(of )51(the )44(descriptor)3( )50(repr)7(esent\ +s )51(the )]TJ +0 -1.22 Td +[(acces)3(s )-3(contr)3(ol )4(data)3( )3(f)20(ields.)]TJ +/f-2-0 1 Tf +11.0467 -29.0067 Td +[(Fi)3(gu)3(re)-276(B4)3(-5)3( Acc)-3(es)3(s)-4(in)3(g coa)4(r)15(se )3 +(pa)10(g)-9(e)3( )-7(tab)9(l)4(e)-4( )5(s)-4(ec)4(on)4(d-)4(l)3(e)15(v)-4 +(el)5( )4(de)4(scri)3(pt)4(or)17(s)]TJ +ET +1 g +95.578 494.82 381.062 -229.02 re f +377.094 430.504 m 377.051 288.477 l 372.777 288.477 l 381.32 284.203 l +389.863 288.477 l 385.594 288.477 l 385.594 431.254 l 377.094 430.504 l f +320.633 324.227 m 320.688 288.91 l 316.418 288.91 l 324.961 284.637 l 333.504 + 288.91 l 329.234 288.91 l 329.133 323.227 l 320.633 324.227 l f +238.039 334.859 181.434 -17.012 re f +0.137299 0.121597 0.125488 rg +0.471 w +0 J +0 j +[] 0.0 d +3.864 M 238.039 334.859 181.434 -17.012 re S +0.5 w +368.445 317.848 m 362.777 317.848 l 362.777 334.859 l 368.445 334.859 l + S +1 g +247.586 375.227 m 247.641 339.91 l 243.371 339.91 l 251.914 335.641 l 260.457 + 339.91 l 256.188 339.91 l 256.086 374.227 l 247.586 375.227 l f +247.734 480.285 m 247.641 390.961 l 243.371 390.961 l 251.914 386.687 l + 260.457 390.961 l 256.188 390.961 l 256.234 477.035 l 247.734 480.285 l + f +320.879 426.578 m 320.938 391.262 l 316.664 391.262 l 325.211 386.988 l + 333.754 391.262 l 329.48 391.262 l 329.383 425.578 l 320.879 426.578 l f +0.137299 0.121597 0.125488 rg +BT +8.0008 0 0 8.0014 141.6514 481.555781 Tm +/f-5-1 1 Tf +<01>Tj +/f-6-1 1 Tf +[<>48<01020304050206070803>]TJ +0 -1 Td +<060209050a>Tj +/f-5-1 1 Tf +<02>Tj +/f-6-1 1 Tf +<0902040a>Tj +14.8819 -4.8779 Td +<0b080c070d070a0c>Tj +0 -1 Td +<0e0701060f0205>Tj +0 -1 Td +<020c0c010a0404>Tj +-19.1339 -4.878 Td +<100c0c010a0404>Tj +/f-5-1 1 Tf +<02>Tj +/f-6-1 1 Tf +<080d>Tj +0 -1 Td +<0d07010406>Tj +/f-5-1 1 Tf +<03>Tj +/f-6-1 1 Tf +<050a0e0a05>Tj +/f-5-1 1 Tf +<02>Tj +/f-6-1 1 Tf +<0c0a0411010712060801>Tj +5.6694 -6.0866 Td +<1307010406>Tj +/f-5-1 1 Tf +<03>Tj +/f-6-1 1 Tf +<050a0e0a05>Tj +/f-5-1 1 Tf +<02>Tj +/f-6-1 1 Tf +[<0c0a0411010712060801>]TJ +6.0006 0 0 6.0011 198.3502 352.739181 Tm +<1307010406>Tj +/f-5-1 1 Tf +<03>Tj +/f-6-1 1 Tf +<050a0e0a05>Tj +/f-5-1 1 Tf +<02>Tj +/f-6-1 1 Tf +<0d0a0611>Tj +/f-5-1 1 Tf +<04>Tj +ET +1 g +192.68 385.891 181.434 -17.012 re f +0.137299 0.121597 0.125488 rg +0.471 w +192.68 385.891 181.434 -17.012 re S +BT +4.2197 0 0 4.6835 193.6724 489.880381 Tm +/f-7-1 1 Tf +<0102>Tj +/f-8-1 1 Tf +42.2531 0 Td +<01>Tj +/f-7-1 1 Tf +-17.9414 0 Td +<0201>Tj +/f-8-1 1 Tf +<0203>Tj +/f-7-1 1 Tf +[<>4665<0203>]TJ +/f-8-1 1 Tf +<0203>Tj +ET +1 g +294.738 385.891 68.703 -17.012 re f +0.137299 0.121597 0.125488 rg +0.465 w +294.738 385.891 68.703 -17.012 re S +1 g +215.359 380.223 36.801 -6.004 re f +0.137299 0.121597 0.125488 rg +BT +5.0005 0 0 5.0009 215.3597 376.220381 Tm +/f-8-1 1 Tf +<04>Tj +/f-7-1 1 Tf +[<>32<04050607>]TJ +/f-8-1 1 Tf +<05>Tj +/f-7-1 1 Tf +<050809>Tj +/f-8-1 1 Tf +<06>Tj +/f-7-1 1 Tf +<06>Tj +/f-8-1 1 Tf +<07>Tj +/f-7-1 1 Tf +<0a0507>Tj +/f-8-1 1 Tf +<08>Tj +ET +1 g +362.777 385.891 11.34 -17.012 re f +0.137299 0.121597 0.125488 rg +0.5 w +362.777 385.891 11.34 -17.012 re S +1 g +364.777 379.223 8.367 -6.004 re f +0.137299 0.121597 0.125488 rg +BT +5.0005 0 0 5.0009 364.7767 375.220181 Tm +/f-8-1 1 Tf +<01070701>Tj +ET +1 g +192.68 487.957 181.434 -17.012 re f +0.137299 0.121597 0.125488 rg +0.471 w +192.68 487.957 181.434 -17.012 re S +1 g +294.738 487.957 79.379 -17.012 re f +0.137299 0.121597 0.125488 rg +0.5 w +294.738 487.957 79.379 -17.012 re S +1 g +225.359 481.285 36.801 -6 re f +0.137299 0.121597 0.125488 rg +BT +5.0005 0 0 5.0009 225.3607 477.285681 Tm +/f-8-1 1 Tf +<04>Tj +/f-7-1 1 Tf +[<>32<04050607>]TJ +/f-8-1 1 Tf +<05>Tj +/f-7-1 1 Tf +[<050809>-1390<0a0507>]TJ +/f-8-1 1 Tf +<08>Tj +ET +391.133 334.859 m 408.473 334.859 l 408.473 317.848 l 391.133 317.848 l + S +1 g +410.137 328.187 8.363 -6 re f +0.137299 0.121597 0.125488 rg +BT +5.0005 0 0 5.0009 410.1348 324.187481 Tm +/f-8-1 1 Tf +<010707>Tj +/f-7-1 1 Tf +<02>Tj +ET +1 g +270.211 328.687 55.312 -6 re f +0.137299 0.121597 0.125488 rg +BT +5.0005 0 0 5.0009 270.2111 324.687581 Tm +/f-7-1 1 Tf +<0b05>Tj +/f-8-1 1 Tf +<090807>Tj +/f-7-1 1 Tf +<08050a>Tj +/f-8-1 1 Tf +<050807>Tj +/f-7-1 1 Tf +<0a0507>Tj +/f-8-1 1 Tf +<0807>Tj +/f-7-1 1 Tf +<050c0c04>Tj +/f-8-1 1 Tf +<08>Tj +/f-7-1 1 Tf +<0707>Tj +ET +1 g +238.039 283.824 181.434 -17.008 re f +0.137299 0.121597 0.125488 rg +0.471 w +238.039 283.824 181.434 -17.008 re S +1 g +270.355 277.137 55.312 -6 re f +0.137299 0.121597 0.125488 rg +BT +5.0005 0 0 5.0009 270.3561 273.135081 Tm +/f-7-1 1 Tf +<0b05>Tj +/f-8-1 1 Tf +<090807>Tj +/f-7-1 1 Tf +<08050a>Tj +/f-8-1 1 Tf +<050807>Tj +/f-7-1 1 Tf +<0a0507>Tj +/f-8-1 1 Tf +<0807>Tj +/f-7-1 1 Tf +<050c0c04>Tj +/f-8-1 1 Tf +<08>Tj +/f-7-1 1 Tf +<0707>Tj +ET +1 g +408.137 283.824 11.34 -17.008 re f +0.137299 0.121597 0.125488 rg +0.5 w +408.137 283.824 11.34 -17.008 re S +1 g +362.777 283.824 m 408.141 283.82 l 408.141 266.82 l 362.777 266.816 l h +362.777 283.824 m f +0.137299 0.121597 0.125488 rg +362.777 283.824 m 408.141 283.82 l 408.141 266.82 l 362.777 266.816 l h +362.777 283.824 m S +1 g +410.137 277.156 8.363 -6.004 re f +0.137299 0.121597 0.125488 rg +BT +5.0005 0 0 5.0009 410.1355 273.154681 Tm +/f-8-1 1 Tf +<01070701>Tj +/f-7-1 1 Tf +-7.6539 0.5721 Td +<0d>Tj +/f-8-1 1 Tf +<08>Tj +/f-7-1 1 Tf +<0e>Tj +/f-8-1 1 Tf +<06>Tj +/f-7-1 1 Tf +<060c>Tj +/f-8-1 1 Tf +<020508>Tj +/f-7-1 1 Tf +<0f>Tj +/f-8-1 1 Tf +<0805>Tj +/f-7-1 1 Tf +0.4717 -1 Td +<08050a>Tj +/f-8-1 1 Tf +<050807>Tj +/f-7-1 1 Tf +<09060c>Tj +/f-8-1 1 Tf +<080a>Tj +4.2197 0 0 4.6835 192.911 387.916081 Tm +/f-7-1 1 Tf +<0102>Tj +/f-8-1 1 Tf +42.253 0 Td +<01>Tj +/f-7-1 1 Tf +-17.9414 0 Td +<0201>Tj +/f-8-1 1 Tf +<0203>Tj +/f-7-1 1 Tf +[<>4665<0203>]TJ +/f-8-1 1 Tf +<0203>Tj +/f-7-1 1 Tf +16.4186 0 Td +[<02>2161<10>]TJ +ET +1 g +294.738 436.926 68.039 -17.012 re f +0.137299 0.121597 0.125488 rg +294.738 436.926 68.039 -17.012 re S +1 g +362.777 436.926 45.359 -17.012 re f +0.137299 0.121597 0.125488 rg +362.777 436.926 45.359 -17.012 re S +1 g +408.137 436.926 68.035 -17.012 re f +0.137299 0.121597 0.125488 rg +408.137 436.926 68.035 -17.012 re S +BT +5.0005 0 0 5.0009 317.6891 428.922881 Tm +/f-8-1 1 Tf +<0b>Tj +/f-7-1 1 Tf +<09040708>Tj +/f-8-1 1 Tf +<020508>Tj +/f-7-1 1 Tf +<0f>Tj +/f-8-1 1 Tf +<0805>Tj +/f-7-1 1 Tf +-0.2496 -1 Td +<08050a>Tj +/f-8-1 1 Tf +<050807>Tj +/f-7-1 1 Tf +<09060c>Tj +/f-8-1 1 Tf +<080a>Tj +/f-7-1 1 Tf +10.8061 1 Td +[<0d>-1612<060c>]TJ +/f-8-1 1 Tf +<020508>Tj +/f-7-1 1 Tf +<0f>Tj +/f-8-1 1 Tf +<0805>Tj +/f-7-1 1 Tf +2.9177 -1 Td +<09060c>Tj +/f-8-1 1 Tf +<080a>Tj +4.2197 0 0 4.6835 294.7379 438.847681 Tm +/f-7-1 1 Tf +<0102>Tj +/f-8-1 1 Tf +<0203>Tj +/f-7-1 1 Tf +14.8845 0 Td +<10>Tj +/f-8-1 1 Tf +<01>Tj +/f-7-1 1 Tf +[<>-467<0211>]TJ +/f-8-1 1 Tf +27.3685 0 Td +<01>Tj +/f-7-1 1 Tf +-16.7022 0 Td +[<0210>-256<02>64<02>]TJ +8.0008 0 0 8.0014 141.6514 277.424781 Tm +/f-6-1 1 Tf +<100c0c010a0404>Tj +/f-5-1 1 Tf +<02>Tj +/f-6-1 1 Tf +<080d>Tj +0 -1 Td +<040a1108030c>Tj +/f-5-1 1 Tf +<03>Tj +/f-6-1 1 Tf +<050a0e0a05>Tj +/f-5-1 1 Tf +[<02>]TJ +/f-6-1 1 Tf +[<0c0a0411010712060801>]TJ +4.2197 0 0 4.6835 238.0392 336.782181 Tm +/f-7-1 1 Tf +<0102>Tj +29.7628 0 Td +<11>Tj +/f-8-1 1 Tf +12.7272 0 Td +<01>Tj +/f-7-1 1 Tf +[<>2079<02>2161<10>]TJ +-42.49 -10.8963 Td +<0102>Tj +29.7628 0 Td +<11>Tj +/f-8-1 1 Tf +12.7272 0 Td +<01>Tj +/f-7-1 1 Tf +[<>2079<02>2161<10>]TJ +-14.4011 10.9096 Td +<02>Tj +/f-8-1 1 Tf +<01>Tj +/f-7-1 1 Tf +0.048 -10.918 Td +<02>Tj +/f-8-1 1 Tf +<01>Tj +ET +1 g +362.887 334.812 45.254 -16.754 re f +0.137299 0.121597 0.125488 rg +0.25 w +362.887 334.812 45.254 -16.754 re S +Q q +294 488 81 -7 re W n +q +294 488 81 -7 re W n +% Fallback Image: x=294 y=304 w=81 h=7 res=300ppi size=30420 +[ 0.24 0 0 0.24 294 480.799983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 338 def + /Height 30 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 30 ] def +end +image +Gb"0MYt[Oc!(G:4,l'N0fK`7LJ2i:<"C_HIfFTD/rb+Y9JU:-up%ga4bm#s3m,ra;s-sS>Bl + >ZJl$QjODEkn[m(p,t5MoNAmsDO9cKjRI!Y=I(]hpqgW#f\Q%lLAB)V%37lCg]?:nr?8;*E + F-*bnXb26)EMeO,>]Tgn]OUO&k94k-DOC/b^$WeVMC6]LB)7eKTQHDj\(e>OF'<"Cj1ec,] + 817im~> +Q +Q q +243 481 18 -11 re W n +q +243 481 18 -11 re W n +% Fallback Image: x=243 y=311 w=18 h=11 res=300ppi size=10350 +[ 0.24 0 0 0.24 243 469.959983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 46 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 46 ] def +end +image +Gb"/)LJO1:'`V+S?31iE"Y)l9;3i5Q+J=^Gq?6HtXW=Z;'e!XXW._$:2ON-m1)/E:ej`KhQ* + LJ6hQo37c*#]a\md?\BG@k']]LRS>5phe(5CIs.91qqDlHII + ;#JZb2-6tQ23P"^G9W"bs]Y$?j2V-C-eFhtK_SX0Y90m30E"Lm?WSOA^GO[1DHZ%^^PPi)6 + 9TI*j,n^Y%K + esl9b-O#<5YdgnS)\Z^rAB]/@q>0dVoIpF[^Dc_JJt6LHMMgL&1"b@67O + t#$nk)MJr$a\\`5i5%i+q54_D*EN%/"abbt[rh#RQ'6XgL#3NqPuq+fn0Fc-F6K;'`9G@jjM[k(gNPd8gbCp!AN`+:.pn8 + n.uTH2_(!2g88p82,pMR3k(Y&)JaKnXX,FF\f@-XVTX!I2"9&1o0K_HkLXu+_e]%`//?PeI + Vb&X)3XSZ5OIYKsIfT?>1,IT20:oq/`7!FmL:Bi-20J[&Y)-G_Mk^r-MMm?G%$XB3p[[f!^ + 'm>[a>S.crI+W2*?7%ldYjG/_2.T"Tn9V',D66rq&9u@:JDQ2UOJ/T0]9eOq5SpVAn4S/9S + `u>lfuk/Oc(@gG'%g[*?9MqIDa.IaP>S+/o@.:o9bU^%MO7MO%>&ef)%$:_5uN9#SkEb*p2 + U&9X(\.<[`VO6Khfq:IFmc!XaLBR[b"61R-m]&HmJVGS*Hqm_jd3^De,[Rl*)\?j]t?=AVg + n=@c/K+?Tf*:L0!;[TEFu-00f,],3i8UNfD#&ql#GKnqer%iqlC^V6l-l)4^-*f).&Ru$"P + e.b"MZ-UqX^c2eaGpGO"A5/1/r']cB%!`@*O\nT0SW>N/@2-Sb^:n*PA#'Z\=c1+mUAVUo[ + >5q+\(9Em%Y$\1l:OH`Rrrjrk\.#4FEVcc6Y_J].0bpZO>hi._I4S]5;,ls+O4,0=^4R5E= + "\9R`3672Z(.e8k?1pVWLoq/EIP"TB"r\Yon6&fti4?O_IZ.--&:MB*u^`aI*TK)bLb@guf + r@)Is%%5R:%o-VF/M(1)at/L4G%;MsFA>4[C-tk(d`7 + 'i$*h'8]aq:0I5u,&4FDtiOA^Y1Xa__gDsPh8Z>\'>%e?:oIr\E`l6ouO/tb_\.djB(BhLL + k^tI_3:OV&laECN[[+LN9m&lYM@Rl\6SL)<' + r@Fd7E56(qK8TX;CF1K1G^as7R(m4_36,-aqYh(oCCF%M#1hf_DHj;(HO.tO +Q +Q q +294 481 81 -11 re W n +q +294 481 81 -11 re W n +% Fallback Image: x=294 y=311 w=81 h=11 res=300ppi size=46644 +[ 0.24 0 0 0.24 294 469.959983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 338 def + /Height 46 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 46 ] def +end +image +Gb"0VqbL.'(^KOpAO<*=Na"*qk$U/YMh&C\7E3/+g5TT..*2":jLse-Vk/!hl!h/YMXDIH;7RK??,+,\a6 + .E(GB#q"p")PAn=oVX3[?#%O1QG*(/ul7"`tkL^'jAao#N;&,Q/bDRK4\G7XX1A7)_@qAmD + 1#c[!>eS;5]ltimm8IO^_fVn!a?e6h\/NMS.5<.3rN>;RjjN-t\\F(-5Pjl&Z]fiMD&Kj#u3]/>7[u")NXe^>N\=[* + qNjA;OF$U + \s/4.;GHZ&`j=+h?b-qjCH/brM%R,HnF5V@[/$2mg(;I%*I;(I)4ES/-^$`m7)NW[NG5(Xk + CY*MdcOH\A"*BG!DV7*&Q'D4mXd5!j'P*ud\>kahrmg5"j6s\-WiW"<:JrqW-LTD(453m&f;qg1bFbCk0>5TM9MS@&6q + 1%kTq#B"*B*uf!3,,i*VUX?HS'?+!/WIbo`4n2h2s6).!q/MA3As&bT)-Hr[$6e[2WE]M]_3Fcd?GhO^9Fj"*+[q + ?L+&>%%h3C&RtgTke8KMBZ^KW61G^iI3m0//#6u^17s>KC+!)J8+8&-Y8(^@*F#+d"]Q7^+ + 2ZP`U;SUo4)8.LFPh,0PXtJ>Zm^m[W8fb'DGM@F7I@"89;d3f69?]ln0JVV,,:31[Jojr]fD^uI'?7\c*;:/e".`Un+aC2/*;2!]8^ILe=uUn.[<5't<;XG + ]oSkY/XoTqSljjjFq];\F;X*9b;W7n90.WQS18D7&`4Eo+r2dVA"X:ZFMM&nYcWp)>AC36j + _BCL5o/04iIuV>p?-T5HL`G=Xk=9I:FTRTq2'?Ao9ao.MODH9*tHCg6MR*UNtbdke_;\RMg + G=;sEHh$#uTd>l19gC!rs;U6#_fmL!d?CO]6]=l*i0`4'un*>0#0-[255Vu"pJ7t$j!7;q^ + !2;dE!CVRi",I/\#7q>B%j2dd*^DPQ4b.4-H2u>8o`1^Pl2a;*e,tL2W`/=dAiHU*?TXEUblQ&/TgM3u`l?EE;A/E,"V;p$X'!:aeNMRJJPLSuTN5Y- + Oc'KgKcaK*-b?3Pb[q!.^(%%rs"*Wr~> +Q +Q q +243 470 18 -33 re W n +q +243 470 18 -33 re W n +% Fallback Image: x=243 y=322 w=18 h=33 res=300ppi size=31050 +[ 0.24 0 0 0.24 243 436.879983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 138 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 138 ] def +end +image +Gb"0O=)Pl?(e*D[,RWA[.6F8Vl'RJcVA[jgB(?Mp*RJ?:A"B[,JGH!JRbR5OI:'.6QWH2Dh\ + +7!oD)\<(OuJd.Kj'QkBI*T`tL_OJ`.1`5_'2mV_A7P2t.q#Qq8P($K!Qt!7Vo("p$ukJVX + 1F+M^(^WW378*C-`Xqs>/lf"g)GTK$=7"VBUegTEL*#&a>r5_)]9Y#deP@DGh\TQm-=!XK@ + 16D3dm!6"sRr.Ft]T\dJL]8S\qF'X:rmjt@<\6LR1!YtWc!-JOXo/T(TQ$8r&s'rCW'Hk1^"32(*U<9M::.JfE=p$.i&O:jH< +Q +Q q +243 437 18 -5 re W n +q +243 437 18 -5 re W n +% Fallback Image: x=243 y=355 w=18 h=5 res=300ppi size=4725 +[ 0.24 0 0 0.24 243 431.959983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 21 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 21 ] def +end +image +Gb"0O_$to;%#*Y7eAS\DDBht]h1#[B3'j<.b^9-jk]^dDb+0aJ38(Yk:4&je^BYh(!!;q,TT + fN9;[!.%;ud4i!!0`Jng6>[*ROTd^m'h/"+[SV!8'@e-31X^dN6Y`S(@`q;?MnA~> +Q +Q q +408 437 69 -5 re W n +q +408 437 69 -5 re W n +% Fallback Image: x=408 y=355 w=69 h=5 res=300ppi size=18144 +[ 0.24 0 0 0.24 408 431.959983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 288 def + /Height 21 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 21 ] def +end +image +Gb"0M_$PWG!!L,9'N/&Ord.K2OU>=rR:?T6c]2ia^oPb+>gGT`!ro#Kki`C8qLXaATVF1(kR + 0HJJr[R +Q +Q q +243 432 18 -5 re W n +q +243 432 18 -5 re W n +% Fallback Image: x=243 y=360 w=18 h=5 res=300ppi size=4725 +[ 0.24 0 0 0.24 243 426.959983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 21 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 21 ] def +end +image +Gb"0IaUNbS$q/K@5b\7b[6e=MoGQp#KnKN;+Xm@3C8WB~> +Q +Q q +372 432 18 -5 re W n +q +372 432 18 -5 re W n +% Fallback Image: x=372 y=360 w=18 h=5 res=300ppi size=4725 +[ 0.24 0 0 0.24 372 426.959983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 21 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 21 ] def +end +image +Gb"/fq+k!\'Z^6=rCuIfRL\ZnrMBH@#F%pXA!UhRU2-7D4\qIbi])dIZ^mAk'*d@!oV + ^]jkGX@!6]ogQHLWL>PGW1A0S@?rpEr7\a*@_ + HmPGf[5B5n'ChC/akkuG:6*aMXb@^@-ouT+T6_9qtp8U: + .k!2hs0JR4IDP(r02L^roC$n&6-c0(G@[.^CSQ+I;?uLabfQX:3Q=>:E2SO!-P]WVT'rbJc + gXm1c@Ba&@m;bScEjqH"(DtNTH7o++`rL8rBa9'uTfFE<<@Wf5?>?7`K[:SX9\uc,Bk0:64 + d_'8d,(L"hEf,8W#/IXX*lh:uOnNWaQNGf6.4M:1#-Vo$Bl`.7CLp6h;8&=2L3K<10:##)6 + e*'hr?Zgs='QS)_*>f>"d^]B2.J6Zr0:QM?O)9.GsQ'.fJ\HSQ.@!Hou":VQOOFVG[[:=IG + k?m:$=45O9C$J#]7MjCbO7q'cIOkJ_PEQs:)dt!FPTR3Q_DAS*`GhC)kiesm4#T!?E5*d`" + atDl\0Z?`*kk3<_AEr/<"^JCQ%7[PG%*!T.RL>BX$^MGEg%;AcY.,G/9N5jf[*/e"9fc#dP + ntYku:_a!GH@c''h2"0"tOf,+l3>cX?eF8GKUZC_S'cgD#;V!+uPW7I;]H2bAV1DVS1m]FQ + "#GWS,3>o^\h/ab)9!PX#G+H';b6dMCN0:%6T\G[N<`TZFJacOGB*j4d:@3cj#"[O(nYldC + Jb$J:N,EbS1A.RSSHpKILqK6o+^&(c(#QRFm[5JBkU'0Z:ZpIY3]qM,#ID)5$pKua(U3[*[ + ?SaG;m+VH42M-X,$34m_E`Uj$DVr9*q2tje$uH-dDJXCKU2gk])(>lT7*9.WC.]G]o!1$02 + O7D-Y?nmT)^8$^$6bsc21r%+rS^+`&2Q*unh";.]%Mc_OuZ&6Ui%SD:mA1SL.CGoE-,UnS[ + .kXj\$nS1:u="609nrWX;"g'.k&>k1i5bFAs-BI/[>$p^okC0LP-?"OL8MR2B + XT\e%8W]t>5G&J@?od(Pt1&> +Q +Q q +408 432 69 -5 re W n +q +408 432 69 -5 re W n +% Fallback Image: x=408 y=360 w=69 h=5 res=300ppi size=18144 +[ 0.24 0 0 0.24 408 426.959983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 288 def + /Height 21 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 21 ] def +end +image +Gb"0M_$PWG!!L,9'N/&Ord.K2OU>=rR:?T6c]2ia^oPb+>gGT`!ro#Kki`C8qLXaATVF1(kR + 0HJJr[R +Q +Q q +243 427 18 -8 re W n +q +243 427 18 -8 re W n +% Fallback Image: x=243 y=365 w=18 h=8 res=300ppi size=7650 +[ 0.24 0 0 0.24 243 418.839983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 34 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 34 ] def +end +image +Gb"0IM%.nn!# + ktu+-Zku#C'oiX9cHJ,J`k8lMqtE(lZuSoDepk%NMAN5Z@K6Jr) +Q +Q q +316 427 18 -8 re W n +q +316 427 18 -8 re W n +% Fallback Image: x=316 y=365 w=18 h=8 res=300ppi size=7650 +[ 0.24 0 0 0.24 316 418.839983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 34 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 34 ] def +end +image +Gb"/'pJ4aS&H5TZFMs1HW,t0*!BoZQ)EVX)">sqQU&lO3M5#hY.a:AX>6#TJRYZq*,LK%M.F + MGikf*!1Ze;trO7OJ>RQ&nAG33CLkF8%5E[)fY..-G.K5&ee!Wkl6VKir`ETH_hcOr;<5/, + Ccb/i)gXFQb.RVHSP1d9Fgli:-5THWs]C77HnDmfNXor(fGjcH]1$]">QXa%$aZh+F>"J+Hk"#Agpgb%JgZ,O'42?%/0 + 2,K+\00$_FETZ%kt3GTn?kCj`mjSK/tn$5[k16:'!gA.m1YB6M3B\pNTm88b9$1YPelG0U6416<]eG]Yq`mCGSt7#"[@t=kErLI!7;ZnDmJn'IR>Z^iCNFPQ + j[7#-O'i1t#Ot8kY?\XiYTj@.r(KgVl0.=B!44F9k5cnW-Lu?>:<,]2.l:5`?>jcN//(s%; + o1%MGU>%LGC[an?GYIJ%Dod5>jP,@^W.B3Yo$(5*;Nm?Lb1A?n]&hPPEAh*!eBRa;Z6rb)+ + %DY6K$^UnoAQ*B,]jojZUc4B+#"VH0FrB\c^/MceoQ9]R:p8Q]n2X4[XSn8ge8V*AP>bFkQ + %[Y,oO6I#qWCJ7s\M*E4YEW,[B8kR>\"GenIW!?sp@"Th4C][eRQ"k_D[7fJ21;8%>RQGsJ + ^qmZVTL>0.Q&\+`>X/S`nIBA)A_%ITI#)IIF$Qr^)^7_7M\,aoj_4k)+CmiT7OqKK74:Q36 + REV!(Et=7d*ilQ>J_*D`,i)-F/h3G,J/HtlU[;GA$ga[eV,<-q(,ZKN_:FXShk?_e1gVoPN + BtBSVkp3n?'-d6hS$%\2@3Oi=om%X_Mkko8HB)(nFZm1iI$6m%UqsLpgQPkgdCt0D/KgiVA + gR/4"C]H9G1#:;upeE1:SV^*RN_e=\hj'gpIbKJ + &QND1NUId@mU!E6o!"CYs4$_BMVR6k\kLI^Hm0B%9P&drUa+;,*HQ\9%80T1cAWdBCrl/Ba + #,$$cm6JC2Ka$Q[/5g[[j0:_DM%(Ir.7^rg^FE$/6h'%JK,K3)?kQ<(r2WCL=VRi5rN'tOL + ]R#8\.IAT0F>3K?4MaK'I6@iI&57r/Q:WEkA +Q +Q q +372 427 18 -8 re W n +q +372 427 18 -8 re W n +% Fallback Image: x=372 y=365 w=18 h=8 res=300ppi size=7650 +[ 0.24 0 0 0.24 372 418.839983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 34 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 34 ] def +end +image +Gb"/(q,>O8'`V)_mE$D!e8$5%,,@XEV%ggGQl&2hUuDV6@iMeC6+`skP[[+j?5X3I;-HHd13 + r8FcZ@?d.V*3q7Q-(DCs/iFJi[@mj8%Y7CSUW:=@fG4J\H"lO2^ + d+)dZXEn/DY*O:DJnT44Y8-ijljWb>iEA11R)aXQQ-Kr."5%s@;/:>c + S@q/Td^_T+M'43QkrinHii<@dKE6JDKY^:B;.0,2_bSQ:$865sOYQ$/6b!_&eMne-8aRi47 + \b/A/j9dnrsY&egfU*$ADI\qW?cU-[2hmAQrHrk81O\W`W1,]@#(JRkUZSH)Kpd_;ogO!L9 + eSVStQ'Q_+(E4Hsi^Q7j!^]6r0^43Uu\.ET+eC:9Y^d[kWiugqIgY4/!C-I(L4$#E[B**GI + b#R6tOe:lPBg"UB!^J7D9*&F8E\_P_iESKuqng2QpBCj-kEq[<2^Q*Ed9tka3k"IV^UH1Y/AL2g5q$`sdX/k18L[&X@9kPC[() + /k[/7],K%s_9u*rQ+OB4gZp5$PZCI#s\m\ii]/qeBa[_2^Rl.Rhna[;N(`TQZE#)?HQMnto + 6r&5nMZm\)EjC[);!lOOOM;V*(B"D%*n0AQW?3kNK/n,r6*Dr8t[6=\UP+N6#o-qJ;QThnR + \Y5;B-;o00+kQZief*2fCWa=&o=Z8UQ=g7*hW*-"h\tVM95WfKo$H^N7KQdrdL`WV)V1mMk + WheEF/h\`I(4_e+fV@hA0(V,l)&^r]Ldf.3FgQ@#]m":/$mS=g^mtM\R9E*N#J)*09YnEu] + 64K4!j)Ie"CY>#k-P*kq/,d*Hg+uPYCcgQqn8Ma"Q.RQk?;%UK$f=.bK\-p+d3$R"slNUJ^ + $L)hg9S9VPU/a\lFS=QYU]H[^MJ?.AgrgDJiWM$9=&'aF?EJ&R]`][ABjj0F.,"6,4B3P%W + *ST[;EViDKL69>nZ!`55LY&.+*596)l2;^Y@M,%u(Z0RA"h1:%82%8O# + 4O"9du;?~> +Q +Q q +408 427 69 -8 re W n +q +408 427 69 -8 re W n +% Fallback Image: x=408 y=365 w=69 h=8 res=300ppi size=29376 +[ 0.24 0 0 0.24 408 418.839983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 288 def + /Height 34 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 34 ] def +end +image +Gb"0M_$L0/!!L,7'J;)YnFrM)m.1?%7W=>82,jSIl0WNIJ5\UKpZ&rj5Crj00BhU-3r4Gg^7 + _5Ski`C8qLXaATVF1(kR0HJJr[R +Q +Q q +243 419 18 -33 re W n +q +243 419 18 -33 re W n +% Fallback Image: x=243 y=373 w=18 h=33 res=300ppi size=31050 +[ 0.24 0 0 0.24 243 385.879983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 138 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 138 ] def +end +image +Gb"0Pb>-eW'F*JcJV<#./kAODp_mL[^JR7%YilG!7D&um)Z_H=_BM9tFc=WsZHi%hue/MQ2bau0*N&U6q9OOX;*QW[7$%Sq;.=_C"8-k`F-dm + MlIiuROO?IPD)?U6fJ>BsmJ>-d9>6"_l)E8`-##5.$:iYDY*medBnpt9N$P"0L#64f2+f[3Q2r+Y!"o@8Ad^k$m/RE"qO!6hJ,lSYD"%WI14ani)qYn:+I;?)m'[q&)(d+b!q;%rqri-;_1WlApuRW + k$b5?JO[M@:QreoV<,j!LDGp^VOFl:1,IIY`KQ0^/6Y19A/:LIcQAQ;B^n4?hbQc&j-m-9& + !!Ztn)kM%St;m9&tau*HZR)f7[TflGJ*e_6YV?i~> +Q +Q q +316 419 18 -33 re W n +q +316 419 18 -33 re W n +% Fallback Image: x=316 y=373 w=18 h=33 res=300ppi size=31050 +[ 0.24 0 0 0.24 316 385.879983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 138 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 138 ] def +end +image +Gb"0Va&5i5!!_@?&OLA.6Kg;65T4f)$:sX!f?b0t8)8eMe\1Bn+`?oQj9]3[mknbq7OAel:e + q#-4`gVu+5hPWAZ"9dsI,A)k9kB5R/?tqs51/Gh6iR"7t.Mk.lN#2TC + :XWsoT`ccP96;RK`1'S*`>0VC#@Jd3%kJ_&$r$Ga=;C]b'-5]\:,5`=.^sXtLn4op=#-bD7*4DLh+d$VLEdRp0=B/\DJY\_K(Jb'6! + >8`&$/,N8-N+$_`"a5VA + 9ApNJqrpJcUil4U2TqCND;d^c!;hS-H42\HN4;FWZapK3BdFnd,)E9DVl"k- + j!VMW"3)Ghf!8BSC5TL(6+^H+Z0VBVIG[P`.(D',G5q#R&Y[C6C#84)=(%=J$G;fa>C'YP^ + Dg)_.5q,Kc#PRgMEBm58"eZM6'PRREH[@c7[.(p<)RiXL@$1&F(Zq[(nP;#P + 4HDic6V(0,(#_12V258,kVRkg[]K9IVEeYp*k5cPPj2u[egFh4ph>~> +Q +Q q +372 419 18 -33 re W n +q +372 419 18 -33 re W n +% Fallback Image: x=372 y=373 w=18 h=33 res=300ppi size=31050 +[ 0.24 0 0 0.24 372 385.879983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 138 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 138 ] def +end +image +Gb"0Pbt8%7(rl)=aV[r+5H7F=IZ8af'K+C;#RVd`Z)!qtYO4Y,Uar[7mBUUPf6.2'G2^;G8@ + /IcbPG]l#poTfeBc>fDhB5l']6.!ZXj@+p$'<^a4L2!,!rR<8;1<,-ojjT3n@E7X4&ghO@3aEBTb@DJpKcEaN`ZamKKW + CgKg/&Hh/X]BA=^/\0)2KR^s0Jr(1T;W9>cKAO?"T-o13!ZCfZYc]`_8+RZO_g\*O:=>)gQ + r@S?X4 +Q +Q q +294 386 70 -10 re W n +q +294 386 70 -10 re W n +% Fallback Image: x=294 y=406 w=70 h=10 res=300ppi size=36792 +[ 0.24 0 0 0.24 294 375.919983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 292 def + /Height 42 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 42 ] def +end +image +Gb"/ks&TYD*68)D/[t3+Cl-ZAHn-b1PYtqVYh#tb/;m4QI9D=rh,M*'Sa6kTZ0PURZEiY0*@ + *-SSVlJD.\T\/mR7^EOL'VZ.J + 6Em:^:ulK#m;$Q%!EgpOkF2Q*?YHVa(t5)*LqJGa.;(qO$>mHbb/W!g.Zs8IF<41iKdlGB\ + YN&InU%&49u)T-4j]>cPY^ofDN2R$s*UCHQ._e9.a`\?,^XtbknY\OZB%IBNe*%EFY['`g\ + J"AlcYh@FOfLG@74W&$^Go&MiO'pShU?Gu.rl8iVXN(PK%Tk>i\:Ce$e&)cP@'_r3@/eZpF + ad#C6B($>R)/gNl$EQFVAA52/5QhgHhVDF6USoS%^S5HfY8LKc&@TZLgeol6.e'&0[[;[n_ + h69CY,^PJ,Yt<]tM,(c-=k@X#iD=s2^gIe/Ru+To?R%(iAP-G$X)rW98HT#Z + j2`HGGM(2W0sjlt7Bm<(>>*V3Q4G>IM$9gd`"KO=1#Lm`Jap2/MHA4l?!B,5d9c\GX + mu#Y$n^MZ#,H(f\2GtbHg!._=0Gk#!EiX9U?Xt[=$0^Gm%Z:SoGBD'bolJ>Ohe-!"hBBP-? + dpSH)\>oK>Q]PTkqopVEt4Jfe^6+3a:o9Qp`>De(j#@P7Vf@\a#)sKnnY$Mj+KMDuM@l#E`]Mh9$];?A)g?VAq\P`cu]+uA#,g7V&mHnT'!3WH + +'f%`'\lF$d;E.0blIs^b:S$kn:p'_p=r]o-Ggj[!f8]8*eLd7L^[/>$JW9laS!\b4;heRV + $ZaM2d0X.#bG.Rg-qs%IAj(,T848)XG'*AZ*BX87E^b!b6L5TprtdJ(M+_ngPGFNqQ'L"AF + Eum@n_t30KT`ht!UX5IpkmMfhm\Y!BW7GkR>#D"QZGjH^of-(Y,R-.la;E@G]CO:LC^XL@2.bDt[8> + %(!cqL=:!MPmr:&'03_,RtkTd?JSK/`7A80Vh_%CZp?ZW + u?"*oZ0tPVC@Kq!M)0S_+<,q,^H7ku4L&rO:I6gO12#,6NoU=8YV>!sJj;oo/SGk09U@Fs!q("YJfGL/qk@>+pr69Ta#\s + &\uSPD\9;Zb/f#k2dP]N)/=\9,i+0*%?6Zkcl[FP5V?L[t'-YfK-gkjsXQbpea=O@V_?+,S + `HahY&._lftm>3e&IQ0?t;ToAR6(LL0O%2Ba%5p'[6l](W/12T`[aQ+d::)b_L710p?[C&S + L`*>b4nl'H`"1tE=]Cp,O\76p?/&q\u,93%nnc0*h-A,aBNtc8EBg#g,MV/O[jrKiN)*V6V + 229K_G)]q;JR)b&D.(s47N9u;/K*\*`6m0(H?HV^N9,!F;!#A4$1[OVP*VPO8J4K$]4Nsu] + _=bpicVQ)jX"#Xk?O:!mm""4dts[TB.SgD1E08aQ'.f"CR2``UlSf.$a=DY1SANs]tJ9bX] + 8A$[r1'hmd?D-,'L*%]cA&_SXkq2!F<&04X#6W*`SH?^dL/&_]?XQYOd'HHtUL&W=HOP*Ws + .Nj65r%`f1E=SudHF)qM2/56OEX_5#q]+<)hHCcg;%`i`Js2GW8#dC4ME&\lb)G4\IET.ML + [2g;F,ocSS;,C2gi@q29YQd[u'%\E8H]`(l@n)JPfru'`dDp#^W + jAFoKF(<@Ko[3sc"nZWOGap'KBfXepBgrn6V_!,+/+Bn)sQZ9r(O`!V1f + tmVeN*u^S[ChQ4Gurf0%gm@n6CfhS"7m4cooX@`4lH?2r7%KFGE'EbJjBCSi'U>23E>&@OY + J(Xk2YSXl0[k'ufSLtoCf!JoK1DZ~> +Q +Q q +372 386 18 -10 re W n +q +372 386 18 -10 re W n +% Fallback Image: x=372 y=406 w=18 h=10 res=300ppi size=9450 +[ 0.24 0 0 0.24 372 375.919983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 42 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 42 ] def +end +image +Gb"0O9+Jd7(l%"?\Aem&Q:ah!&eY;'W#?56fL9:NPK#ir0lS(pW4e9FTc9)jr!Uj]7$'XjQS + X%cc8.NOE$Xk$VM=UH>ZR'jo$!!* + 365QCff&3p3rr#+uS3WK0`&3p3r"RllA`Nib#AIPB=?E6)H_\H9N'PdO$T'(AMJ[TDCU+sf + /fBXBk9Nq44+Ka=1:qi=C\H6E@8\*DM\H970%HXEQOXopA[O;rU.B^J8nOU2A8R-i4jbiVD + \\](@d<3T%r;fP6rU5"l8,6T&B*iqeor5[)~> +Q +Q q +243 376 18 -8 re W n +q +243 376 18 -8 re W n +% Fallback Image: x=243 y=416 w=18 h=8 res=300ppi size=7650 +[ 0.24 0 0 0.24 243 367.839983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 34 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 34 ] def +end +image +Gb"0Md0Y=G'SYLCMCab\&_a0sMQD5h>fXY6+Lm4MB& + B%p^GC>m6j.NkmQ1b&!47!fZ;2#3Lg76IMIEZ%ofn%0r+8>mh9K^i~> +Q +Q q +294 376 70 -8 re W n +q +294 376 70 -8 re W n +% Fallback Image: x=294 y=416 w=70 h=8 res=300ppi size=29784 +[ 0.24 0 0 0.24 294 367.839983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 292 def + /Height 34 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 34 ] def +end +image +Gb"/kktb8[(l/-U.O2hTTN#1#AREH/?o;b0BcCQiJDpRnQT!Al6r^+id`",DlqOSJPteAWY_ + h^>V5]Rk";5D#Te\/$oJaMKait4r1F'S-iI19G39Ru11Zt@?c^]'ZM9F('Y,8*I?J1L4RC1 + 6UU#>W]9MndM0ri74SjrDMr-ZnbWNcaI2qS!PZdZ`&),E3cl02p)N/iqdh;s6!AU+GjNeW7 + _>#J=YEe7JSo!+"G)NBKS%LioZ3'1>_[2Kl!0K(V!%u1W!U&:q>%f@JU*?H91ZW8:G>?;W@ + >-2t?bAL:o^%%*G+nN=8a<3Z>9/gi-a>c7BTioskbaFk:D\!ACDg_5cKp0+\Td_!"):?X6C + MT[->/d''r4K\!M$_R[>][-U(E%6F2`k6t:YOn\8=kiuTrKeXG'8&@N@i:KIX`PY:L=Q6YT + eh)?+P8Xg)qdd&BUrp8sJ(6>>`BF$'0U[6+^pQ:@Tb[%\p,4<-Q*cG4BQb;$[[=J]OleiT> + _tZPYjW^s^XDIcp1W]n^l+8\UkgoiohOp9lkn5:+:f8-Z"l<#);.g=_=7dRmAB/Z+ + jPECndotI\^)7ijR=rEE8U[62I.iEf&,@(Sact>1'a%UYZd20_6pBcI,(Me8OR5/A[ZI/MW5>_j!pA_.N"+!9f/buSm?KTN,b7/,EMjd`]bi--[cT8UB4hbMq'5M$LEBB + c34RqeOnn+t_tBSos"E`-`QZZSdu$DK6Ht,foFFq9LP(5kT0>u.O/FHKfB%Ke_q*#IerK;n + .g;M`4KG2\W@?"DT(=2CLIAUrJ7G@La2c5%)47t;!>n*Q&Ht)4['LLNoN*-Sjj[8c(4+<`W + Mq>o-g`0dhrcI`DJ%P/QNYXhd,:R?6$H#?h?g*IqRX8pSmK!c]jfm*BDm7,@adm+E7FC@;, + ^uRlIH6\7`V/(p6d>1q^iAh"UKh$>45]Co.W'Vll*d_"1uQ,o"_C_N'+=[$mQ;L)T0Vu]>c + Pq^ofDN4KrT0,7j,Z_oMql`\?u!XtbktY\OXl&*t4Pa90&o0_3#^0oS6!CCDEull*d_"1uQ + ,o"_C_N'%rg((hIBE-$.jhT*Mi1-C/@KB)'G>Z:Ip"fPB7ir;X1i8FB3UU-^/;-R7/>$Sq\ + _6I=/G3Om?CKI_$B'9/K)d7u)(ku1;rW_d*T7[~> +Q +Q q +372 376 18 -8 re W n +q +372 376 18 -8 re W n +% Fallback Image: x=372 y=416 w=18 h=8 res=300ppi size=7650 +[ 0.24 0 0 0.24 372 367.839983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 34 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 34 ] def +end +image +Gb"0I9a\`k(kgkC-q4o'Y1i_nJq?KhgaXA@fQrJ(Xa6kGP:HcNh20&u86*Mgb\HnYGqQ#$k] + @%m@>q2SZ<=u0AKB2jG*Xm!9qM-W.eqOO]>!)IdJC!d5E#p + A,!6?M,eCf\C@0$7E"otaIb#>.d.q^^gP + :kJ/Si*[**~> +Q +Q q +243 368 18 -33 re W n +q +243 368 18 -33 re W n +% Fallback Image: x=243 y=424 w=18 h=33 res=300ppi size=31050 +[ 0.24 0 0 0.24 243 334.879983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 138 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 138 ] def +end +image +Gb"0V=]Z5E*!YnNP)]t:^`]:`F^;POi`9sXK<@`UH,M=+o9nFZ^Qg%HR&pK7a7C:s8I8Pnh/ + $Ba:Dq#T+rn$!^VF!9?-M1nmEd,eQefW1a`$/Vh3MJ`1!m0Mp#n6GXdY?kIN((CC:Y"+u%e + D.(0B,7NW@M$$`]SDQsZk^287%4q-t?JpC=X,6iWk]&hb%Wj3dfqSQLT._cN!2An>8p*@&U + ^^RVq@jHn4[*?_/AM7X4Wt;_ZLF5>nF<7W7R2W%lGEHd"Xn_>]G_!%1d=bTpi(,2"],:'5+ + %m@JFWfm38iTjq^d9-1H9`B3:PeK>s(po*)Z:B]6@k#")"KLj+.CWnBU[5!gFe*dDCFCDr% + ,sSA'!,2XokY'HSZ9FUCsJhO%gR1]i5,f-b87-RZ&G5l#sl4UcR`I"F9Gg=SB%i5Fh-"/+K + N"--:bNfB"UJL3Nt6q<#fB`gk[QiM+N3c]@6!Tl7YB^c?M-lN4*nERe3D;^]Y!2/O3S%0@?Cqn=h)q`_^*Y0f!JF^+UV1 + erSfE)/HDf-m3ChcjuncLIE(pKj!33]reOZ'Gcfmj&=UCXu=imnNa^g"9r\@X/?DKf%( + E<3Z%k?Cq):bXK?%7`9gsG_a,5D=/,cW:H8tg>@#,H=AfJ.3i]2o")BBenA(6aFr[`\OuBP + 53j@mS"Whp2?3UP(UCF:eHWC.g$h+9)=E3JqJ7$'=1$K-:SN`h>KcCNBF'PTc'+MhQDr6S* + Ru,C?cS']uHttU'B(jPJJkg4rc1,I`H[@hs+*VpQ?b^u"&Of!TS'8Y!W7+=>WUJ]V9dZ(=) + qR2`VF/O*VF7cF9%'X!&bB@C3R3kIQ@mEAT]HIN\7lA>86TbOG'8n8abg:1joR+l1,P;t_%6n>ZWn8!\WZ=*[+8RGi+Q_/0DAEG*g21K!TS[B!shWH=>22O`Gj3]rRU** + Q,F#4N_g=g#L1c_nIZ/K]7:R@]4KYt`AD"IJ_-eeM"=e3^S~> +Q +Q q +372 368 18 -33 re W n +q +372 368 18 -33 re W n +% Fallback Image: x=372 y=424 w=18 h=33 res=300ppi size=31050 +[ 0.24 0 0 0.24 372 334.879983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 138 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 138 ] def +end +image +Gb"0QbmD6P&-gKZ'YK6`A:L>^+^tn<26+('Ze&J@_=0Y&!p25(R;&\D3To414&;LC8):D"J: + N0#J:N/73TUha&.fBa&.fBaE"V"_Xo-fU"9\i1"9\i1"C)9n`WQPQ#RC\A#RC\AfE<$8+/!!EE-"9\i1"9^7ZIU;K3G5K0n^t[sS0] +Q +Q q +362 335 47 -10 re W n +q +362 335 47 -10 re W n +% Fallback Image: x=362 y=457 w=47 h=10 res=300ppi size=24696 +[ 0.24 0 0 0.24 362 324.919983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 196 def + /Height 42 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 42 ] def +end +image +Gb"0L_+Fc+(l%!2.;^'2FN=`>.$7CQ:qXZ>S!^dIg"X3icpHMVpgF?PiE?)js.%!=?EVl&e\ + cJi./TpUEds:BgW0-L!2at(ZFW3#W=.G,Xa'j6OA.YD&;;\acW0^:\39VJ3EU5.!_8Q:TC9.9[o + a9;H6X'J5HA,uV* +Q +Q q +316 325 18 -7 re W n +q +316 325 18 -7 re W n +% Fallback Image: x=316 y=467 w=18 h=7 res=300ppi size=6750 +[ 0.24 0 0 0.24 316 317.799983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 30 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 30 ] def +end +image +Gb"0J5mi3/(rc$?ACNUP02Rbi*McUB>)0DCJo5\(HY8m"SHC96"$mO+Yat"Xa'3r\hWiQnhk + KFS@td85Dc4aLnRSY$p=ApM"A5Z>TP8f*HOif?K7/g@.IDNT?(Yb4>ug%^3G9LO=d3W`R"p + X +Q +Q q +362 325 47 -7 re W n +q +362 325 47 -7 re W n +% Fallback Image: x=362 y=467 w=47 h=7 res=300ppi size=17640 +[ 0.24 0 0 0.24 362 317.799983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 196 def + /Height 30 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 30 ] def +end +image +Gb"0L_$RtT&4OuE1`?M9J0J)k`-(DifTKFYmjNX)j"fOsT&D@3bk=f\B3pY^HElhF]=MFb_n + J2S:\?-49NpEd=s?C.UhGT!/WlbR;RAiLQ:TC9.9[oa9;H6X'J5HA,uV*eM[l\=.@mEg:D4?n-5Fgje;~> +Q +Q q +316 318 18 -34 re W n +q +316 318 18 -34 re W n +% Fallback Image: x=316 y=474 w=18 h=34 res=300ppi size=31950 +[ 0.24 0 0 0.24 316 283.919983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 142 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 142 ] def +end +image +Gb"0Sf1m8^&-h&OJUkH"FiST_N>jdh(BXljHSMC-\kjFqa^#N.a]4FYPe70D#d3AK=bMU4"; + 5O:s0/7SqX8XBS[!C"2B3'X8Oo!@MKXGrs.3Kn?8&D%nrhFsqtujueQ#VeJ5,\G8b]1k?t3 + J*$XaDPfMGemJ]\(qEPVF>>!,Wq-k%N]9^9E.4Ac#_E1g+.XfA*)XJo_1PTRUn@!+ma#:a' + Nq]QAM3M($NrFcH!jPa$s;dB%P0(&dfp#( + `HYc`F#.Z@.hLq=qH*`M0OV0+9-!0hi.5`1T[3#F"%0m?ikUj\*73fa"5AAlD\6u^a'$=\f + \/e6fDu,dW<6E9-QX*7[Gudk%LuGqYfL.l!8*;63ph+E5Y"*@*n]/n_1@IEo8*PWoCDFeY& + G3^[*o5VYQ8p&4)kqXc(b_!aN;C'H[rp0ll8-l\$Ltp'a&&Z1B;T@_gm"`J:0[j/e_W:%h+ + hhR=tn>p[iL!;TZ@Y&dN%$nA'V34q:ONYR^u_Z=_GfAm2:CJMrDi%ijs)V[XX2+2@p%$s%I + p?k[Scs(R@KHau"G$YT%V2fub"-na%/WDZMbljqWBERF0An + eI4r9PC.Wd7+U!uL*UY:(#3:[n5W)@Tl@T18sdY-)F?0/"up^tAPd$n*3anA(lS74@ZbJhU + "bd9kg_Mbr@-q)K;%*/btkB4kkAJQ`'b>_t$5J_JT%;qf$NP7teu8Lkc&+/=B[bHui$b:>9 + >?4`0YNkiH$hI4j;=f_XrDsQ`?6 + bB@)k'q+1A_teHhFH!8@#E/CpEmdg:6,&=R53%eAD54;>*Yu`br"\<0V=VR02mgo9T+3dqATfM($:<.FYp^[n:B)op[Dd1!P"H%9e/Hm-I+b&P4M*F7\8%H&M]qM5f=e?)f_^oa?E + ^3pc~> +Q +Q q +372 318 18 -34 re W n +q +372 318 18 -34 re W n +% Fallback Image: x=372 y=474 w=18 h=34 res=300ppi size=31950 +[ 0.24 0 0 0.24 372 283.919983 ] concat +/DeviceRGB setcolorspace +8 dict dup begin + /ImageType 1 def + /Width 75 def + /Height 142 def + /Interpolate false def + /BitsPerComponent 8 def + /Decode [ 0 1 0 1 0 1 ] def + /DataSource currentfile /ASCII85Decode filter /FlateDecode filter def + /ImageMatrix [ 1 0 0 -1 0 142 ] def +end +image +Gb"0U9hrPj(rl*@BS:h.MadFQ9Y?*,?9k7i@u(NPMKfM\\6!d)a1t&mMm@jj)\uU^R)WM8Pa + Q7Os2f>4pXd]"hD>tE,uWRCeonY%hX4ul!!*-(#S8+DJ,fT + OPS6RG^G>ij!X&c?+@(GW!WFaF@0-Q;&0O5g!!*-(#Z*tn5_&h8!X&c?+@(IGJ@8kd":,P] + 5_&h8!X&d*%P[;)6l$n1J,fTO":,P]^o5&X?E[6V*u%?uXk0[Kf + %S6E**Z;]e(j]gNt7dgmr:+Ngc(_*AHu-#6a#%2D-)V6maLcD2Z)gM-Bu%L/YUC=<\9SD]. + Zh*'#]_qM`Gj-+?)TE+]AS^!RoW8PYKWJ<(U$4e4!K*4Okf472``3n6CI-8QVMC6r!*Dm.u + 3WM+_@nbQ6!~> +Q +Q Q +showpage +%%Trailer +%%EOF diff --git a/mmu/notmain.c b/mmu/notmain.c index be32af8..62d9f31 100644 --- a/mmu/notmain.c +++ b/mmu/notmain.c @@ -9,6 +9,7 @@ extern unsigned int GET32 ( unsigned int ); extern void start_mmu ( unsigned int, unsigned int ); extern void stop_mmu ( void ); extern void invalidate_tlbs ( void ); +extern void invalidate_caches ( void ); extern void uart_init ( void ); extern void uart_send ( unsigned int ); @@ -16,6 +17,8 @@ extern void uart_send ( unsigned int ); extern void hexstrings ( unsigned int ); extern void hexstring ( unsigned int ); +unsigned int system_timer_low ( void ); + #define MMUTABLEBASE 0x00004000 //------------------------------------------------------------------- @@ -27,14 +30,35 @@ unsigned int mmu_section ( unsigned int vadd, unsigned int padd, unsigned int fl ra=vadd>>20; rb=MMUTABLEBASE|(ra<<2); - ra=padd>>20; - rc=(ra<<20)|flags|2; + rc=(padd&0xFFF00000)|0xC00|flags|2; + //hexstrings(rb); hexstring(rc); PUT32(rb,rc); return(0); } +//------------------------------------------------------------------- +unsigned int mmu_small ( unsigned int vadd, unsigned int padd, unsigned int flags, unsigned int mmubase ) +{ + unsigned int ra; + unsigned int rb; + unsigned int rc; + + ra=vadd>>20; + rb=MMUTABLEBASE|(ra<<2); + rc=(mmubase&0xFFFFFC00)/*|(domain<<5)*/|1; + //hexstrings(rb); hexstring(rc); + PUT32(rb,rc); //first level descriptor + ra=(vadd>>12)&0xFF; + rb=(mmubase&0xFFFFFC00)|(ra<<2); + rc=(padd&0xFFFFF000)|(0xFF0)|flags|2; + //hexstrings(rb); hexstring(rc); + PUT32(rb,rc); //second level descriptor + return(0); +} //------------------------------------------------------------------------ int notmain ( void ) { + unsigned int ra; + uart_init(); hexstring(0xDEADBEEF); @@ -43,21 +67,36 @@ int notmain ( void ) PUT32(0x00245678,0x00245678); PUT32(0x00345678,0x00345678); + PUT32(0x00346678,0x00346678); + PUT32(0x00146678,0x00146678); + + PUT32(0x0AA45678,0x12345678); + PUT32(0x0BB45678,0x12345678); + PUT32(0x0CC45678,0x12345678); + PUT32(0x0DD45678,0x12345678); + hexstring(GET32(0x00045678)); hexstring(GET32(0x00145678)); hexstring(GET32(0x00245678)); hexstring(GET32(0x00345678)); uart_send(0x0D); uart_send(0x0A); - mmu_section(0x00000000,0x00000000,0x0000|8|4); - mmu_section(0x00100000,0x00100000,0x0000); - mmu_section(0x00200000,0x00200000,0x0000); - mmu_section(0x00300000,0x00300000,0x0000); + for(ra=0;;ra+=0x00100000) + { + mmu_section(ra,ra,0x0000); + if(ra==0xFFF00000) break; + } + + //mmu_section(0x00000000,0x00000000,0x0000|8|4); + //mmu_section(0x00100000,0x00100000,0x0000); + //mmu_section(0x00200000,0x00200000,0x0000); + //mmu_section(0x00300000,0x00300000,0x0000); //peripherals mmu_section(0x20000000,0x20000000,0x0000); //NOT CACHED! mmu_section(0x20200000,0x20200000,0x0000); //NOT CACHED! - start_mmu(MMUTABLEBASE,0x00800001|0x1000|0x0004); + start_mmu(MMUTABLEBASE,0x00000001|0x1000|0x0004); //[23]=0 subpages enabled = legacy ARMv4,v5 and v6 + hexstring(GET32(0x00045678)); hexstring(GET32(0x00145678)); hexstring(GET32(0x00245678)); @@ -67,23 +106,71 @@ int notmain ( void ) mmu_section(0x00100000,0x00300000,0x0000); mmu_section(0x00200000,0x00000000,0x0000); mmu_section(0x00300000,0x00100000,0x0000); - invalidate_tlbs(); + hexstring(GET32(0x00045678)); hexstring(GET32(0x00145678)); hexstring(GET32(0x00245678)); hexstring(GET32(0x00345678)); uart_send(0x0D); uart_send(0x0A); + for(ra=0;ra<4;ra++) + { + hexstring(system_timer_low()); + } + uart_send(0x0D); uart_send(0x0A); + + mmu_section(0x20000000,0x20000000,0x0000|8); //CACHED + invalidate_tlbs(); + + for(ra=0;ra<4;ra++) + { + hexstring(system_timer_low()); + } + uart_send(0x0D); uart_send(0x0A); + + mmu_small(0x0AA45000,0x00145000,0,0x00000400); + mmu_small(0x0BB45000,0x00245000,0,0x00000800); + mmu_small(0x0CC45000,0x00345000,0,0x00000C00); + mmu_small(0x0DD45000,0x00345000,0,0x00001000); + mmu_small(0x0DD46000,0x00146000,0,0x00001000); + mmu_small(0x0DD03000,0x20003000,0,0x00001000); + mmu_section(0x00300000,0x00300000,0x0000); + invalidate_tlbs(); + + + hexstring(GET32(0x0AA45678)); + hexstring(GET32(0x0BB45678)); + hexstring(GET32(0x0CC45678)); + uart_send(0x0D); uart_send(0x0A); + + + hexstring(GET32(0x00345678)); + hexstring(GET32(0x00346678)); + hexstring(GET32(0x0DD45678)); + hexstring(GET32(0x0DD46678)); + uart_send(0x0D); uart_send(0x0A); + + for(ra=0;ra<4;ra++) + { + hexstring(GET32(0x0DD03004)); + } + uart_send(0x0D); uart_send(0x0A); + + + //access violation. + mmu_section(0x00100000,0x00100000,0x0020); - invalidate_tlbs(); + hexstring(GET32(0x00045678)); hexstring(GET32(0x00145678)); hexstring(GET32(0x00245678)); hexstring(GET32(0x00345678)); uart_send(0x0D); uart_send(0x0A); + hexstring(0xDEADBEEF); + return(0); } //------------------------------------------------------------------------- diff --git a/mmu/novectors.s b/mmu/novectors.s index 5e87fe3..deaf533 100644 --- a/mmu/novectors.s +++ b/mmu/novectors.s @@ -76,8 +76,8 @@ handler: data_abort: mov r6,lr ldr r8,[r6,#-8] - mrc p15,0,r4,c5,c0,0 ;@ data/combined - mrc p15,0,r5,c5,c0,1 ;@ instruction + mrc p15,0,r4,c5,c0,0 ;@ data/combined + mrc p15,0,r5,c5,c0,1 ;@ instruction mov sp,#0x00004000 bl hexstring mov r0,r4 @@ -143,6 +143,7 @@ invalidate_tlbs: bx lr + ;@------------------------------------------------------------------------- ;@ ;@ Copyright (c) 2012 David Welch dwelch@dwelch.com diff --git a/mmu/periph.c b/mmu/periph.c index c9ed11b..2e0d49b 100644 --- a/mmu/periph.c +++ b/mmu/periph.c @@ -9,27 +9,26 @@ extern unsigned int GET32 ( unsigned int ); extern void BRANCHTO ( unsigned int ); extern void dummy ( unsigned int ); -#define ARM_TIMER_CTL 0x2000B408 -#define ARM_TIMER_CNT 0x2000B420 +#define SYSTIMERCLO (0x20003004) -#define GPFSEL1 0x20200004 -#define GPSET0 0x2020001C -#define GPCLR0 0x20200028 -#define GPPUD 0x20200094 -#define GPPUDCLK0 0x20200098 +#define GPFSEL1 (0x20200004) +#define GPSET0 (0x2020001C) +#define GPCLR0 (0x20200028) +#define GPPUD (0x20200094) +#define GPPUDCLK0 (0x20200098) -#define AUX_ENABLES 0x20215004 -#define AUX_MU_IO_REG 0x20215040 -#define AUX_MU_IER_REG 0x20215044 -#define AUX_MU_IIR_REG 0x20215048 -#define AUX_MU_LCR_REG 0x2021504C -#define AUX_MU_MCR_REG 0x20215050 -#define AUX_MU_LSR_REG 0x20215054 -#define AUX_MU_MSR_REG 0x20215058 -#define AUX_MU_SCRATCH 0x2021505C -#define AUX_MU_CNTL_REG 0x20215060 -#define AUX_MU_STAT_REG 0x20215064 -#define AUX_MU_BAUD_REG 0x20215068 +#define AUX_ENABLES (0x20215004) +#define AUX_MU_IO_REG (0x20215040) +#define AUX_MU_IER_REG (0x20215044) +#define AUX_MU_IIR_REG (0x20215048) +#define AUX_MU_LCR_REG (0x2021504C) +#define AUX_MU_MCR_REG (0x20215050) +#define AUX_MU_LSR_REG (0x20215054) +#define AUX_MU_MSR_REG (0x20215058) +#define AUX_MU_SCRATCH (0x2021505C) +#define AUX_MU_CNTL_REG (0x20215060) +#define AUX_MU_STAT_REG (0x20215064) +#define AUX_MU_BAUD_REG (0x20215068) //GPIO14 TXD0 and TXD1 //GPIO15 RXD0 and RXD1 @@ -121,18 +120,10 @@ void uart_init ( void ) PUT32(GPPUDCLK0,0); PUT32(AUX_MU_CNTL_REG,3); } -//------------------------------------------------------------------------ -void timer_init ( void ) -{ - //0xF9+1 = 250 - //250MHz/250 = 1MHz - PUT32(ARM_TIMER_CTL,0x00F90000); - PUT32(ARM_TIMER_CTL,0x00F90200); -} //------------------------------------------------------------------------- -unsigned int timer_tick ( void ) +unsigned int system_timer_low ( void ) { - return(GET32(ARM_TIMER_CNT)); + return(GET32(SYSTIMERCLO)); } //------------------------------------------------------------------------- //-------------------------------------------------------------------------