Jump to content
Shift838

USES UCSD Pascal

Recommended Posts

I never got around to learning pascal and figured with us on lockdown it's a good time.

 

I have been reading through the TI UCSD Compiler manual and I wanted to play around with some of the TI Units Procedures and Functions that are stored in the SYSTEM.LIBRARY on the compiler disk.

 

So i created just super small program to echo Hello for testing to make sure I got the 'USES' and other statements right.

 

However when I go to compile I get a error that states:

 

Attempt to open library unsuccessful
Line 3

I have my compiler disk in Drive #2, without the USES and reserved functions it will compile and run fine.

 

PROGRAM HELLO;
USES SUPPORT;
BEGIN
  SET_SCREEN(1:INTEGER);
  SET_SCR_COLOR(4,15:INTEGER);
  WRITELN('HELLO');
END.

What am I doing wrong here?

  • Like 4

Share this post


Link to post
Share on other sites

After some messing around with it I got it working.

 

I ended up creating a whole new disk file with 1440 blocks and copied all my disk to one disk.

 

I did have the syntax wrong on the SET_SCREEN and SET_SCR_COLOR functions.

 

The correct coding would be:

 

PROGRAM HELLO;
USES SUPPORT;
BEGIN
  SET_SCREEN(1);
  SET_SCR_COLOR(4,15);
  WRITELN('HELLO');
END.

 

  • Like 4

Share this post


Link to post
Share on other sites

Looks like in you initial set up the system library was not being located in any of the available disk drives. You solved the problem by consolidating all your disks. Obviously this would not work on real hardware unless you have DSDS drives. I tend to keep my libraries on the work disk as it simplifies life.

  • Like 1

Share this post


Link to post
Share on other sites
3 hours ago, Shift838 said:

After some messing around with it I got it working.

 

 

First of all, welcome to the dark side!  

 

I likely ran into the same problem when I started Pascal development on the 99/4A some years ago.  I've gone through my early log entries (at some point I started logging every day's worth of coding in Evernote) but I don't have a note covering this particular problem. 

 

UNITS are very useful in Pascal, especially from an editing and compiling efficiency perspective.  It's worth looking at the Pascal Compiler manual from page 100, section 4.5 UNITS.  I read that section some years ago (again and again) and straight-up it answered absolutely none of my questions.  But a craftsman never blames his tools.  I eventually worked it out and posted it in Atariage.  I hope you find this useful.

 

@apersson850 is the most knowledgeable on Pascal and has been hugely helpful to me and others in the community over the years.

 

FWIW, I have customized my disks extensively (if you're interested, I can point you to some of the resources in the USUS library and other places). 

 

  • Like 4

Share this post


Link to post
Share on other sites
9 hours ago, Rossman said:

First of all, welcome to the dark side!  

 

I likely ran into the same problem when I started Pascal development on the 99/4A some years ago.  I've gone through my early log entries (at some point I started logging every day's worth of coding in Evernote) but I don't have a note covering this particular problem. 

 

UNITS are very useful in Pascal, especially from an editing and compiling efficiency perspective.  It's worth looking at the Pascal Compiler manual from page 100, section 4.5 UNITS.  I read that section some years ago (again and again) and straight-up it answered absolutely none of my questions.  But a craftsman never blames his tools.  I eventually worked it out and posted it in Atariage.  I hope you find this useful.

 

@apersson850 is the most knowledgeable on Pascal and has been hugely helpful to me and others in the community over the years.

 

FWIW, I have customized my disks extensively (if you're interested, I can point you to some of the resources in the USUS library and other places). 

 

Customized disk?  very interested..  point away please!

Share this post


Link to post
Share on other sites
Posted (edited)

There are a few things that I do to customize my p-system environment.

 

Have a look at this post on Atariage.  This was really helpful to me when I was getting started.

 

Also, have a look at this directory on whtech

-- Disk 671 volume name PUTIL-A has some useful utilities on it.  SYSTEM.STARTUP on this volume should give you an upper and lower case character set, and the volume includes some additional character sets as well.  I've harvested a number of things from this volume. 

-- Disk 712A has the MODCOL utility which changes the foreground and background colors.  I use white foreground on dark blue.

-- Disk 705 is a DSDD boot disk image that provides a reference example of a customized boot disk.  

 

If you have a physical 4th disk drive or if you have Classic99, you can add a utility that @apersson850 posted called unit_10 that will make it accessible in the p-system environment.  He also included code to access a ramdisk from the p-system in the same post.

 

For what it's worth, I found that experimenting with incremental customization let me eke out a little bit more out of the p-system here and there.

 

Hope this is helpful.

Edited by Rossman
  • Like 3
  • Thanks 2

Share this post


Link to post
Share on other sites

One thing I didn't mention in the post Rossman links to above, was the mapping of the libraries.

Separately compiled units, whether you made them yourself or they were provided by TI, have to be accessible at two different occasions.

The first occassion is when you compile the program using the units. The second occasion is when you run the program that uses the units.

 

The p-system can always find and access units, both at compile and run time, that are stored in the *SYSTEM.LIBRARY file. Note that the asterisk at the beginning of the file name is the shorthand root volume (#4:) prefix. The SYSTEM.LIBRARY file provided with the system when you get it contains the system extensions that TI developed to provide access to TI 99/4A specific things, like sprites and sound.

 

When you create your own units, you have two options. Either you include them in SYSTEM.LIBRARY or you keep them in a separate file. To include them in the system's library file makes sense if they are of general interest. A general input utility is a typical candidate for this. But if you develop a unit that's meaningful in one program only, where the reason for making it a unit could be that the program is too large to be edited as a single unit, and you can break out a section that has a specific and (preferably) separate task in your program (like printing a result), then it makes sense to place this unit in a file by itself. I've developed some program for my 99/4A, where one main program relied on the use of half a dozen units. These units were all specific for this program, so I included them in a separate library.

The supplied utility program LIBRARY.CODE is used to open a library file as well as add or remove single units from that library.

 

If you then compile a program, which references the system unit support, as well as your own unit printfix, and that unit is stored in the file printutil.code, then you need to write your program like this.

program unittest;

uses
  support,
  (*U mydisk:printutil.code *) printfix;

begin
  (* bla bla bla *)
end.

That's sufficient for compiling your program. The compiler will now know where to find the interface section of the unit.

When it's time to run the program, you need to tell the runtime system where to find the implementation section of the unit. When it's in a file outside the SYSTEM.LIBRARY, like in the example above, you have to create a file which tells the system where to look. This is the USERLIB.TEXT file. That file simply contains the line MYDISK.PRINTUTIL.CODE to tell the system where to look.

You can use an execution option to set the name for the library index file. Press X L=mydisk:unitfile.text to tell the system that you have your own unit index file on your work disk.

Such a unit index file can contain multiple lines, telling the system to scan through all of them, to located the proper units, if your program references many different units, spread over different files. Or you can use the LIBRARY.CODE program to consolidate all your units into different slots in your own library file, in which case your unit index file only need to point to that library.

  • Like 3
  • Thanks 2

Share this post


Link to post
Share on other sites
On 4/14/2020 at 5:52 PM, Shift838 said:

However when I go to compile I get a error that states:

 

Attempt to open library unsuccessful
Line 3

I have my compiler disk in Drive #2, without the USES and reserved functions it will compile and run fine.

 

 

For what it's worth, I was flipping through the Pascal Compiler manual and came across an entry on page 211.  It's the appendix, section 8.16, PROGRAM DEVELOPMENT WITH MULTI-DRIVE SYSTEMS.

 

With two-disk systems, TI recommended combining the compiler and editor onto one diskette and having that in #5, with the filer in #4.  Per their recommendation, source and object code should be in #4.  I don't follow this recommendation as I have the Filer and Editor in disk #4, the compiler in disk #5, and source and object code in disk #9 (with code I use for reference purposes in #10, per the previous post about UNIT_10).  

 

I suspect that this is a brute force way to ensure that at both compile time and run time that SYSTEM.LIBRARY can be found.  

 

Again, hope this is helpful.

 

Share this post


Link to post
Share on other sites
Posted (edited)

As I wrote above, if you have SYSTEM.LIBRARY on the root volume (#4:), then everything is automatic.

 

Here's a piece of code from one of my programs, a program which uses several units defined for this program only. It also uses one system unit, crt.

You can see that the uses-clause is given file location information to tell it in which file to look for the appropriate unit. These units are not consolidated into any SYSTEM.LIBRARY file.

This particular code section is actually from Turbo Pascal 4.0, but the same code runs under the UCSD p-system on the 99/4A as well.

 

In this example, the units contain global data definitions and then different sections of the program, like data entry, data display, data disk storage etc.

 

I included the complete main program, since it shows how you can create a fairly complex program, but still keep the main program small and easy to overview. The main program here only handles the main user's menu system and some minor housekeeping. By then doing the real work in the different units, I could work on one of them without caring about all other stuff in the program. This was especially important when working with the TI 99/4A, since the whole program is 4000 lines long. It doesn't fit in the editor and compiling everything takes a loooooong time, to say the least. That wasn't much of an issue with Turbo Pascal, but the same convenience of working with one piece at a time ruled.

program dust_buster;
 (* Dust evacuation dimensioning software system.
    Idea: Sven Lundgren, Process Ventilation.
    Program: Anders Persson. *)

 (* A-DATA 880705 *)

uses
   crt,
   (*$U dustglob *) dustglobal,
   (*$U dustent  *) dust_entry,
   (*$U dustshow *) dust_show,
   (*$U dustio *)   dust_io,
   (*$U dustchng *) dust_change,
   (*$U dustprin *) dust_print,
   (*$U dustback *) dust_back;

var
   i,
   choice: integer;
   stop: boolean;
   hmr: ^integer;

function menu: integer;
 (* Displays the main menu *)

var
   choice: integer;

begin (* menu *)
   clrscr;
   gotoxy(20,1);
   write('DAMMUTSUG  v4.2');
   gotoxy(20,2);
   write('===============');
   gotoxy(1,5);
   write('1 - Inmatning');
   gotoxy(1,7);
   write('2 - Visa data');
   gotoxy(1,9);
   write('3 - Žndra data');
   gotoxy(1,11);
   write('4 - Spara data p† skiva');
   gotoxy(1,13);
   write('5 - H„mta data fr†n skiva');
   gotoxy(1,15);
   write('6 - Utskrift av resultat');
   gotoxy(1,17);
   write('7 - Utskrift av material†tg†ng');
   gotoxy(1,19);
   write('8 - Avsluta');
   gotoxy(5,23);
   write('Process Ventilation   A-DATA 88');

   repeat
      choice := ord(readkey);
      if choice<>15 then
         choice := choice-48;
   until choice in [1..8,15];
   menu := choice;
end; (* menu *)


function ok_to_kill
 (* Checks if the current system is stored, and, if not, allows storage
    before continuing. *)
   (var stored: boolean;
    var plant: plant_type;
    var filename: string): boolean;


   function menu: integer;
    (* Shows the save or abandon option menu *)

   var
      choice: integer;

   begin (* menu *)
      clrscr;
      writeln('Det nuvarande systemet „r inte lagrat!');
      gotoxy(1,4);
      write('1 - Spara data p† skiva');
      gotoxy(1,6);
      write('2 - Forts„tt utan att spara');
      gotoxy(1,8);
      write('3 - Avbryt valt alternativ');
      write(bell);

      repeat
         choice := ord(readkey)-48;
      until choice in [1..3];
      menu := choice;
   end; (* menu *)

begin (* ok to kill *)
   if not stored then
      case menu of
         1: begin
               save_data(plant,filename);
               stored := true;
               ok_to_kill := true;
            end;
         2: ok_to_kill := true;
         3: ok_to_kill := false;
      end; (* case *)
end; (* ok to kill *)


begin (* dustbuster *)
   if data_files_ok then
   begin
      mark(hmr);       (* To allow swift release of heap space before a new
                          system is entered. *)
      stop := false;
      repeat
         choice := menu;
         case choice of
            1: if ok_to_kill(stored,plant,filename) then
               begin
                  release(hmr);
                  mark(hmr);
                  new_data(plant,stand_dim);
                  filename := filedefault;
                  calculate(plant,stand_dim);
                  (* If plant.next=nil at this point, there can't be any
                     system to preserve. Otherwise, prevent accidental
                     erasure. *)
                  stored := plant.next=nil;
               end;
            2: show_data(plant);
            3: if ok_to_kill(stored,plant,filename) then
               begin
                  change_data(plant,stand_dim);
                  calculate(plant,stand_dim);
                  stored := false;
               end;
            4: begin
                  save_data(plant,filename);
                  stored := true;
               end;
            5: if ok_to_kill(stored,plant,filename) then
               begin
                  release(hmr);
                  mark(hmr);
                  plant.next := nil;   (* Just in case nothing can be read *)
                  fetch_data(plant,filename);
                  stored := true;
               end;
            6: print_data(page_height,plant,prdevice,filename);
            7: cost_report(page_height,plant,stand_dim,cost_info,prdevice,filename);
            8: if ok_to_kill(stored,plant,filename) then
               begin
                  stop := true;
                  release(hmr);
                  clrscr;
               end;
           15: secret_service(show_change,page_height,prdevice,stand_dim);
         end; (* case *)
      until stop;
   end; (* if *)
end. (* dustbuster *)

 

Edited by apersson850
Added info
  • Like 2

Share this post


Link to post
Share on other sites
On 4/21/2020 at 7:55 AM, apersson850 said:

I included the complete main program, since it shows how you can create a fairly complex program, but still keep the main program small and easy to overview. The main program here only handles the main user's menu system and some minor housekeeping. By then doing the real work in the different units, I could work on one of them without caring about all other stuff in the program.

 

My Pascal professors in the 1980s were adamant that Main should have only one line of code.  I found it frustrating at the time, but I have come to appreciate what they were trying to teach me. Among other things, a verbose Main is a short path to writing sloppy code.  So in my code today, Main has one statement.  

 

In my Chemin-de-Fer game and in my Roulette game, I have implemented a crude model-view-controller in each in an attempt to separate UI from logic.  I have a lot of units.  That allows me to compile more efficiently and, more importantly, test code in isolation.  

 

One other thing I have learned, especially since picking up the code a couple of months ago, is that the solution need not be perfect the first or second or third try, or ever.  There is great joy in making something that works, then making it work a little better, then a little better-er, and so forth.  

 

  • Like 1

Share this post


Link to post
Share on other sites

So if all your main does is call another function, you are spending 2 or 4 bytes of stack space simply to make your old professors happy?

 

Why not just change the name of the entry point? It amounts to the same but doesn't cost any stack. ;)

 

Share this post


Link to post
Share on other sites
On 4/15/2020 at 11:15 PM, Rossman said:

There are a few things that I do to customize my p-system environment.

Since I posted this, I've been motivated to look at my boot disk again, and am making some adjustments.  I strung the aforementioned utilities together using CHAIN, plus a REDIRECT for a date prompt.  I'm now consolidating the code and will post it here when I'm done. 

 

I want to stress that the value of this is in the work done by other people, I've simply orchestrated it for convenience.

 

On the date capture.  I put the user in Filer-Date which is crude but effective.  I'm certain there's a POKE for setting the system date, but I'm not that familiar with the internals to know precisely how to do that.

Share this post


Link to post
Share on other sites
20 minutes ago, Rossman said:

My Pascal professors in the 1980s were adamant that Main should have only one line of code.  I found it frustrating at the time, but I have come to appreciate what they were trying to teach me. Among other things, a verbose Main is a short path to writing sloppy code.  So in my code today, Main has one statement.

Eh, I disagree, and I find minimal main functions frustrating.  Main is a function like any other, put code in it.  Sloppy programmers write sloppy code, regardless of how the code is organized.  A language or design pattern will not make anyone a better programmer.  Of course, just my opinions.  Back to the regularly scheduled topic of the thread.

Share this post


Link to post
Share on other sites
6 minutes ago, Tursi said:

So if all your main does is call another function, you are spending 2 or 4 bytes of stack space simply to make your old professors happy?

 

Why not just change the name of the entry point? It amounts to the same but doesn't cost any stack. ;)

 

You are probably right.  

 

I am not a smart developer and I have not been hands-on-keyboard cutting code too much in the last decade-and-a-half.  What I concluded is that avoiding verbose Main code keeps me out of lazy habits, like global variables.  For reasons I no longer remember, it wasn't uncommon to see global variables in code examples that I was learning from (nearly) 40 years ago.  I don't know why that was.  It just was.   And I wasn't smart enough to understand the benefits of good code encapsulation at the time to appreciate why things like that were just bad ideas.  My conclusion is that their discipline in this area - artificial though it may be - made me a more disciplined developer.  Not a good developer, but a more disciplined one.

 

From time to time, I've had reason to look at Java and C# code in the last 20 years, and I know that encapsulation isn't a given.  That can lead to conditions that defy automated testing and yield mystery production errors.  

 

When I started coding in Pascal again a few years ago, I remembered that rule.  I started with that rule, specifically to understand why they had it.  Perhaps it isn't much value, but after a hiatus I can pick up my code a lot easier now than I could decades ago, if only because it's got a bit more structure to it than it would have otherwise. 

 

That's worth at least 2 bytes, if not 4, of stack.

 

  • Like 1

Share this post


Link to post
Share on other sites
Posted (edited)

Well.. the concept of "good" and "bad" programming changes quite often, and I think we're going to find that a lot of what is considered "good" today will be considered "bad" in another twenty years. So don't get too hung up on it.

 

Regardless of how your code is structured, the machine underneath operates the same way. One of the biggest reasons that global variables were so common back in the day is that power was limited, and globals were simply better performing. CPUs have improved and non-global variables have gotten much better - often to par, but indirection is indirection and will always be more expensive than no indirection. The question that has been growing less important is whether it matters. ;)

 

At it simplest form, though, good code is /readable/. You should be able to look at it and know what it's doing. You should understand WHY it's doing that. And that's why good code is a combination of functions to isolate behaviours, encapsulation to isolate data, and comments to explain the mess. However, all of these things can be taken too far. When readability suffers, then it's not good code anymore.

 

Your case of a main function that does nothing but call another function does not isolate a behaviour, encapsulate any data, nor perform a clear and obvious function. All it does, literally all it does, is consume memory. I was teasing a bit, but if you simply renamed your entry function to whatever your main function calls now, your code's function would be /identical/ but not consume the stack space, right?

 

Main exists for a reason - to identify where the program starts executing. Saying it should contain no code is what led to the rather silly process of encapsulating your entire program in the constructor of an object, and having an empty main(). That structure made it hard to even see where a program started, but was considered good object-oriented programming practice in C++. (I'm not sure if anyone but MFC still does that though ;) ).

 

Ultimately, I don't mean to call you out - there's no harm in writing code however makes you happy. But I am going to argue that it's meaningful for readability - that one thing. When it gets down to the assembly level, it's this:

 

* runtime startup complete, call user program
  bl @main

...

main
  bl @program
  rt

...

program
* real code starts here...

 

Just a double subroutine call...

 

Anyway, sorry, don't mind me. :) I still have to deal with this sort of thing... ;)

 

Edited by Tursi

Share this post


Link to post
Share on other sites

(That said, I see you are crediting being forced to do it with forcing discipline in your code. I guess I can appreciate that, but I still think your profs were silly. ;) )

 

  • Like 1

Share this post


Link to post
Share on other sites
Posted (edited)

As could be seen from the code example I posted, I tend to make the main program easy to overview, so you can get an idea about what's being done. Then the details are in various subprograms. At least in more complex projects. If the whole program is a hundred lines, it doesn't matter much.

 

By the way, when a procedure or function is called, an activation record is created on the stack.

An activation record in the UCSD p-system consists of the following parts:

  1. Function value, if it is a function. Four words for a real result, otherwise one word.
  2. Space for parameters, if any.
  3. Space for local variables, if any.
  4. Five words of Mark Stack information.

So the absolute minimum amount of stack space that's allocated is five words, for a procedure with no parameters and no local variables.

 

<nerd mode>

The five mandatory words are these:

  • MSSTAT points to the activation record of the lexical parent.
  • MSDYN points to the activation record of the caller.
  • MSIPC points to the place from where it was called. Segment relative byte pointer (since p-codes are bytes, not words).
  • MSENV pointer to the calller's environment record (E_Rec).
  • MSPROC procedure number of the caller.

 

An activation record is what I just described. A block of data that's local to a procedure.

An environment record contains information about a compilation unit's global data and segment link.

A compilation unit is the main program or any unit it uses.

A segment is a part of the program that can be removed from memory, and later reloaded from disk, to allow running programs that don't fit in memory all at the same time. A compilation unit is always a segment, but a compilation unit may be split in several segments.

 

</nerd mode>

Edited by apersson850
  • Like 1

Share this post


Link to post
Share on other sites
6 hours ago, Tursi said:

(That said, I see you are crediting being forced to do it with forcing discipline in your code. I guess I can appreciate that, but I still think your profs were silly. ;) )

 

I am with you on this Tursi. I prefer the main be more of a high-level synopsis of the program. Not many lines but enough to describe what the darn thing does.

I coded Pascal that way as well. The main program was never more than a page but it was not one line.

 

To your point about why have the extra call, in Forth if we followed the advice of one line in the main program it could look as silly as:

: MAIN    GO ;

:)  

  • Like 1

Share this post


Link to post
Share on other sites

And in Pascal

begin
  doit;
end.

And something similar in all other languages. Which doesn't give you any idea of what's going on.

But something like this does.

begin
  getFileName;
  openFile;
  readFile;
  sortFile;
  writeFile;
  closeFile;
end.

Not too big to be confusing, not too small to tell nothing.

  • Like 2

Share this post


Link to post
Share on other sites
20 hours ago, Tursi said:

(That said, I see you are crediting being forced to do it with forcing discipline in your code. I guess I can appreciate that, but I still think your profs were silly. ;) )

 

Perhaps that is why there are academics and there are practitioners.  Academic rules tend not to do well in real-world applications, but the theory behind the rules informs thoughtful practice.

 

In revisiting their edict, it made me ask again why they laid it down in the first place.  I still choose to follow it as a rule because it costs me nothing... well, I now know that is not true, it costs me 5 bytes.  Fortunately, my code is an output of what is a purely academic exercise.  And following a main() call to a single procedure where my MVC logic resides doesn't impair readability.  It isn't that difficult to scroll up.  Even in the Pascal editor.  It's the next procedure up.

 

In UCSD Pascal, I am effectively a rookie programmer again.  I suspect that by making the call out of main(), I got to thinking about code structure and more quickly gravitated to the MVC pattern than I would have otherwise.  I never implemented MVC in Pascal (AFAIK the pattern post-dates my study of Pascal).  I probably would have ended up there, but I suspect this got me thinking about the structure of my code differently much sooner than I might have otherwise.  Don't know, but I'd like to think so.  

 

One of my goals is readability, so that future me can pick up where past me left off.  I'm sure you've all had the joy of picking up somebody else's code and cursing out a person or people you never met.  I wonder what the record is for percentage of a build that is ghost code?  Or for levels of nested IF statements?  When I picked up my work again recently after a long hiatus, I was pleasantly surprised that I had modularized the code and made it readable enough that I could pick it up again after a day.  There are no comments in the code.  I have a few automated unit tests.  The structure made it accessible.  

 

I hadn't thought about resource limitations of early computers as encouraging (if not mandating) use of global variables, and I can appreciate that.  I remember getting the 32k memory expansion on the TI and wondering what I could possibly fill up all that memory with?  And I did get to see first hand how resource abundance resulted in code bloat throughout the 80s and 90s.  Excess memory and faster CPUs covered up for a lot of coding sins.  No doubt I wrote code that benefited from the same, so I'm not throwing stones.  Since then, I've seen unnecessary abstractness (why have 3 levels of inheritance when 5 will do?) and all kinds of goldplating that increased the intellectual density without increasing the utility of the code.

 

I do aggressively refactor my code to reduce the number of statements, eliminate redundancies, create reusable functions and procedures.  I do like the eloquence of code density for efficiency.  So sure, a single statement in main() is a resource wasteful practice that at best was training wheels as I got back into programming.  And no doubt, the efficiency with which the code is executed in machine-level instructions is critical, especially in environments of limited resources like the TI.  Perhaps I do it because I write my code for me, and not for the machine.

 

Share this post


Link to post
Share on other sites
4 hours ago, Rossman said:

well, I now know that is not true, it costs me 5 bytes.

Words, not bytes. So ten bytes.

 

I still think this isn't too complex a main program. It's slightly more complex than the original, but more realistic.

program sortfile;

uses
  magic;

var
  fName: file of integer;

begin (* sortfile *)
  getFileName(fName);
  if openFile(fName) then
    readFile(fName);
    sortFile(fName);
    writeFile(fName);
    closeFile(fName)
  else
    writeln('ERROR - File not found';
  end;
end. (* sortfile *)

Provided the unit "magic" contains what is needed, it even kind of works.

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...

  • Recently Browsing   0 members

    No registered users viewing this page.

×
×
  • Create New...