Your Personal views on Satanism?N | Forum

Correction: no more bearing

Heh ;) Well, I was actually using analytical reasoning and you went or right on with it as if it were deductive. Meethinks you don't know the difference. 

"deduction and induction are additional examples of a duality and balance in nature."
Duality and balance in nature? Ah, so that's why I have two balls? Except... If there's deductive, inductive, analytical and a few others I'm aware but too lazy to write ... does that mean I supposed to have more that two balls? 

In all fairness, I know they're considered to be opposites of each other. But... I don't know, maybe it's me, but 'duality and balance in nature' sounda a bit like you've just reguritated something you've heard an occultist say without any real understanding of what you heard. Would you like some? I'll give you a couple of hints, even if you don't. From the occult perspective duality is an illusion and the fact we see duality where none really need exist is the problem. See systems thinking for more details. Oh, and dont mistake symmetry for duality. Starfish are symmetrical. Secondly, balance kills without a little wobble. For example, if you were in a pit of quicksand and the weight of the quicksand was perfectly 'balanced' to your strength -- this would have the predictable and certainly inevitable consequence of you being totally fucked. To get a different consequence, you need a third force -- someone throwing you a line or having a convient branch overhead.

"I have a degree in computer engineering among other degrees. I had to design a microprocessor back in the day and write an assembler for it. Your degree in C.S. or whatever has more bearing on the subject at hand than any of my degrees or whatever."

Sure... OK then, describe to me the structure of a half-adder and bit about how it works (in your own words, I will search for a source) and I'll believe you. And when was 'back in the day?' I go back to the 6502. Google Hartnell 6502 I'm sure there's got to be some rambling of mine about it left somewhere online. (Aw, fuck it. Here's the remains of a wiki where I was documenting the little bugger for fun https://6502.wikidot.com)

I'm not saying I'm better than you, I'm warning you that I can spot fakes and frankly challenging  you to put up or drop the pretense. Essentially, I'm calling you on your appeal to authortive knowledge (which ain't holdin' up so far)

"Yes, I've questioned this idea and just about every other idea that has ever been presented to me"
Uh huh. There's not enough time in anyone's life to do that. You're being presented with many more ideas than you probably recognize. How many ideas do you think came prepackaged in the last two  sentences? They don't come prepackaged with 'idea' stamped on them. Google 'presupposition'

What actually happens is you learn to listen to the structure of whatever's being said and you eventually learn overall structures and those tip you off as to whether it's worth examining. It's a system of heuristics. If you wanna get a handle on this sort of thing a great place to start is NLP's Meta Model and the endlessly fun Milton Model.

@ Shawn
Based upon our discussion ending prior to your attempt to turn this into a  C.S. dick waving contest there is more than sufficient information for a little intelligence to sort this out. As for a challenge, I'm just going to take the easy road and post my assembler minus my name and SS#. The processor was a Harvard Architecture with a dual phase clock implemented on an FPGA.

//
// Main.cxx
// Implementation file for an assembler for the basic computer
//
// Usage main (int  argc =4;) filename.bas
//
// unix main -f filename.bas or main 4 filename.as
//
// dos main /f filename.bas

/*****************************************************************************

  TODO:
        Clean up, unbloat, make a non hack,
        use same function for resolve inst
        and resolve label, put all instructions in
        array of sym_tab structures to make it easy
        to add instructions, write routine that
        resolves instruction from type to accommodate this
        i.e.
        if(inst < 0X7000)
            inst += resolve_label();
        else
            inst = inst;
       

        Figure out some way to tell between
        the hex number DEC and the type specifier DEC
        Perhaps use getline, but getline messes up
        input << variable_in_file; which is needed for
        numeric    computation of instructions.

*****************************************************************************/


#include <iostream>
#include <fstream>
#include <cstdlib>
#include <ctype.h>
#include <iomanip>


using namespace std;

// CONVENTION      typically upon succes bool functios wil return 0,
//                 failure results in a 1     


struct sym_tab{

char label[3];
int  val;
int  offset;
};

bool is_ws(char cursor);
//returns 1 if char is white space 0 otherwise

bool first_pass(char * argv[], sym_tab ad_syms[], sym_tab ob_sym[]);
//places address symbols in ad_syms sym_tab array

bool second_pass(char * argv[], sym_tab ad_sym[], sym_tab ob_sym[]);
//creates object symbol table

int resolve_label(char lab[3], sym_tab ad_sym[]);
//returns value of label

bool resolve_inst(char op[3], sym_tab ad_sym[], sym_tab ob_sym[],
                  int pos, ifstream &input);
//adds instruction to object table

bool store_ad_sym(char tmp[],int pos, sym_tab ad_sym[], sym_tab ob_sym[],
                  ifstream &input);

//stores address symbol in ad_syms sym_tab array

int get_address(sym_tab ad_sym[], sym_tab ob_sym[], ifstream &input);
// returns value of an addresses instruction

int MEMORY_BASE = 100;  //Memory above system memory if an ORG
                           //is less than this, it is added to the ORG
                           //and a warning is issued

int MEMORY_MAX = 2048;  //Highest memory location can't exceed me

int MAX_USED_MEM = MEMORY_MAX - MEMORY_BASE;
int ORG = MEMORY_BASE; //Default if no org line is specified in code
int LINE_COUNT;

//////////////////////////////////////////////////////////////////////////////

int main(int argc, char *argv[])
{

sym_tab ad_sym[1000];    // GNU allows [MAX_USED_MEMORY]
sym_tab ob_sym[1000];    // as long as predefined value    
                                        
if (first_pass(&argv[1], ad_sym, ob_sym))
    {
      cout << "Error making first pass, bailing out" << endl;
      return 1;
    }

if (second_pass(&argv[1], ad_sym, ob_sym))
    {
      cout << "Error making second pass, bailing out" << endl;
      return 1;
    }

  cout << "Address\t\t" << "Contents\n";
 
for (int i=1; i < LINE_COUNT; i++)           // Print table
  {
    if (ob_sym[i].offset == 0)
    i++;
  cout << "  " << hex << ob_sym[i].offset << "\t\t      "
       << hex << ob_sym[i].val << endl;
   }
 
  return 0;
}



//////////////////////////////////////////////////////////////////////////////

bool first_pass(char * argv[], sym_tab ad_sym[], sym_tab ob_sym[])

{
  int count = 0;
  char cursor = ' ';
  int offset = 0;
  char tmp[3];
  bool end=0;

  ifstream input;   
  input.open(argv[1],ios::in);

  if (input.fail())                  // Make sure file opens
    {
      cout << "Error opening input file" << endl;
      cout << "Usage: main -f filename" << endl;
      exit(1);
    }

      while (end == 0)                  //Stop at end
      {
        input.get(cursor);

        if ((tmp[0] == 'E')&&(tmp[1]=='N')&&(tmp[2]=='D'))
            end = 1;
                 
        else if (cursor == '\n')
           offset++;
             
        else if (cursor == ',')      //get values of label addresses
        {


            if (!(isalpha(tmp[1])))
            {
                ad_sym[offset].label[0]=tmp[2];
                ad_sym[offset].label[1]=' ';
                ad_sym[offset].label[2]=' ';
                tmp[0] = ' ', tmp[1] = ' ', tmp[2] = ' ';
            }   
            else if (!(isalpha(tmp[0])))
            {
                ad_sym[offset].label[0]=tmp[1];
                ad_sym[offset].label[1]=tmp[2];
                ad_sym[offset].label[2]=' ';
                tmp[0] = ' ', tmp[1] = ' ', tmp[2] = ' ';
            }
            else
            {
                ad_sym[offset].label[0]=tmp[0];
                ad_sym[offset].label[1]=tmp[1];
                ad_sym[offset].label[2]=tmp[2];
                tmp[0] = ' ', tmp[1] = ' ', tmp[2] = ' ';
            }
           
            store_ad_sym(tmp, offset, ad_sym, ob_sym, input);
           
        }
    
        else
        {
            tmp[0] = tmp[1];
            tmp[1] = tmp[2];
            tmp[2] = cursor;
        }
       
    }

      LINE_COUNT = offset;
      input.close();
      return 0;
}



/////////////////////////////////////////////////////////////////////////////


bool store_ad_sym(char tmp[], int pos, sym_tab ad_sym[], sym_tab ob_sym[],
                  ifstream &input)
{

  char cursor = '\t';
  char typ[3];
  char temp;
  long file_pos = 0;
   
    temp = input.peek();

    while (is_ws(temp))
      {
        input.get(cursor);
        temp = input.peek();
      }

    temp = input.peek();

    if (temp == 'H')
        {
        input.get(cursor);
        typ[0] = cursor;
        input.get(cursor);
        typ[1] = cursor;
        input.get(cursor);
        typ[3] = cursor;

        }

    if (temp == 'D')
        {
        file_pos = input.tellg();
        input.get(cursor);
        typ[0] = cursor;
        input.get(cursor);
        typ[1] = cursor;
        input.get(cursor);
        typ[2] = cursor;

        if ((typ[1]=='E')&&(typ[2]=='C'))
            {
            input.get(cursor);
            input >> dec >> ad_sym[pos].val;
            ob_sym[pos].val = ad_sym[pos].val;
            }
        else
            {
            input.seekg(file_pos);
            input >> hex >> ad_sym[pos].val;    
            ob_sym[pos].val = ad_sym[pos].val; 

            }
        }
    else
       {
        temp = input.peek();

        while (is_ws(temp))
            {
            input.get(cursor);
            temp = input.peek();
            }

        input >> hex >> ad_sym[pos].val;    
        ob_sym[pos].val = ad_sym[pos].val; 
      }

    ad_sym[pos].offset = pos;

    return 0;

}

///////////////////////////////////////////////////////////////////////////////

bool is_ws(char cursor)
{
  bool WS;

  if((cursor != '\t')&&(cursor != ' ')&&(cursor != '\n'))
          {
                   WS=0;
          }
      
        else
          {
          WS=1;
       
          }
  return WS;
}

/////////////////////////////////////////////////////////////////////////////

bool second_pass(char * argv[], sym_tab ad_sym[], sym_tab ob_sym[])

{
  int count = 0;
  char cursor;
  int offset = 0;
  char tmp[3];
  bool end = 0;

  tmp[0] = ' ';
  tmp[1] = ' ';
  tmp[2] = ' ';

  ifstream input;   
  input.open(argv[1],ios::in);

  if (input.fail())
    {
      cout << "Error opening input file" << endl;
      cout << "Usage: main -f filename" << endl;
      exit(1);
    }

      while (end == 0)
      {
      
        input.get(cursor);
        if ((tmp[0] == 'E')&&(tmp[1]=='N')&&(tmp[2]=='D'))
            {
              end = 1;
            }

        else if ((int(cursor) == 0x2F) || (cursor == ','))
            {
                while (cursor != '\n')
                    {
                        input.get(cursor);
                        tmp[0] = tmp[1];
                        tmp[1] = tmp[2];
                        tmp[2] = cursor;
                    }
                offset++;
            }      // skip to next line if comment or label or CR
                 
                       
        else if ((is_ws(cursor)) && !(is_ws(tmp[2])))
          {
                          
             if (resolve_inst(tmp, ad_sym, ob_sym, offset, input))
                {
                  cout << "Error reolving instruction at line: "
                       << offset << endl;
                  return 1;
                }

            tmp[0] = tmp[1];
            tmp[1] = tmp[2];
            tmp[2] = cursor;
            offset++;
          }

        else if (cursor == '\n')
            offset++;


        else
          {
            tmp[0] = tmp[1];
            tmp[1] = tmp[2];
            tmp[2] = cursor;
           }
      }
      input.close();
      return 0;
}

///////////////////////////////////////////////////////////////////////////////

bool resolve_inst(char op[3], sym_tab ad_sym[], sym_tab ob_sym[],
                  int pos, ifstream &input)

{

  int org = ORG;          //if no org is given start at base
  int eff_address = 0;
  long file_pos = 0;
  char cursor = 'a';
  char tmp = 'a';
  char snoop;

  if ((op[0] == 'O') && (op[1] == 'R') && (op[2] == 'G'))
      {
       
        input >> hex >> org;
        ORG = org-1;
              
        if (org < 0)
          {
            cout << "Error resolving address at line: "
                 << pos << endl;
            return 1;
          }
        return 0;

      }

    else if ((op[0] == 'L') && (op[1] == 'D') && (op[2] == 'A'))
      {
         eff_address = get_address(ad_sym, ob_sym, input);

         if (eff_address < 0)
          {
            cout << "Error resolving address at line: "
                 << pos << endl;
            return 1;
          }

         ob_sym[pos-1].val = 0x2000 + eff_address;
         ob_sym[pos-1].offset = org + pos -1;      
         return 0;
      }

    else if ((op[0] == 'C') && (op[1] == 'M') && (op[2] == 'A'))
      {
        snoop = input.peek();
         while (is_ws(snoop))
        {
            input.get(cursor);
            snoop = input.peek();

        }
         
         ob_sym[pos-1].val = 0x7200;
         ob_sym[pos-1].offset = org + pos - 1;
         return 0;
      }

    else if ((op[0] == 'I') && (op[1] == 'N') && (op[2] == 'C'))
      {
        snoop = input.peek();
         while (is_ws(snoop))
        {
        input.get(cursor);
        snoop = input.peek();

        }
         ob_sym[pos-1].val = 0x7020;
         ob_sym[pos-1].offset = org + pos -1;
         return 0;
      }

    else if ((op[0] == 'A') && (op[1] == 'D') && (op[2] == 'D'))
      {
         eff_address = get_address(ad_sym, ob_sym, input);

         if (eff_address < 0)
          {
            cout << "Error resolving address at line: "
                 << pos << endl;
            return 1;
          }

         ob_sym[pos-1].val = 0x1000 + eff_address;
         ob_sym[pos-1].offset = org + pos - 1;
         return 0;
      }

    else if ((op[0] == 'S') && (op[1] == 'T') && (op[2] == 'A'))
      {
         eff_address = get_address(ad_sym, ob_sym, input);

         if (eff_address < 0)
          {
            cout << "Error resolving address at line: "
                 << pos << endl;
            return 1;
          }

         ob_sym[pos-1].val = 0x3000 + eff_address;
         ob_sym[pos-1].offset = org + pos -1;
         return 0;
      }

    else if ((op[0] == 'H') && (op[1] == 'L') && (op[2] == 'T'))
      {
        snoop = input.peek();
         while (is_ws(snoop))
        {
        input.get(cursor);
        snoop = input.peek();

        }
         ob_sym[pos-1].val = 0x7001;
         ob_sym[pos-1].offset = org + pos -1;
         return 0;
      }

    else
      {
        return 1;
      }
  return 0; //to make compiler happy :)
}

///////////////////////////////////////////////////////////////////////////////

int get_address(sym_tab ad_sym[], sym_tab ob_sym[], ifstream &input)

{
  char cursor;
  char tmp[3];
  char snoop;
  int address;
  int count = 0;
  bool its_alpha = 0;
  snoop = input.peek();

 while (is_ws(snoop))
    {
      input.get(cursor);
      snoop = input.peek();

    }


    
  if (isalpha(snoop))
    {
    input.get(cursor);
        while(!(is_ws(cursor)) && (count<3))
        {
            tmp[count] = cursor;
            count++;
            input.get(cursor);
        }
        while(count < 3)
        {
            tmp[count] = ' ';
            count++;
        }

        address = resolve_label(tmp, ad_sym);
        ob_sym[address - ORG].offset = address;
       
      if (address < 0)
        return -1;

      else
        return address;
    }
  else
    {
      input >> hex >> address;
     
      if (address < 0x1000)
        return address;
     
      else
        return -1;
    }

}

///////////////////////////////////////////////////////////////////////////////

int resolve_label(char lab[3], sym_tab ad_sym[])

{

    for (int i=0; i < 1000; i++)
    {
      if ((lab[0] == ad_sym[i].label[0]) &&
          (lab[1] == ad_sym[i].label[1]) &&
          (lab[2] == ad_sym[i].label[2]))

          {
            return i + ORG;
          } // end of if

    }
    return -1;
}

I didn't ask for that. I asked for simple explanation of a half-adder and a bit about how it works -- in your own words.. That's not dick waving -- that's super simple! You can't design a processoe without one! 

There's code repositories all over the place where the code isn't searchable by Google. Nice of you to have this code since you wrote it so long ago, 'back in the day.' Alright, I get the gist. If you can't so something REALLY AMAZINGLY simple like describing a half adder -- then I offer a second challenge -- comment your code. (THIS code is strangely lacking the comments one would expect to turn in as an assignment.) 

The assembler ran on a PC and simply converted the assembly code into a hex file which could be loaded onto a ROM chip and accessed from the FPGA board. The microprocessor itself was implemented using logic gates with some ancient Xillinx software which I can no longer run. Version 4 something.
Your original half adder question was bullshit because I imagine there are hundreds of websites where one can find the boolean expression for a half adder. A more intelligent question would have been say, find the canonical SOP form for some arbitrary truth table which you would have provided. That would have been sufficiently unique that one couldn't just go online and get the answer. This code cannot be found anywhere else, except perhaps on a hard drive on some computer discarded by a university long ago so it's unique. But hey, now that we're engaged in C.S. nerd dick waving, seems at least you could have came up with an intelligent question. Though I suspect your original goal of directing people completely away from the issue we were debating has been fulfilled. I don't need to prove anything, my arguments stand on there own ground for anyone to read.
Goodnight.

"I imagine there are hundreds of websites where one can find the boolean expression for a half adder."

It's a set of logic gates dumbass. I'm done.

@ Shawn You sound like a technician, experts represent logic with boolean expressions and then implement it with logic gates.
In Canonical form:
Sum = (!A&B) !! (A&!B), or an XOR gate for the boolean challenged.
Carry = A&B

@Beavery: Yeah, ok, I'll take that. Respect.

Math nurd, right? ;)

@Frater: define science

The 11 Satanic Rules of the Earth are not dogmas, they're simple rules-of-thumb. Where in the Satanic Bible does it say "Thou shalt be stupid and follow my word absolutely, especially the 11 rules!"

If someone thinks that they're absolutes and follows them as if they were absolute, so what? Some people are stupid and use things in ways not intended by the inventor. The "use as directed" warning is printed on thousands of products for a reason.

Uh... The Satanic Bible? From The Book of Satan, right in the front of the book:

"2. Open your eyes that you may see, Oh men of mildewed minds, and listen to me ye bewildered millions!

3. For I stand forth to challenge the wisdom of the world; to interrogate the "laws" of man and of "God"!

4. I request reason for your golden rule and ask the why and wherefore of your ten commandments.

5. Before none of your printed idols do I bend in acquiescence, and he who saith "thou shalt" to me is my mortal foe!

6. I dip my forefinger in the watery blood of your impotent mad redeemer, and write over his thorn-torn brow: The TRUE prince of evil - the king of slaves!

7. No hoary falsehood shall be a truth to me; no stifling dogma shall encramp my pen!

8. I break away from all conventions that do not lead to my earthly success and happiness."

This kind of skepticism also applies to Satanism is obvious to me, from the above. But LaVey didn't stop there. There's this gem from the 9 Satanic Statements:

"Satanism represents undefiled wisdom instead of hypocritical self-deceit!"

Auchtung!!  The No.1 Satanic noob error is failing to apply Satanism to itself.

Heh. You win. ;)

To be frank I just gave up. You're asking me to be a mind reader. No, I don't have mystical psychic powers that would allow me answer your question. 

Yes, I've tried to 'get in LaVey's head' and think I'm fairly accurate about what he was up to with Satanism  given a lot of things he says, especially when he's given to be striaghtforward about it: https://www.churchofsatan.com/...owerful-religion.php . Even so, I'm not 100% sure that 100% of everything I think about LaVey and his reasons. So, what I'm about to tell you is both a highly educated guess and an opinion I'm fairly confident about -- but hey, I didn't know LaVey and he's not around to ask questions anymore. Do you get that?

As to why he included "undefiled wisdom instead of hypocritical self-deciet" as one of the Satanic Statements, let me start by quoting two others:

Responsibility to the responsible instead of psychic vampires.

Satan is the best friend the church has ever had, and has kept it in business all these years.

There's this quirk in human psychology where someone projects onto other people responsibility for their own behavior, make it someone else's fault, and blame them entirely. It's all about NOT taking responsibility for their own life and accepting the consequences of their own actions. In short, they're self-righteous hypocrites who always blame the other guy and never accept responsibility for anything.

So, in writing those statements, he was making that quirk explicit and offering a clue to get out of the hypocrisy trap. Think about it: hypocrisy is what defiles wisdom. Another way to put it is "you don't know shit unless you can smell your own shit."

It may surprise you to know that LaVey's on record saying that some Christians were already Satanic but didn't call themselves that. He was well aware that Jesus and Satan agree more than most people realize and that the real problem is the self-righteous hypocrisy of the adherents -- not the religion itself.  Notice he says that Satan is the best friend the CHURCH has ever had, not the religion.

Here's Jeezer himself on the subject: 

Matthew 7:5You hypocrite, first take the plank out of your own eye, and then you will see clearly to remove the speck from your brother's eye.

Luke 6:41"Why do you look at the speck of sawdust in your brother's eye and pay no attention to the plank in your own eye?

And here it is echoed in an epistle: 

Romans 2:1You, therefore, have no excuse, you who pass judgment on someone else, for at whatever point you judge another, you are condemning yourself, because you who pass judgment do the same things.

This from Burton Wolfe's introduction to the Satanic Bible:

"Anton LaVey, called “The Black Pope” by some of his followers, realized that two decades ago when he was playing organ for carnival sideshows. “On Saturday night,” he recalls, “I would see men lusting after half-naked girls dancing at the carnival, and on Sunday morning when I was playing the organ for tent-show evangelists at the other end of the carnival lot, I would see these same men sitting in the pews with their wives and children, asking God to forgive them and purge them of carnal desires. And the next Saturday night they’d be back at the carnival or some other place of indulgence. I knew then that the Christian church thrives on hypocrisy, and that man’s carnal nature will out no matter how much it is purged or scourged by any white light religion.”

Note again that the church is specified, not the religion. The 'scourging by white light religion' is basically a process of shaming which causes denial, repression, and projection. (See Freud's ego defense mechanisms) This happens at church, and by people who go to church to people who don't go to church. Well, some churches. I admit that. Most of them are dens of self-righteous hypocrites, but not all. Some of them are more to the gnostic side, but they're the minority, and generally are cool peoples.

Another point I think is misunderstood is that LaVey's issue isn't that the church brainwashes people, but rather, causes repression and self-loathing. They turn against themselves. (Jeezer: A house turned against itself won't stand.) It's a condition like being ravenously hungry but thinking all food is poison. You know that bit about indulgence instead of abstinence without compulsion? What about the bit about the Seven Deadly sins? Making sense yet?

Who said I followed LaVeys philosophy and who the fuck are you to determine if I 'fail' as a Satanist? WTF does that even mean? Get real.

What difference would it make if he was or wasn'r a Satanist before starting the CoC? 

You consistently abuse the term you use: free thinking. You don't think. You choose from options handed to you. You regurgitate the most banal arguments which I've heard a thousand rimes befoe and will a thousand times since.

Mind reading is an NLP meta-model violation:

"Mind Reading occurs when someone assumes they know what another person is thinking or feeling without direct evidence.  Mind Reading can be recognized when someone claims to know something without obvious evidence, claims to know how another person feels, or claims to understand another person’s internal state without explanation. It is the assumptions that are made about another persons thoughts or opinions, without the other person specifying it."

It wouldn't surprise me if this goes right over your head even when explained well -- as it went sailing over your head so effortlessly the first time. 

K.

If you quote something make sure you are not typing in the highlighted quote box... or it looks like the comment above me.