Behold the interloper...

    A cycle of system nuisances are beginning to increase.  These are good signs however.  As predictably noticeable as to be expected when system viruses scanning is turned off in windows likely for one bit of clicking on something somewhere.  I'd mention that this need not be with respect to anything of the less than trustworthy path.  For instance, not using suspect software, or being a torrents offender, and generally restricting this to par for the course stuff.  The increased probability and likelihood of contracting some internet based infection these days are a large problem, and the likely source instituting something of mandatory quarantine one should imagine.  

A most recent episode...

 Turning virus scanning off, disabling windows updates.   More likely than not, its simply to let someone that might be paying attention to these, for most, trivialities that they are there.  This is to see what you might do or say, it could be retributive.  If it flows along the lines asinine or juvenile, it usually takes the course of something more silly obnoxious...like clicking on the errant Der Spiegel article about the NSA one too many times which leads to any number of windows system sounds being toggled and making a tethered tablet go haywire.  Pretty common one.  The duration of this could be anywhere from several days or a lengthier time until some time window has elapsed (that I've seen), or a system nuke attempts to reconcile such issue, if your hardware weren't permanently doomed one should imagine.

Its pretty easy to speculate on the intrinsic role of a given nuisance on a system, whether it might be to harass a user on a system, or given to the nature of expressing control or any manner of dominance on a given system.  The more obvious extreme cases of rendering a system to the extent of being unusable it would seem are likely not the objectives of anyone engaged in a bit of snooping, or as in my experience, making it obvious on some point being there, or at least semi obvious is simply a matter of letting the user know it is so, and traditionally the stance could be on the motivation of provoking a given reaction (obviously this writing, for instance, is an example).  One might add, over the course of time, that these sorts of light provocations are less likely to lead to the same sets of reactions.  More than likely, it would seem social conditioning to such a presence makes for anything that were not outside of typified usage patterns, or that one having engaged in exactly the same sets of behaviors as before without significant alterations simply points either to some inherent experience to such condition, this leading neither to any change in usage patterns or revealing anything furthered, may lead to a condition of re instating the role and service that such user might expect...being that, for instance, the red button goes off on a daily basis as expected, or the machine that goes 'bing' as one should hope does exactly that.

Some considerations for periodic testings at varying levels.

Testing to see, if you are willing to engage in a personal algorithm for disarming the interloper...that is to see what tactics you might engage in removing a given presence, could be smarts testing...I don't have so much interests here in this realm at all, or more commonly fit into one profile but not the most general profile of all...that is between do nothing ism or having installed some anti viral software that doesn't do at all what it claims to do, at least not being owned and designed around the largest likely interloping offenders.

The lead up to all of this on the creativity side...having perused an employment add for a computer vision (image processing) related job for the National Institute of Health, or alternately, if in proximity, related to any particular twitter hashtag, although its hard in measuring timeliness for some potential matter of speculation.

A status quo, I might add has led to such a customary condition arising with greater frequency than other socially exchanged ailments, or this is to say if an issue of 'bin' were a problem, than the frequency of social exchange of the common cold should only drive home what only need be furnished in so far as surveillance as evidence, but fortunately civilizations dropped these sorts of medievalists some time ago?!  I must say though I do feel as though I exist in quarantine for a condition that I hadn't deserved...adding that for the many years spent, it seems my ideas must still be infectious or at least dangerous enough?!  Although it seems more than likely, given to the customary status quo, if a propagandist hadn't shown up conveniently at your door step with papers in hand ready to counter such an illness, there were always the matter of ignoring, or suggesting in varying ways the ill logic of the condition itself.    A recent Halloween telling of Through the Wormhole and Zombie Apocalypse were given to the same presence of the mindless illness that must exist in all of us.  To this extent forgoing the hippocratic oath, I am not sure how much this were to the extent of reflexive conditioning...if it weren't only part of some fictionalizing the role and nature of behavior.  Apparently re chorusing the narrative if it hadn't already seemed over worked to any sense of decency, little explanation is given for any derived model, or merely served to some ideological presence itself, which is to say there is amply little reason to believe much here in the existential ordering of things.  Rabies, or encephalitis, meningitis, or any number of potentially neurologically impairing contagions tend not only to be rarer in their own right, but that they also represent more often than not weaker points in the food chain for social host re productivity, not stronger points, and thus while primal manifestations of uncontrollable rage, for the sake of Holly wood films, in this regard may not in reality be great for social transmission relative to other causal mechanisms.  Or if the trick is better done through an airborne transmission, there is all the likelihood that evolutionary resources are spent bettering the cough as opposed to bettering the primal rage craze.  Maybe the ant, has specifically dedicated neuro pathway channels mostly consistent from generation of one off spring to the next which control, for instance, the ant's given desire not only to climb but also forage on a leaf, unlikely one is to wonder that any specific channels or pathways for human behavior are one and the same...or this is to say evolution of this sort is not only rarer, I would expect, but exceptionally rare in possibility, that is, unlikely one might find specific tasking type behaviors, unless the little bug were actually more intelligent in design, other than say handing down some simpler orders of tasks...in the computing world truly decoding tasks would amount, not only to figuring out the desired tasks for certain operations but I believe handling this in a relational manner which, for higher order functioning, something of feedback testing a system for response signals...I'd say pretty crazy to believe that a virus could do these sorts of things without having some inset intelligent design  outside of natural evolutionary forces that might otherwise be involved.  Obviously, one looks at the zombie gait, and it just doesn't bode as well either for locomotive transmission, consider that a normal walking gait, is more likely to spread things faster than a disabled one, for instance, so truly your zombie might actually look like you or I.  Thus while it is not always true in the evolutionary sense that something better is always the  optimal course for evolution, but that ample enough existential space exists for something to propagate, it seems that statistical advantage could still be awarded to the attack of the fast breeder/fast propagator in principle, if the infection is noticeably perilous not only to host, but having made itself known to the intelligence of a greater society that has aided in the evolution of such crowd contagion in the first place, or the fast breeding zombification could look like something on steroids...but I wonder if burning the car metaphorically speaking of gas, too quickly too soon, is also just not as advantageous?!  This being said, I don't know that I'd bank on the zombie super flu anytime soon.

  I don't know that one could always also characterize evolution by way of arms race, or at least this is not characteristically necessary at all in adaptation.  As in most taxonomy, it seems any number of viruses, one should imagine, statistically more likely benign, or finding ways to populate a host without killing and then assuming potentially it were immune response, secondary infections or anything else in the added process that did us in...hmm...sort of leads me back to the interloper...we are only lucky to be infected and made known that we are being infected in the most obnoxious ways?!    This leads to the inset logic that system killers are just not so common in the computing world...and the likely reasons are that well the FBI and the NSA like their host systems living, alongside most hacks...they want to accrue data, not extinguish it outright, at least for most this logic it seems should be true, and thus, I am wondering maybe semi convincing myself that there are parallels between biological and digital viruses.

Search and Seizure, Electronic versus Non Electronic forms

   Recent articles and officially FBI having confirmed as of recently that a 'faked' web site were used in a phishing scam to gain access to teen suspect's computer, only adds to potential concern on the matter of search and seizure of data/information or what one could term as intellectual property on a privately owned machine.

   I think the biggest problems surrounding the use of viral mechanism to gain entry into a form of private residence is that likely one should imagine the structure of logic involved in the search of such property.  Here if one were to think of a given case, which actually related an issue concerning the warranted search of a home based upon a described 'reasonable' suspicion that because a known suspect's car were in proximity to a known possible address, this should necessarily entail reasonable cause for searching the property by law enforcement, or loose implicit assumptions being that  reasonably a suspect were likely in a home, however, neither owing to any additional evidence of being on such property.  As it turns it this weren't allegedly enough cause for a warranted search of the property for such individual.  More reasonably, you think of this in the context, of say for instance, a known suspect that has an arrest warrant for traffic violations, and local law enforcement irrespective of all other non offending occupants of the home are given to any persistent level of harassment by law enforcement concerning search of a given property at the whims of law enforcement.

   The bigger problem with electronic surveillance and warranting of say wiretaps or searching electronic domains are that legal definitions may not be defined exactly one and the same?  And here in the bigger problem.  If this model were given to the traditional mode of a warranting process and property search, likely the FBI's case would be thrown out in a flash, or at least any evidence gathered in such process would not be considered acceptable given the means and methods used in conducting the search.  On the other hand, local law enforcement and federal agencies may have found loop hole methods for entry into private homes...the problems here are that phishing scams could be employed in less than specifically targeted ways, imagine a potential case generates local attention to the extent of garnering the interest of any number of residents that are equally innocent on the matter of potential threat but having been subject to search electronic residential searches.  Obviously to sift through any number of systems to reach the conclusion that any one resident were guilty, would strike in the traditional warranting system for searches as bad constitutionally speaking.  But in a electronic search, apparently this appears to be potentially weaker?  Secondly even if a potential suspect's computer were targeted specifically meaning that no other computer were sifted for information, what reasonable cause for search existed in the first place?  Here it is hard to imagine that a fake article's content would provide ample reasonable cause, or at least alone that something other would need be furnished in justifying the cause for search of such computer...at least I would be interested in hearing the supposedly justifiable reasons given.

   This also raises another point concerning why I believe at times culture remains in some ways more apathetic relative to another potential outcomes if conditions were strikingly different.  If in a tangible way, for instance, any household were more likely subject to and/or having known someone having been subject to more frequent search and seizure in the obvious sense, would likely lead to general outcomes of populations being less ambivalent concerning the matter of property searches, or this leading one could imagine to a greater degree of anger and distrust of ruling institutions and/or related law enforcement bodies.  On the other hand, because electronic searches appear to be in some ways so non invasive to most persons, in the absence of any tools that would aid in identifying a breach of residence, we are less accustomed to thinking that our private and personal data could be compromised.  This inherent problem I believe had led to a culture of relaxation and increased permission concerning the acceptability of a form of property search, or that as decades of technological adoptions have existed, and so to the permission given over time for any given search of private data, culture hasn't related perhaps as strongly to the clear and present danger of insecurities of privacy in general.  Obviously if we feel inconvenienced less in the obvious context of a search of personal data we think less of a given intrusion.  On the other hand, there may be potential increased cause for concern regarding private data and the loopholes having been created in exploiting searches for whatever cause supposedly legal or not legal at all.  We have seen the potential for such exploitation, for instance, in the sorts of surveillance tools developed by and for law enforcement agencies that end up in the hands of individuals that aren't involved in law enforcement, or to say the least have not only nothing of justifiable cause for searching and stealing private data, but in another way is tantamount to the outright criminal behavior similar to theft or burglary.  Interestingly in this present age, I haven't heard so much the outrage or anger provoked when data has been stolen say, for instance, most recently when allegedly private intrusion into a reporter's system were simultaneously used in public context for revealing supposedly salacious or compromising details regarding existing relations between such reporter and the subject matter that the reporter were writing about...as it turns out these accusations by likely thieves were all erroneous and badly co opted in the first place, but nothing of the private intrusion were really called upon in such process for what appeared to be nothing more than a bad burglary in a #gamergate sick phishing expedition.  The same would also be true with respect to the seizure of private emails of a top climate science expert that would supposedly call into question the climate science movement.  As it turns out, again the seizure of private data not only failed to yield the death knell of a movement, but also leaves something of a troubling legacy behind the seizure of private data and who is doing it, coupling this to a culture that seems more reticent to question such behavior if only having been conditioned socially to growth in such behavior.  Obviously in this day and age, a tangible and troubling prospect concerning the matter of privacy seems in some ways to reflect that we are more likely accustomed to listening to the presentation of arguments given by those engaged in so much the ill warranted process that we supposedly had traditions in safe guarding a society against.  The root cause of problems in procedural handling in the search and seizure of data, could have a basis in the process that we have identified leading to the cause for seizure.  Obviously we wouldn't like it if our society were given to the arbitrary whims of fault finding when there is likely and most likely none, given to those in power to arbitrarily decide what is right and wrong for us.  If we could less likely do our jobs well enough in finding fault, perhaps, we might in some other context be fired from our jobs for the sake of accountability to say the least as a bad crooked and corrupt investigator.

Personally in more tangible ways, if having understood concerns on the matter of privacy, when we find that if and when are privacy were being used in less benign and more malicious ways, as in the case of social harassment, the inability to find work/employment, friendships, increased social isolation, and/or any number of factors that effect how we are able to function as individuals in a given society, obviously the ill effects of loss in privacy could be more amply understood.  On the other hand, just because we are conditioned in knowing what someone else is doing, apparently likewise may not be leading to furthered social tolerances, or that dare we say, articles are published relating at times to those engaged in victimizing as opposed to those victimized.  
  

C sharp to Python translator example script

This isn't robustly written for pattern matching as a C sharp to Python translator but at least it provides a somewhat easier method for porting code with literal translation.  I manage to do this by the way through a combination of things, but some key points are some translator dictionary terms

instantiationkeywords  

-  A string match on these word terms means that list type is provided from a given c sharp array type to a python list type.  In python lists may commonly be grown or shrunk through a populate or remove functions, but I opted for the method of instantiating a fixed list type matching a given array.  

defheaderwords

-or type (e.g., int is integer type, double is double type, and so forth) , there is also another layer (redundant) in matching a given type whether it falls into a python list type of specific multidimensional allotment or not a list at all.  This type list can be customized for pattern matching on keywords, by simply populating added type words with translation data.

This may still have some bugs, although I've done some testing up to now...I haven't scoured this to remove much of deprecated stuff, but at least it appears to be functioning fairly well. 

class conversionCsharptopython:
    classscope = False
    classfuncscope = False
    casescope = False
    casevalues = []
    casevar = ''
    caseenditer = 0
    caseiter = 0
    classfuncscopeintervalleft = []
    classfuncscopeintervalright = []
    classname = ''
    indentlevel = 0
    classfuncnames = {}
    classfuncnames_rev = {}
    classvars = {}
    classfuncvars = {}
    classscopecounter = []
    var = []
    linescope = {}
    writenextlineclosuref = False
    classfuncwords = ['public','private']
    keywords = ['Debug.Log','break', 'Console.Write','return','//',
                'new','.ToArray()','DenseVector.OfArray(',
                'DenseMatrix.CreateDiagonal(','.Length]',
                '(int)','(double)', '(float)']
    keywordinterpret = {'.ToArray()':'.tolist()', '.ToArray ()':'.tolist()',
                        'DenseVector.OfArray(':'numpy.matrix(',
                        'DenseMatrix.CreateDiagonal(':'numpy.matrix(',
                        'Console.Write':'print','Debug.Log':'print',
                        '//':'##', '(int)':'', '(double)':'', '(float)':'',
                        '.PI':'.pi','Math':'math','true':'True',
                        'false':'False', ';':'', 'Sin':'sin','Cos':'cos',
                        'Tan':'tan','AssetDatabase':'##AssetDatabase'}
    instantiationkeywords = {'new Vector[':'Vector[','new findter(':'findter.findter(',
                             'new Boundaryedges(':'Boundaryedges.Boundaryedges(',
                             'new float[':'float[',
                             'new computetranslations(':'Computetranslations.computetranslations(',
                             'new computetranslationsgroup(':'Computetranslationsgroup.computetranslationsgroup(',
                             'new int[':'int[',
                             'new linearalgpckg.pointsrescale (':'linearalgpckg.pointrescale (',
                             'new AssemblyCSharp.computetranslations': 'Computetranslations.computetranslations',
                             'new Vector3 (':'mathutils.Vector([',
                             'new Vector3(':'mathutils.Vector([',
                             'new LoadHeightmap(':'LoadHeightmap.LoadHeightmap(',
                             'new double[':'double['
                             }
    ##these are defined types.  This list likely expands.
    defheaderwords = {'int':'single','float':'single','int[]':'list', 'int[ ]':'list',
                      'int[,]':'2dlists','int[':'sr','float[]':'list','float[,]':'2dlists',
                      'float [,]':'2dlists','int [,]':'2dlists',
                      'double [,]':'2dlists',
                      'float[,] ':'2dlists','Matrix':'matrix',
                      'Matrix[]':'list',
                      'Matrix[,]':'2dlist',
                      'float[][]':'2dlist','float[][,]':'3dlist',
                      'Vector':'matrix',
                      'Vector[]':'list','Vector[][]':'2dlist',
                      'double':'single',
                      'double[]':'list','double[][]':'2dlist',
                      'double[,]':'2dlists','bool':'single', 'Boundaryedges':'single', 'findter':'single',
                      'computetranslationsgroup':'single', 'computetranslations':'single', 'int[][]':'2dlist'}
    falseequiv = ['(int)','(double)','(float)', 'checkpoints', 'point', 'checkpoint']
    
    ##arraylist = {'int[]':1, 'int[,]':2, '':}

    def __doublelistinit(self, lefteqtokens, listlenstring):
        returnstring += lefteqtokens
        returnstring += '='
        returnstring += 'Initialize.initalize.doublelist(listlenstring)'
        return returnstring

    def __intlistinit(self,lefteqtokens, listlenstring):
        returnstring += lefteqtokens
        returnstring += '='
        returnstring += 'Initialize.initalize.intlist(listlenstring)'
        return returnstring

    def __matrixinit(self,lefteqtokens, matrixdatvarstring):
        returnstring += lefteqtokens
        returnstring += '='
        returnstring += 'numpy.matrix('
        returnstring += matrixdatvarstring
        returnstring += ')'

    def replacekeyword(self, stringline):
        for word in self.keywordinterpret:
            if word in stringline:
                stringline = stringline.replace(word,self.keywordinterpret[word])
        return stringline

    def deftype(self, stringline):

        if '[]' in stringline:
            if '[][,]' in stringline:
                return '3dlist'
            elif '[][]' in stringline:
                return '2dlist'
            else:
                return 'list'
        elif '[,]' in stringline:
            return '2dlist'
        else:
            return 'single'

    def getsetclosure(self, sep, sepc, stringline):
        sepcount = 0
        sepccount = 0
        line = 0
        indexr = 0
        for char in stringline:
            if char == sep:
                sepcount += 1
                
            if char == sepc:
                if sepcount == 0:
                    print('found')
                    
                    indexr = line
                    break
                else:
                    sepcount -= 1
            line += 1
        return stringline[0:indexr]

    def getsetclosure2(self, sep, sepc, stringline):
        # this assumes set closure is found at its first instance sep pairing which is included in the string search
        sepcount = 0
        sepccount = 0
        line = 0
        indexl = 0
        indexr = 0
        for char in stringline:
            if char == sep:
                if sepcount == 0:
                    indexl = line
                    sepcount += 1
                else:
                    sepcount += 1
                
            if char == sepc:
                if sepcount == 1:
                    print('found')
                    
                    indexr = line
                    break
                else:
                    sepcount -= 1
            line += 1
        return stringline[indexl+1:indexr]
    
    def writenextlineclosure(self, stringline):
        self.writenextlineclosuref = False
        return self.getsetclosure('[', ']', stringline) +')'

    def instantiationcheck(self,stringline, itera):
        #problems between c sharp and python, are that one would likely
        #want class level object types instantiated at the outset in python
        #whereas class object type variables maybe instantiated later
        #.  The solution is to initialize a variable with some arbitrary
        # value that fits necessary operable conditions.  Easy if we
        # are working with non array types.  More difficult otherwise.
        # Can you think why?  Obviously, array type objects may not
        # be instanced with any defining array length, so we'd need to fish
        # out this information in the body of the program.  So we'll need
        # to define special instancing rules and search algorithms to aid
        # us.
        instantstring = ''
        iterm = -1
        maxcount = 0
        wordflag = False
        for word in self.instantiationkeywords:
            if word in stringline:
                maxcount = 0
                iterm = -1
                count = 0
                wordflag = True
                for word2 in self.defheaderwords:
                    if word2 in stringline:
##                        print('stringline at word2 match:')
##                        print(word2)
##                        print(stringline)
                        check = False
                        for word3 in self.falseequiv:
                            if word3 in stringline:
                                if not stringline.find(word2)-1 == stringline.find(word3):
                                    check = True
                                else:
                                    check = False
                                    break
                            else:
                                check = True
                        if check:
                            if len(word2) > maxcount:
                                maxcount = len(word2)
                                iterm = word2
                                iword = word
                break
            
        if not iterm == -1 and wordflag:
            ocheck, varname, matchtype = self.checkreturnvar(stringline)
            if '//' in stringline:
                print('at // check:')
                print(stringline)
                print(varname)
                if stringline.index('//') < stringline.index(varname):
                    instantstring += '##'
            instantstring += self.getspacing2(itera)
            print('variable name:')
            print(varname)
            instantstring += varname
            instantstring += ' = '
##            print(word2)
##            print(iterm)
            if self.defheaderwords[iterm] == 'list':
                rightval = stringline.split(iword)[1]
                print('rightval:')
                print(rightval)
                val = self.getsetclosure('[', ']', rightval)
##                val = rightval.split(']')[0]
                try:  int(val); c = True                
                except: None; c = False
                instantstring += 'Initialize.initalize.list('+val+')'
                print('instantiation with new list: ')
                print(instantstring)
                self.writefileline (instantstring)
                return True
            elif self.defheaderwords[iterm] == '2dlist':
                rightval = stringline.split(iword)[1]
                val = self.getsetclosure('[', ']', rightval)
##                val = rightval.split(']')[0]
                instantstring += 'Initialize.initalize.2dlist('+val+')'
                print('instantiation with new 2dlist: ')
                print(instantstring)
                self.writefileline (instantstring)
                return True
            elif self.defheaderwords[iterm] == '2dlists':
                rightval = stringline.split(iword)[1]
##                val = rightval.split(']')[0]
                print(len(rightval.split(',')))
                if ';' in rightval:
                    
                    val1 = rightval.split(',')[0]
                    val2 = rightval.split(',')[1]
                    val2 = self.getsetclosure('[', ']', val2)
                    instantstring += 'Initialize.initalize.2dlists('+val1+','+val2+')'
                    print('instantiation with new 2dlist: ')
                    print(instantstring)
                else:
                    print('************')
                    val1 = rightval.split(',')[0]
##                    val2 = val.split(',')[0]
                    instantstring += 'Initialize.initalize.2dlists('+val1+','
                    self.writenextlineclosuref = True
                    print('instantiation with new 2dlist: ')
                    print(instantstring)

                self.writefileline (instantstring)
                return True
            elif self.defheaderwords[iterm] == '3dlist':
                
                rightval = stringline.split(iword)[1]
                val = self.getsetclosure('[', ']', rightval)
##                val = rightval.split(']')[0]
                try:  int(val); c = True                
                except: None; c = False
                instantstring += 'Initialize.initalize.list('+val+')'
                print('instantiation with new word match 3dlist: ')
                print(instantstring)
                self.writefileline (instantstring)
                return True
            elif self.defheaderwords[iterm] == 'sr':
                rightval = stringline.split('new ')[1]
                if '{' in rightval:
                    rightval = rightval.split('{')[1]
                    val = rightval.split('}')[0]
                    instantstring += ' [' + val + ']'
                    print('instantiation with new special: ')
                    print(instantstring)
                    print(self.linescope[itera])
                    self.writefileline(instantstring)
                else:
                    rightval = stringline.split(iword)[1]
                    print('rightval:')
                    print(rightval)
                    val = self.getsetclosure('[', ']', rightval)
        ##                val = rightval.split(']')[0]
                    try:  int(val); c = True                
                    except: None; c = False
                    instantstring += 'Initialize.initalize.list('+val+')'
                    print('instantiation with new list: ')
                    print(instantstring)
                    self.writefileline(instantstring)
                return True
            else:
                ## no match defheader match but we have a instantiation of somesort
                ## so we replace some things on the line
                newstring = ''
                newstring += self.getspacing2(itera)
                newstringadd = self.getStringnotabsspaces2(stringline)
                newstringadd = newstringadd.replace(word,self.instantiationkeywords[word])
                newstringadd = newstringadd + '    ##' +iterm
                newstringadd = newstringadd.replace(iterm,'', 1)
                newstringadd = self.replacekeyword(newstringadd)
                newstring += self.getStringnotabsspaces2(newstringadd)
                
                print('instantiation with new word match not list:')
                print(newstring)
                self.writefileline(newstring)
                return True
        elif iterm == -1 and wordflag:
            newstring = ''
            newstring += self.getspacing2(itera)
            newstringadd = self.getStringnotabsspaces2(stringline)
            newstringadd = newstringadd.replace(word,self.instantiationkeywords[word])
            newstringadd = self.replacekeyword(newstringadd)
            newstring += self.getStringnotabsspaces2(newstringadd)
            print('instantiation with new no word match: ')
            print(newstring)
            self.writefileline(newstring)
            return True
        else:
            return False

    def instantiationWithoutNewCheck(self,stringline, itera):
        maxcount = 0
        iterm = -1
        count = 0
        wordflag = True
        for word2 in self.defheaderwords:
            if word2 in stringline:
                check = False
                for word3 in self.falseequiv:
                    if word3 in stringline:
                        if not stringline.find(word2)-1 == stringline.find(word3):
                            check = True
                            if word2 in word3:
                                check = False
                                break
                        else:
                            check = False
                            break
                    else:
                        check = True
                if check:
                    if len(word2) > maxcount:
                        maxcount = len(word2)
                        iterm = word2
        if not iterm == -1:
            newstring = ''
            newstring += self.getspacing2(itera)
            newstringadd = self.getStringnotabsspaces2(stringline)
            
            newstringadd = newstringadd.replace(iterm,'',1)
            newstringadd = self.replacekeyword(newstringadd)
            newstringadd = self.getStringnotabsspaces2(newstringadd)
            newstring += newstringadd
            print('instantiation without new: ')
            print(newstring)
            self.writefileline(newstring)
            return True
        else:
            return False
            
                        
    def getStringnotabsspaces(self, stringline):
        #use the second function of this type for now.
        def findnonemptyr(stringset, itera):
            returnit = 0
            if stringset[itera] == '':
                returnit = findnonemptyr(stringset, itera-1)
            else:
                return itera
            return returnit

        def findnonemptyrts(stringset, itera, map2):
            returnit = 0
            index1, index2 = map2[itera] 
            if stringset[index1][index2] == '':
                returnit = findnonemptyrts(stringset, itera-1,map2)
            else:
                return itera
            return returnit

        def findnonemptylts(stringset, itera, map2):
            returnit = 0
            index1, index2 = map2[itera] 
            if stringset[index1][index2] == '':
                returnit = findnonemptylts(stringset, itera+1,map2)
            else:
                return itera
            return returnit

        def map2dlist(listset):
            count = 0
            mapset = {}
            setindex = 0
            for listr in listset:
                listindex = 0
                for strin in listr:
                    mapset[count] = (setindex, listindex)
                    listindex += 1
                    count += 1
                setindex += 1
                
            return mapset

        def getcopylist(stringset, itera, iterb, map2):
            index1l, index2l = map2[itera]
            index1r, index2r = map2[iterb]
            allset = []
            if not index1l == index1r:
                print('stringset:')
                print(stringset)
                retset = [stringset[index1l][index2l:len(stringset[index1l])]]
                print(retset)
                if not index1l+1 == index1r:
                    retsetb = stringset[index1l+1:index1r]
                    retsetc = [stringset[index1r][0:index2r+1]]
                    allset = retset+retsetb+retsetc
                else:
                    retsetb = [stringset[index1r][0:index2r+1]]
                    allset = retset+retsetb
            else:
                allset = stringset[index1l][index2l:index2r+1]
                    
            return allset

        def buildnfrmsetl(stringset,itera, add):
            namestring = ''
            for i in range(0,itera+1):
    ##            namestring += add + stringset[i]
                if not i == 0:
                    namestring += add + stringset[i]
                    print(i)
                    print(stringset[i])
                else:
                    
                    namestring += stringset[i]
            return namestring

        def buildnfrmsetlr(stringset, adds, addt):
            namestring = ''
    ##        for i in range(itera,iterb+1):
    ##            namestring += add + stringset[i]
            count = 0
            strngsetcount = 0
            for set1 in stringset:
                setcount = 0
                print(set1)
                for strin in set1:
                    
                    if not count == 0:
                        if setcount == 0:
                            namestring += adds + strin
    ##                        print(i)
    ##                        print(stringset[i])
                        else:
                            namestring += addt + strin
                    else:
                        
                        namestring += strin
                    count += 1
                    setcount += 1
                strngsetcount += 1
                    
            return namestring

        def findnonemptyl(stringset,itera):
            returnit = 0
            if stringset[itera] == '':
                returnit = findnonemptyr(stringset, itera+1)
            else:
                return itera
            return returnit

        def buildnfrmsetr(stringset,itera, add):
            namestring = ''
            for i in range(itera,len(stringset)):
                if not i == itera:
                    namestring += add + stringset[i]
                else:
                    namestring += stringset[i]
            return namestring

        def getsplitsets(stringline):
            splitsets = []
            spaceset = stringline.split(' ')
            count = 0
            for word in spaceset:
                tabset = word.split('\t')
                splitsets.append(tabset)
                count += 1
            print(splitsets)
            return splitsets

        splitsets = getsplitsets(stringline)
        map2 = map2dlist(splitsets)
        iterb = findnonemptyrts(splitsets, len(map2)-1, map2)
        itera = findnonemptylts(splitsets, 0, map2)
        trunclist = getcopylist(splitsets, itera, iterb, map2)
        return buildnfrmsetlr(trunclist, '  ', '\t')

    def getStringnotabsspaces2(self, stringline):
        def forward(stringline, itera):
            retiter = 0
            if stringline[itera] == ' ' or stringline[itera] == '\t':
                retiter = forward(stringline, itera+1)
            else:
                if stringline[itera] == '':
                    retiter = forward(stringline,itera+1)
                else:
                    return itera
            return retiter
        
        def rev(stringline, itera):
            retiter = 0
            if stringline[itera] == ' ' or stringline[itera] == '\t':
                retiter = rev(stringline, itera-1)
            else:
                if stringline[itera] == '':
                    retiter = rev(stringline,itera-1)
                else:
                    return itera
            return retiter
        iter1 = forward(stringline,0)
        iter2 = rev(stringline, len(stringline)-1)
        return stringline[iter1:iter2+1]
        
    ##    spaceset = stringline.split(' ')
    ##    print(spaceset)
    ##    iterl = findnonemptyl(spaceset, 0)
    ##    stringl = buildnfrmsetr(spaceset,iterl, ' ')
    ##    spacesetr = stringl.split(' ')
    ##    print(spacesetr)
    ##    iterr = findnonemptyr(spacesetr, len(spacesetr)-1)
    ##    print(iterr)
    ##    stringr = buildnfrmsetl(spacesetr, iterr, ' ')
    ##    
    ##    tabset = stringr.split('\t')
    ##    iterlt = findnonemptyl(tabset, 0)
    ##    stringl = buildnfrmsetr(tabset,iterlt, '\t')
    ##    tabsetr = stringl.split('\t')
    ##    iterrt = findnonemptyr(tabsetr, len(tabsetr)-1)
    ##    stringr = buildnfrmsetl(tabsetr, iterrt, '\t')
    ##
    ##    spaceset = stringr.split(' ')
    ##    print(spaceset)
    ##    iterl = findnonemptyl(spaceset, 0)
    ##    stringl = buildnfrmsetr(spaceset,iterl, ' ')
    ##    spacesetr = stringl.split(' ')
    ##    print(spacesetr)
    ##    iterr = findnonemptyr(spacesetr, len(spacesetr)-1)
    ##    print(iterr)
    ##    stringr = buildnfrmsetl(spacesetr, iterr, ' ')
    ##    return stringr

##    def getStringnotabsspaces(self, stringline):
##        def findnonemptyr(stringset, itera):
##            returnit = 0
##            if stringset[itera] == '':
##                returnit = findnonemptyr(stringset, itera-1)
##            else:
##                return itera
##            return itera
##        
##
##        def buildnfrmsetl(stringset,itera, add):
##            namestring = ''
##            for i in range(0,itera):
##                namestring += add + stringset[i]
##
##            return namestring
##
##        def findnonemptyl(stringset,itera):
##            returnit = 0
##            if stringset[itera] == '':
##                returnit = findnonemptyr(stringset, itera+1)
##            else:
##                return itera
##            return itera
##
##        def buildnfrmsetr(stringset,itera, add):
##            namestring = ''
##            for i in range(itera,len(stringset)):
##                if not i == itera:
##                    namestring += add + stringset[i]
##                else:
##                    namestring += stringset[i]
##            return namestring
##
##        spaceset = stringline.split(' ')
##        iterl = findnonemptyl(spaceset, 0)
##        stringl = buildnfrmsetr(spaceset,iterl, ' ')
##        spacesetr = stringl.split(' ')
##        iterr = findnonemptyr(spacesetr, len(spaceset)-1)
##        stringr = buildnfrmsetl(spacesetr, iterr, ' ')
##        tabset = stringr.split('\t')
##        iterlt = findnonemptyl(tabset, 0)
##        stringl = buildnfrmsetr(tabset,iterlt, '\t')
##        tabsetr = stringl.split('\t')
##        iterrt = findnonemptyr(tabsetr, len(tabset)-1)
##        stringr = buildnfrmsetl(tabsetr, iterrt, '\t')
##        return stringr
        
    
    def adddefheaderword(self, word):
        if word not in self.defheaderwords:
            rettype = self.deftype(word)
            self.defheaderwords[word] = rettype
            print(word)
            print(rettype)

    def checksingleline(self, stringline):
        if ';' in stringline:
            return True
        else:
            return False

    def strengthmatching(self, stringline, flg):
        def getsubstringindex(word1, word2):
            #word2 is a substring of word1  (that is smaller)
            return word1.index(word2)

        def checkindices(word1,word2,stringline,subind):
            #word2 is checked as amatched substring of word1 (that is smaller)
            ind1 = stringline.index(word1)
            ind2 = stringline.index(word2)
            if (ind2-ind1) == subind:
                return True
            else:
                return False
        flgset = [self.classfuncnames, self.classvars]
            
        
        cwordlist = []
        cword = 'abc'
        for word in flgset[flg]:
            if word in stringline:
                check = True
                strength = len(word)
                for word2 in flgset[flg]:
                    if word2 in stringline:
                        if (len(word2) > strength) and (word in word2):
                            ind1 = getsubstringindex(word2, word)
                            if checkindices(word2,word,stringline,ind1):
                                check = False
                                break
                if check:
                    stringline = stringline.replace(word,'self.'+word)
        return stringline       
        
    def checkclassfuncscopelineexec(self, stringline, itera):
##        cword = 'abc'
##        for word in self.classfuncnames:
##            if word in stringline:
##                if not (word in cword) or not (cword in word):
##                    stringline = stringline.replace(word,'self.'+word)
##                    cword = word
##                    print(cword)
        stringline = self.strengthmatching(stringline, 0)


        self.checkclassvars(stringline, itera)
##        self.checkclassfuncvars(stringline, itera)
##        print('first self app:')
##        print(stringline)
##        cword = 'abc'
##        for word in self.classvars:
##            if word in stringline:
##                if not ((word in cword) or (cword in word)):
##                    stringline = stringline.replace(word,'self.'+word)
##                    cword = word
##                    print(cword)
##        print('after self app:')
##        print(stringline)
        stringline = self.strengthmatching(stringline, 1)
        
        if not self.instantiationcheck(stringline, itera):
            if not self.instantiationWithoutNewCheck(stringline, itera):

                newstring = ''
                newstring += self.getspacing2(itera)
                newstring += self.getStringnotabsspaces2(stringline)
                newstring = self.replacekeyword(newstring)
                print('no instantiation: ')
                print(newstring)
                self.writefileline(newstring)

    def checkreturnvar(self, stringline):
        removelist = {'{':'', '}':''}
        def removes(stringline):
            if '{' in stringline:
                stringline = stringline.replace('{','')
                if '}' in stringline:
                    stringline = stringline.replace('}','')
            elif '}' in stringline:
                stringline = stringline.replace('}','')
            return stringline
        
        def getname (stringline, wordmatch):
            if '=' in stringline:
                print('indexing:')
                print(stringline.index(wordmatch))
                print(stringline.index('='))
                print(wordmatch)
                if stringline.index(wordmatch) > stringline.index('='):
                    varmatch = stringline.split('=')[0]
                    varmatch = self.getStringnotabsspaces2(varmatch)
                    return varmatch
                else:
                    varmatch = stringline.split('=')[0]
                    varmatch = varmatch.split(wordmatch)[1]
                    varmatch = self.getStringnotabsspaces2(varmatch)
                    return varmatch
            else:
                return stringline.split(wordmatch)[1]
            
        strength = 0
        matchindex = 0
        matchtype = ''
        i = 0
        found = False
        var = ''
        for word in self.defheaderwords:
            if word in stringline:
                if len(word)>strength:
                    strength = len(word)
                    matchindex = i
                    matchtype = word
                    var = getname(stringline, word)
                    var = removes(var)
##                    var = stringline.split(word)[0]
##                    var = self.getStringnotabsspaces2(var)
                    var = self.removespacefromstring(var)
                    found = True
            i+=1
        return (found, var, matchtype)

    def checkclassfuncvars(self, classvarstring, itera):
        #deprecated/bordering.  Using alternate string
        # parsing methods above.
        def findnonemptyr(stringset, itera):
            returnit = 0
            if stringset[itera] == '':
                returnit = findnonemptyr(stringset, itera-1)
            else:
                return itera
            return returnit
        

        def buildnfrmset(stringset,itera):
            namestring = ''
            for i in range(0,itera):
                namestring += stringset[i]
            return namestring
        
        classlevelstring = ''
##        print('linescope: ')
##        print(self.linescope[itera])
        if not itera in self.classfuncnames_rev:
##            if self.linescope[itera] == 2 and self.classscope:
##                writestring = classvarstring[0:len(classvarstring)]
##                writestring = '##'+writestring
##                print(writestring)
    ##            self.writefileline (switchfirstline)
                if not '=' in classvarstring:
                    if self.checksingleline(classvarstring):
                        v = classvarstring.split(';')[0]
                        v = self.getStringnotabsspaces2(v)
                        print('p check: ')
                        print(v)
                        print(len(v.split(' ')))
                        if len(v.split(' ')) > 1:
                            if not '()' in v.split(' ')[1]: 
                                vs = v.split(' ')
                                ##next line finds from the right hand side
                                ## the next(first) non empty character set
                                vsriter = findnonemptyr(vs,len(vs)-1)
                                classvar = vs[vsriter]
                                classtypea = buildnfrmset(vs,
                                                          vsriter)
                                classtypeset = classtypea.split('\t')
                                classtype = buildnfrmset(classtypeset,len(classtypeset))
                                self.classvars[classvar] = classtype
                                self.adddefheaderword(classtype)

                        
                else:
                    if not '==' in classvarstring:
                        print('unidentified type hit: ')
                        eqleftvar = classvarstring.split('=')[0]
                        check, classvar, ctype = self.checkreturnvar(eqleftvar)
                        if check:
                            self.classvars[classvar] = ctype
    ##                        classlevelstring =
                            
                        else:
                            classvarset = eqleftvar.split(' ')
                            ## presuming non empty character set supplied
                            classvarnameiter = findnonemptyr(classvarset,
                                                         len(classvarset)-1)
                            classvarname = classvarset[classvarnameiter]
                            classtypea = buildnfrmset(classvarset,
                                                      classvarnameiter)
                            classtypeset = classtypea.split('\t')
                            classtype = buildnfrmset(classtypeset,len(classtypeset))
                            self.classvars[classvarname] = classtype
                            self.adddefheaderword(classtype)
                return True
##            else:
##                return False
        else:
            return False
    
    def checkclassvars(self, classvarstring, itera):
        #deprecated/bordering.  Using alternate string
        # parsing methods above.
        def findnonemptyr(stringset, itera):
            returnit = 0
            if stringset[itera] == '':
                returnit = findnonemptyr(stringset, itera-1)
            else:
                return itera
            return returnit
        

        def buildnfrmset(stringset,itera):
            namestring = ''
            for i in range(0,itera):
                namestring += stringset[i]
            return namestring
        
        classlevelstring = ''
##        print('linescope: ')
##        print(self.linescope[itera])
        if not itera in self.classfuncnames_rev:
            if self.linescope[itera] == 2 and self.classscope:
                writestring = classvarstring[0:len(classvarstring)]
                writestring = '##'+writestring
                print(writestring)
    ##            self.writefileline (switchfirstline)
                if not '=' in classvarstring:
                    if self.checksingleline(classvarstring):
                        v = classvarstring.split(';')[0]
                        vs = v.split(' ')
                        ##next line finds from the right hand side
                        ## the next(first) non empty character set
                        vsriter = findnonemptyr(vs,len(vs)-1)
                        classvar = vs[vsriter]
                        classtypea = buildnfrmset(vs,
                                                  vsriter)
                        classtypeset = classtypea.split('\t')
                        classtype = buildnfrmset(classtypeset,len(classtypeset))
                        self.classvars[classvar] = classtype
                        self.adddefheaderword(classtype)

                        
                else:
                    if not '==' in classvarstring:
                        print('unidentified type hit: ')
                        eqleftvar = classvarstring.split('=')[0]
                        check, classvar, ctype = self.checkreturnvar(eqleftvar)
                        if check:
                            self.classvars[classvar] = ctype
    ##                        classlevelstring =
                            
                        else:
                            classvarset = eqleftvar.split(' ')
                            ## presuming non empty character set supplied
                            classvarnameiter = findnonemptyr(classvarset,
                                                         len(classvarset)-1)
                            classvarname = classvarset[classvarnameiter]
                            classtypea = buildnfrmset(classvarset,
                                                      classvarnameiter)
                            classtypeset = classtypea.split('\t')
                            classtype = buildnfrmset(classtypeset,len(classtypeset))
                            self.classvars[classvarname] = classtype
                            self.adddefheaderword(classtype)
                return True
            else:
                return False
        else:
            return False
                        
                                        
                
    def removespacefromstringstart(self, stringline):
        if stringline.startswith(' '):
            rstring = stringline[0:len(stringline)]
            rstring.replace(' ','',1)
            return rstring
        else:
            return stringline

    def removespacefromstring(self, stringline):
        scount = stringline.rfind(' ')
        return stringline.replace(' ','',scount)

    def getspacing(self):
        spacestring = ''
        for i in range(0,self.indentlevel):
            spacestring += '\t'
        return spacestring

    def getspacing2(self, lineint):
        spacestring = ''
        for i in range(0,self.linescope[lineint]):
            spacestring += '\t'
        return spacestring            
            
    def getclassfuncinputs(self, classstring):
        funcvalinputnamesstring = '(self'
        leftparsplit = classstring.split('(')
        rightparstring = leftparsplit[1]
        leftparstring = rightparstring.split(')')
        funcinputvals = leftparstring[0].split(',')
        i = 0
##        funcvalinputnamesstring = ''
        for funcinputval in funcinputvals:
            if not i == len(funcinputvals) - 1:
                funcvalinputnamesstring += ', '
                funcinputvalsplit = funcinputval.split(' ')
                funcvalinputnamesstring += self.findfirstnonnullfromlast(funcinputvalsplit)
            else:
                if len(funcinputvals) < 2:
                    
                    funcinputvalsplit = funcinputval.split(' ')
                    if self.findfirstnonnullfromlast(funcinputvalsplit) == '':
                        funcvalinputnamesstring += self.findfirstnonnullfromlast(funcinputvalsplit)
                        funcvalinputnamesstring += '):'
                    else:
                        funcvalinputnamesstring += ', '
                        funcvalinputnamesstring += self.findfirstnonnullfromlast(funcinputvalsplit)
                        funcvalinputnamesstring += '):'        
                else:
                    funcvalinputnamesstring += ', '
                    funcinputvalsplit = funcinputval.split(' ')              
                    funcvalinputnamesstring += self.findfirstnonnullfromlast(funcinputvalsplit)
                    funcvalinputnamesstring += '):'
            i += 1
        return funcvalinputnamesstring
        
        
    def findsecondnonnull(self,splitlist):
        firsthit = False
        for item in splitlist:
            if not item == '':
                if not firsthit:
                    firsthit = True
                else:
                    return item
            
        return ''

    def findfirstnonnullfromlast(self, splitlist):
        c = splitlist[0:len(splitlist)]
        c.reverse()
        return self.findfirstnonnull(c)

    def findfirstnonnull(self,splitlist):
        for item in splitlist:
            if not item == '':
                return item
            
        return ''
        
    def checkusing(self, stringline):        
        if 'using' in stringline:
            if stringline.index('using') == 0:
                newstringline = "##" + stringline
                print(newstringline)
                self.writefileline (newstringline)
                return True
            else:
                return False
        return False
    
    def checkleftbracenextline(self, stringline):
        if '{' in stringline:
            self.cmtleftbracenextline = False
        else:
            self.cmtleftbracenextline = True
            
    def checknamespace(self, stringline):
         if 'namespace' in stringline:
            self.checkleftbracenextline(stringline)
            newstringline = "##" + stringline
            print(newstringline)
            self.writefileline (newstringline)
            return True
         return False

    def rebuildsplit(self, splitset):
        line = ''
        for stringpart in splitset:
            line += stringpart
        return line
    
    def checkcmtleftbracenextline(self, stringline):
        if self.cmtleftbracenextline:
            if '{' in stringline:
##                newstringline = stringline.split('{')[0] + stringline.split('{')[1]
                ##newstringline = "##" + stringline
                newstringline = self.rebuildsplit(stringline.split('{'))
                print(newstringline)
                self.writefileline (newstringline)
                self.cmtleftbracenextline = False
                return True
            else:
                ##expected good code writing no double left bracing on the same
                ## line
                ##self.cmtleftbracenextline = False
                return False
        else:
            return False

    def checkclass(self, stringline):
        if 'class' in stringline:
            classstring = ''
            classstring += 'class '
            classstringf = stringline.split('class')
            classnamestringlist = classstringf[1].split(' ')
##            ## assumed class name returned below is non null value good
##            ## programming
            classname = self.findfirstnonnull(classnamestringlist)
            
            self.classname = classname.split('\n')[0]
##            classstring += self.getclassfuncinputs(self, stringline)
            self.checkleftbracenextline(stringline)
            classstring += self.classname + ':'
            print(classstring)
            print(self.cmtleftbracenextline)
            self.writefileline (classstring)
            self.indentlevel += 1
            self.classscope = True
            return True
        else:
            return False

    def checkiffuncandscope(self, filea,lineint):
        ## deprecated function using buildclassfunccompletion instead
        markincheck = False
        markin = 0
        scopelevel = 0
        markout = 0
        
        for i in range(lineint, len(filea)):
            if not markincheck and not ';' in filea[i]:
                if '{' in filea[i]:
                ##if not markincheck:
                    markin = i
                    markincheck = True
                    self.classfuncscopeintervalleft.append(i)
                    if not '}' in filea[i]: 
                        continue
                
            elif not markincheck and ';' in filea[i]:
                return False
            
            if markincheck:
                if '{' in filea[i]:
                    scopelevel += 1
                    self.classfuncscopeintervalleft.append(i)
                    
                if scopelevel == 0:
                    if '}' in filea[i]:
                        markout = i
                        classfuncscope = True
                        self.classfuncscopeintervalright.append(i)
                        ##classfuncscopeinterval = [markin,markout]
                        return true
                else:
                    if '}' in filea[i]:
                        scopelevel -= 1
                        self.classfuncscopeintervalright.append(i)

    def buildclassfunccompletions(self, filea,lineint):
        def findnonemptyr(stringset, itera):
            returnit = 0
##            print(stringset)
            if stringset[itera] == ' ':
                returnit = findnonemptyr(stringset, itera-1)
            else:
                return itera
            return returnit

        def findnonemptyl(stringset, itera):
            returnit = 0
##            print(stringset)
            if stringset[itera] == ' ':
                returnit = findnonemptyr(stringset, itera+1)
            else:
                return itera
            return returnit        
        

        def buildnfrmset(stringset,itera):
            namestring = ''
            for i in range(0,itera+1):
                namestring += stringset[i]
            return namestring

        def findname(filea, itera):
            niter = 0
##            print(filea[itera])
            if not '(' in filea[itera]:
                niter = findname(filea,itera-1)
            else:
                return itera
            return niter

        def nocommentcheck(filea,itera, name):
            if '//' in filea[itera]:
                if filea[itera].index('//') < filea[itera].index(name):
                    return True
                else:
                    return False
            else:
                return False
            
        
##        def parseclassfuncname(stringline):
##            leftpar = stringline.split('(')[0]
            
        namelist = ['namespace','class']
        markincheck = False
        markin = 0
        scopelevel = 0
        markout = 0
        recordline = ''
        namelistcounter = 0
        for i in range(lineint, len(filea)):
            for word in namelist:
                if word in filea[i]:
                    namelistcounter += 1
                    
        count = 0
##        print(namelistcounter)
        for i in range(lineint, len(filea)):

            self.linescope[i] = scopelevel
            if scopelevel == namelistcounter:
##                print(scopelevel)
                if not markincheck and not ';' in filea[i]:
                    recordline = filea[i]
                    if '{' in filea[i]:
                    ##if not markincheck:
                        markin = i
                        markincheck = True
                        fiter = findname(filea, i)
                        
                        
                        leftpar = filea[fiter].split('(')[0]
                        filea[fiter].split('(')[0][len(leftpar)-1] == ' '
##                        print(filea[fiter].split('(')[0][len(leftpar)-1])
                        funcnameiter = findnonemptyr(leftpar,
                                                     len(leftpar)-1)
                        funcnspace = buildnfrmset(leftpar,funcnameiter)
##                        funcnspace = leftpar[funcnameiter]
                        funcnspaceset = funcnspace.split(' ')
##                        print(funcnspaceset)
##                        funcspacei = findnonemptyr(funcnspaceset,
##                                                   len(funcnspaceset)-1)
                        if not nocommentcheck(filea,fiter, funcnspaceset[len(funcnspaceset)-1]):
                            self.classfuncnames[funcnspaceset[len(funcnspaceset)-1]] = fiter
                            self.classfuncnames_rev[fiter] = funcnspaceset[len(funcnspaceset)-1]
                        
                        ##self.classfuncscopeintervalleft.append(i)
##                        if not '}' in filea[i]: 
##                            continue
                        

                    
##                elif not markincheck and ';' in filea[i]:
    ##                return False
                    
            elif scopelevel < namelistcounter:
                if '{' in filea[i]:
                    csplit = len(filea[i].split('{'))-1
                    scopelevel += csplit
                    if '}' in filea[i]:
                        csplitl = len(filea[i].split('}'))-1
                        scopelevel -= csplitl
                    self.linescope[i] = scopelevel
                elif '}' in filea[i]:
                    scopelevel -= 1
                    if '{' in filea[i]:
                        scopelevel += 1
                    else:
                        self.classfuncscopeintervalright.append(i)
            
            if markincheck:
##                if '{' in filea[i]:
##                    scopelevel += 1
                    ##self.classfuncscopeintervalleft.append(i)
                    
                if scopelevel == namelistcounter+1:
                    if '}' in filea[i]:
                        markout = i
                        classfuncscope = True
                        markincheck = False
                        csplit = len(filea[i].split('}'))-1
                        scopelevel -= csplit
                        if '{' in filea[i]:
                            csplitl = len(filea[i].split('{'))-1
                            scopelevel += csplitl
                            if scopelevel > namelistcounter:
                                markincheck = True
                            else:
                                self.classscopecounter.append(i)
                        else:
                            self.classscopecounter.append(i)
                        self.classfuncscopeintervalright.append(i)
                        ##classfuncscopeinterval = [markin,markout]
                        ##return true
                    elif '{' in filea[i]:
                        scopelevel += 1
                        if '}' in filea[i]:
                            scopelevel -= 1
                else:
                    if '}' in filea[i]:
                        csplit = len(filea[i].split('}'))-1
                        scopelevel -= csplit
                        if '{' in filea[i]:
                            csplitl = len(filea[i].split('{'))-1
                            scopelevel += csplitl
                        else:
                            self.classfuncscopeintervalright.append(i)
                    elif '{' in filea[i]:
                        scopelevel += 1
                        if '}' in filea[i]:
                            scopelevel -= 1
                        ##self.classfuncscopeintervalright.append(i)
            count += 1
            
            

    def checkclassfuncname(self, stringline):
        if self.classname in stringline:
            return True
        else:
            return False

    def checkleftbrace(self, filea, itera):
        if itera in self.classfuncscopeintervalleft and '}' in filea[itera]:
            ##self.indentlevel -= 1
            return filea[itera].split('{')[0]+filea[itera].split('{')[1]

    def checkclassfuncscope(self, itera):
        if itera in self.classscopecounter:
            self.classfuncscope = False

    def checkrightbrace(self, filea, itera):
        if itera in self.classfuncscopeintervalright:
            if itera == self.classfuncscopeintervalright[len(self.classfuncscopeintervalright)-1]:
##                self.classfuncscope = False
                self.indentlevel -= 1
            elif self.casescope == True:
                if itera == self.caseenditer:
                    self.casescope = False
                    self.indentlevel -= 1
                else:
                    self.indentlevel -= 1
            else:
                self.indentlevel -= 1
            print('right brace line: ')
            print(filea[itera].split('}')[0]+ filea[itera].split('}')[1])
            return True
        else:
            return False

    def checkcontrolscopenonfor(self, filea,itera):
        returncheck = False
        markrightpar = False
        for i in range(itera, len(filea)):
            if ')' in filea[i]:
                rightpar = filea[i].split(')')[1]
                if not ';' in rightpar:
                    if '{' in filea[i] and i in self.classfuncscopeintervalleft:
                        return True
                    else:
                        markrightpar = True
                else:
                    return False
            else:
                if ';' in filea[i]:
                    return False
                else:
                    if markrightpar:
                        if '{' in filea[i] and i in self.classfuncscopeintervalleft:
                            return True
                    
        return returncheck

    def findcasecompletion(self, filea,itera):
        val = []
        for i in range(itera, len(filea)):
            if not '}' in filea[i]:
                if 'case' in filea[i]:
                    casesplitright = filea[i].split('case')[1]
                    value = casesplitright.split(':')[0]
                    val.append(value)
            else:
                
                self.casevalues = val
                self.caseenditer = i
                break
        
    def getfor(self, stringline, itera):
        ##retrieve brace information, presuming a (int i = 0; i<...;i++) example
        ##structure, my writing style, this is not generalized
        returnstring = ''
        if 'for (' in stringline:
            leftpar = stringline.split('for (')[1]
        elif 'for(' in stringline:
            leftpar = stringline.split('for(')[1]
        rightpar = leftpar.split('){')[0]
        parsemicolonsplit = rightpar.split(';')
        parsemicolonsplit[0] = parsemicolonsplit[0].replace('int ','')
        rangemin = parsemicolonsplit[0].split('=')[1]
        var = parsemicolonsplit[0].split('=')[0]
        rangemax = parsemicolonsplit[1].split('<')[1]
        print(rangemax)
        rangemaxnew =''
        if '.Length' in rangemax:
            rangemaxnewl = rangemax.split('.Length')[0]
            rangemaxnewr = rangemax.split('.Length')[1]
            rangemaxnew = 'len(' + rangemaxnewl+')'+rangemaxnewr
        else:
            rangemaxnew = rangemax
            
##        returnstring += self.getspacing()
        returnstring += self.getspacing2(itera)
        returnstring += 'for '
        returnstring += var
        returnstring += ' in range('
        returnstring += rangemin
        returnstring += ','
        returnstring += rangemaxnew
        returnstring += '):'
        return returnstring
    
    def getif(self, stringline, itera):
        ##retrieve brace information, presuming a (int i = 0; i<...;i++) example
        ##structure, my writing style, this is not generalized
        returnstring = ''
##        leftpar = stringline.split('(')[1]
##        rightpar = leftpar.split(')')[0]           
##        returnstring += self.getspacing()
        leftpar = stringline.split('if')[1]
        rightpar = self.getsetclosure2('(', ')', leftpar)
        returnstring += self.getspacing2(itera)
        returnstring += 'if '
        returnstring += rightpar
        returnstring += ':'
        return returnstring
    
    def getelse(self, stringline, itera):
        ##retrieve brace information, presuming a (int i = 0; i<...;i++) example
        ##structure, my writing style, this is not generalized
        returnstring = ''
##        returnstring += self.getspacing()
        returnstring += self.getspacing2(itera)
        returnstring += 'else: '
        return returnstring

    def getelseif(self, stringline, itera):
        ##retrieve brace information, presuming a (int i = 0; i<...;i++) example
        ##structure, my writing style, this is not generalized
        returnstring = ''
        
##        leftpar = stringline.split('(')[1]
##        rightpar = leftpar.split(')')[0]
        leftpar = stringline.split('else if')[1]
        rightpar = self.getsetclosure2('(', ')', leftpar)
##        returnstring += self.getspacing()
        returnstring += self.getspacing2(itera)
        returnstring += 'elif '
        returnstring += rightpar
        returnstring += ':'
        
        return returnstring        

    def getparinput(self, stringline):
        parleft = stringline.split('(')[1]
        parright = parleft.split

    def getswitchvar(self, stringline):
        if 'switch' in stringline:
            varpar = stringline.split('(')[1]
            var = stringline.split(')')[0]
            self.casevar = var

    def getswitchline(self, caseiter, itera):
        if caseiter == 0:
            switchline = ''
##            switchline += self.getspacing()
            switchline += self.getspacing2(itera)
            switchline += 'if '
            switchline += self.casevar
            switchline += '=='
            switchline += self.casevalues[0]
            switchline += ':'
        else:
            switchline = ''
##            switchline += self.getspacing()
            switchline += self.getspacing2(itera)
            switchline += 'elif '
            switchline += self.casevar
            switchline += '=='
            switchline += self.casevalues[0]
            switchline += ':'
        return switchline
        

    def checkcontrol(self, stringline, filea,itera):
        charcheck = ['\t',' ']
        atypes = ('for','if ','if(', 'switch', 'else', 'else if', 'while')
        atypetrans = {'for':'for','switch':'switch','else':'else','else if':'else if','if ':'if', 'if(':'if'}
        strength = 0
        ratype = ''
        for atype in atypes:
            if atype in stringline:
                if len(atype) > strength:
                    for char in charcheck:
                        if char == stringline[stringline.index(atype)-1]:
                            ratype = atype
                
                ## this suffers unfortunately from the possibility that a word
                ## is embedded in a variable name...although we eliminate
                ## with additional checking algorithms the possibility that
                ## a single line non control loop set of tokens are interpreted
                ## as a control structure by cross checking outside for paranthesis
                ## , braces, and semi colons.  Semi colons outside of for loops
                ## at least in my programming writing style should suffice in most
                ## cases to be interpreted that a structure is not likely a control
                ## structure as opposed to a single line executable set of tokens
                ## control paranthesis are expected on a single line with control
                ## token.  Thus I haven't taken into account the possibility
                ## of multi line control token statements.
        check = False
        if '//' in stringline:
            if stringline.index('//') < stringline.index(ratype):
                check = True
        if not check:
            if ratype == 'for':
                print('for stringline:')
                print(stringline)
                rightpar = stringline.split(')')[1]
##                        if self.checkcontrolscopenonfor(filea,itera):
                forstring = ''
                forstring += self.getfor(stringline, itera)
                self.indentlevel += 1
                self.checkleftbracenextline(stringline)
                forstring = self.replacekeyword(forstring)
                print(forstring)
                self.writefileline (forstring)
                return True
##                    else:
##                        return False
                
                
            elif ratype == 'if ':
                if atypetrans[ratype] == 'if':
        ##                        if self.checkcontrolscopenonfor(filea,itera):
                    ifstring = ''
                    print('if stringline:')
                    print(stringline)                        
                    ifstring += self.getif(stringline, itera)
                    self.indentlevel += 1
                    self.checkleftbracenextline(stringline)
                    ifstring = self.replacekeyword(ifstring)
                    print(ifstring)
                    print(itera)
                    print(self.linescope[itera])
                    if '{' in stringline and ';' in stringline:
                        stringexec = stringline[stringline.index('{'):len(stringline)]
                        self.checkclassfuncscopelineexec(stringexec, itera+1)
                    self.writefileline (ifstring)
                    return True
        ##                        else:
        ##                            return False
            elif ratype == 'if(':
                if atypetrans[ratype] == 'if':
        ##                        if self.checkcontrolscopenonfor(filea,itera):
                    ifstring = ''
                    print('if stringline:')
                    print(stringline)                        
                    ifstring += self.getif(stringline, itera)
                    self.indentlevel += 1
                    self.checkleftbracenextline(stringline)
                    ifstring = self.replacekeyword(ifstring)
                    print(ifstring)
                    print(itera)
                    print(self.linescope[itera])
                    if '{' in stringline and ';' in stringline:
                        stringexec = stringline[stringline.index('{'):len(stringline)]
                        self.checkclassfuncscopelineexec(stringexec, itera+1)
                    self.writefileline (ifstring)
                    return True
        ##                        else:
        ##                            return False
            
                
            elif ratype == 'switch':
##                        if self.checkcontrolscopenonfor(filea,itera):
                self.findcasecompletion(filea,itera)
                self.getswitchvar(stringline)
                print('switch stringline:')
                print(stringline) 
                switchfirstline = self.getswitchline(self.caseiter,
                                                     itera)
                self.indentlevel += 1
                self.caseiter += 1
                self.checkleftbracenextline(stringline)
                switchfirstline = self.replacekeyword(switchfirstline)
                print(switchfirstline)
                self.writefileline (switchfirstline)
                self.casescope = True
                return True
##                        else:
##                            return False
                
            elif ratype == 'else if':
##                        if self.checkcontrolscopenonfor(filea,itera):
                elifstring = ''
                print('else if stringline:')
                print(stringline)            
                elifstring += self.getelseif(stringline, itera)
                self.indentlevel += 1
                self.checkleftbracenextline(stringline)
                elifstring = self.replacekeyword(elifstring)
                print(elifstring)
                self.writefileline (elifstring)
                if '{' in stringline and ';' in stringline:
                    stringexec = stringline[stringline.index('{'):len(stringline)]
                    self.checkclassfuncscopelineexec(stringexec)
                return True
##                        else:
##                            return False
                
            elif ratype == 'else':
##                        if self.checkcontrolscopenonfor(filea,itera):
                elsestring = ''
                print('else stringline:')
                print(stringline) 
                elsestring += self.getelse(stringline, itera)
                self.indentlevel += 1
                self.checkleftbracenextline(stringline)
                elsestring = self.replacekeyword(elsestring)
                print(elsestring)
                print(self.linescope[itera])
                self.writefileline (elsestring)
                if '{' in stringline and ';' in stringline:
                    stringexec = stringline[stringline.index('{'):len(stringline)]
                    self.checkclassfuncscopelineexec(stringexec, itera+1)
                return True
##                        else:
##                            return False
            else:
                return False
        else:
            return False

    def checkcase(self, stringline):
        if self.casescope:
            if 'case' in stringline:
                self.indentlevel -= 1
                switchfirstline = self.getswitchline(self.caseiter)
                self.indentlevel += 1
                self.caseiter += 1
                self.writefileline (switchfirstline)
                return True
            else:
                return False
        else:
            return False
            
    def checkfunc(self, stringline, filea, lineint):
##        for word in self.classfuncwords:
##            if word in stringline and not ';' in stringline:
        if lineint in self.classfuncnames_rev:
##                if '(' in stringline:
##                if self.checkiffuncandscope(filea,lineint):
        ##if ')' in stringline:
            funcstring = ''
##            funcstring += self.getspacing()
            funcstring += self.getspacing2(lineint)
            funcstring += 'def '
            if self.checkclassfuncname(stringline):
                funcstring += '__init__'
            else:
                
##                classstring = stringline.split('class')
##                classnamestringlist = classstring[1].split(' ')
##            ## assumed class name returned below is non null value good
##            ## programming
##                funcstring += self.findfirstnonnull(classnamestringlist)
                funcstring += self.classfuncnames_rev[lineint]
            funcstring += self.getclassfuncinputs(stringline)
            self.checkleftbracenextline(stringline)
            print(funcstring)
            self.writefileline (funcstring)
            self.indentlevel += 1
            self.classfuncscope = True
            return True
##                else:
##                    return False
##                else:
##                    return False
        else:
            return False

##    def checkvardefinition(self, linestring):
        ##simplest keyword token looks for '=' are there points
        ## of ambiguity on this?! Potentially I might want to confuse
        ## this with '=='.  Definitions often omit this and may have
        ## a single line ';' character, but this is not necessary for
        ## program execution.  So searching for '=' may aid us here.
        ## We can rest a little easier that any control loop
        ## using conditional logic '==' are previously scanned in our
        ## body parsing structure.
        ## This may not be very good in retrospect unless I eliminate
        ## other keywords on given line/multi line
        
        
    def writefileline(self,stringdata):
        stringdata = stringdata.replace('\n','')
        stringdata += '\n'
        self.writefile.write(stringdata)
        
    def readwritefile(self):
        filea = open(self.file, 'rU')
        semicolondatasplit = []
        lineint = -1
        fileb = self.getfilelines(filea)
        self.buildclassfunccompletions(fileb,lineint)
        for line in fileb:
            lineint += 1
            self.checkclassfuncscope(lineint)
            if self.checkusing(line):
                continue
            if self.checknamespace(line):
                continue
            if self.checkcmtleftbracenextline(line):
                continue
            if not self.classscope:
                if self.checkclass(line):
                    continue
            else:
                if self.checkclassvars(line, lineint):
                    continue
##                if self.checkclassvars(line):
##                    continue
                
            if not self.classfuncscope:
                print(lineint)
                print(line)
                if self.checkfunc(line, fileb, lineint):
                    continue
##            if self.casescope:
##                if self.checkcase(line):
##                    continue
            if self.checkcontrol(line, fileb,lineint):
                continue
            if self.checkrightbrace(fileb, lineint):
                continue
            print(line)
            if self.writenextlineclosuref:
                line = self.writenextlineclosure(line)
            self.checkclassfuncscopelineexec(line, lineint)
##            
##                
            
        filea.close()
        self.writefile.close()
        
    def getfilelines(self, filea):
        filed = []
        for line in filea:
            filed.append(line)
        return filed
                
    def startwritefile(self):
        self.writefile = open(self.writefilenamepath +self.filename.replace('.cs','')+".py", "w")
        
    def __init__(self, filenamepath=None, filename=None, writefilenamepath=None):
        self.filenamepath = filenamepath
        self.filename = filename
        self.file = self.filenamepath+self.filename
        self.writefilenamepath = writefilenamepath
        self.cmtleftbracenextline = False
        self.startwritefile()

path = 'C:\\Users\\StrangeCharmQuark\\Documents\\New Unity Project 4\\Assets\\'
filename = 'Boundaryedgesgroup.cs'

path2 = 'C:\\Users\\StrangeCharmQuark\\Documents\\'
a = conversionCsharptopython(path,filename, path2)
a.readwritefile()
filename2 = 'test.py'

A case of one of them...

     I'd mention some of the bigger social red flags in dealing with any person on the matter of perception, reality, social politics, government, and so forth.  

Here's a small of list to be considered:

1.  Not ignorant and given to much social persistence.  Probably the biggest red flag I could think of, it it weren't a matter of insistence, hardly giving up, a lack of desire in relinquishing control on a subject matter.  A common interweaving of personal social communication in such discourse reverts upon the craziness of a given subject matter, or that thoughts are dangerous, never mind, all the tantrums of a society through well sanctioned air waves, or socially acceptable tantrums, tirades, or any place where an acceptable forum were to the well accepted social verse of a civilization.  These sort of typified speech patterns use the sorts of language one might as well find in China, or that a dissident opinion reflects something of personal mental instability, although recent trends could be posited on something like 'grammar', but this is nothing of an old variation from the sort of social tirade, whether from the likes of an idiot driven security apparatus which might have used the bellicosity of language in reflecting its own desire for cultural revolution.        

2.  Too probing.  If you weren't drugged out enough apparently and were too keenly present in a given existential moment, you might notice how bad the actors were...they might ask for personal history, they might start up by saying, 'I am having these issues...'  the sort of thing that might lead one to roll one's eyes interminably given to the nature of acting...or why the FBI really insists that encryption is a problem to them, maybe it were that their ranks really are starting to stink at their jobs all the more.  If they had a hard time really sliding through personal information, and you weren't up to the task of social complicity, you might have questioned the inquisitor?

3.  Bad social network.  People that seem to know too much personal information about you when you haven't divulged an ounce of information to them.  A potential social danger?   

So if you hadn't learned to be ultra assertive by now, I'd suggest its a better pathway, outside of complicit interaction.  Setting up separability between yourself on the sick societal occult gone awry is the first step to personal liberation. 

Fear and Loathing was a good film?!

   Not that often there really isn't a whole lot of anything but generally crappy offerings from media in general that weren't selected in the alacarte sense,  the Science channel turned DEA channel is, however, currently is not given to the same options...much laughter on this one, looks most definitely the government mouthpiece.  Which is pretty amusing considering everything else...added to this I hadn't been frequenting Facebook for that matter...not that square is bad...on the forcible issue of eating beans, these days that's all translated into salmonella product warnings, or apparently if you like grammar all the rage for the sad nazi desiring criminal offense for language, these days you couldn't be more careful to suggest matters of sacrilege regarding power and authority.  To this extent, however, you might have the option, hopefully outside of any particular darker recess, reaching agreements that everything is well, all is well, all is good, all is fine, the metamorphosis dude is running for congress here locally!  :D  Mostly though if I pushed a bit on the square I say eating beans could be like swallowing a comet.  Fear and Loathing was a good film?!

No one really understood that seeming bit of irrational mystery...cult of Pythagoras?!

Ironic isn't it?!  Someone fired for teaching about NIMH s

Spare the octopus from a calamari grave site, it were merely a day off in its prediction.

   



  

Oddity of selecting vertices in Blender via python script

Okay so if you read into python scripting examples of moving vertices around in Blender, it seems whether using a bpy.context or bpy.data call to a given object and its corresponding vertices, you can resort to updating these without any problems.  On the other hand while you can see if for a given selected object, its given vertices are selected (in 'Edit' mode), it appears that changing a given selection status is another matter.  Technically you can change these but apparently relation between context and object are not given systemically in a way that translates to any related operator command.  Thus if you wanted to select particular vertices in adding these to a given vertex group via operator command, for instance, it appears that an operator based assignment process is a no go.

There is a work around that I've found at the moment, albeit slightly circuitous in updating a given set of vertices in so far as selection.

#example to select a vertex
bpy.ops.object.mode_set(mode = 'EDIT')
bpy.ops.mesh.select_all(action = 'DESELECT')  #deselecting vertices

#nextline ensures that we have an updated representation of selected vertices
bpy.context.object.update_from_editmode() 
me = bpy.context.object.data
bm = bmesh.new()   # create an empty BMesh
bm.from_mesh(me)   # fill it in from a Mesh

bm.verts[0].select_set(True)
bpy.ops.object.mode_set(mode = 'OBJECT')
bm.to_mesh(me)
bpy.ops.object.mode_set(mode = 'EDIT')

Presuming there is a vertex, for instance, in the zeroth container position to be selected for a given mesh object, this sets the vertex of the object to a selection true case.

Read any number of my previous posts

If and when representation applied, I'd offer reading through the litany.  Obviously given to small time inter web chat, I'd think the answer couldn't be more clear.  This aside, I don't think there's really much going for another camp.

For that matter gaining attention to the extent of slaving digital devices and eavesdropping, these sorts of decade long repetitions have yielded the same results.  I am sort of surprised that someone bothers to any degree...however, ineffective this must appear in some other way, or that things are going the way of moderation enough...you drop by?!  :D


Taught me a lesson?!  :D

I am sort of amazed that funny little suicide taunts on google plus, likely the sort of troll these days that could well be headed to prison in some other country.  What you bothered to quit gaming to check out Space.com and then have your candy ass grade school shit moderated in ten seconds flat?!

Between the somewhat intelligible extremes of Gamergate that I have managed in following while having spent all but several minutes bothering to read twitter feeds on this subject

    I managed to follow through an intelligible article written, I believe, as a nuanced GamerGate deferential piece (through Forbes) on whatever intelligible aspects of 'Gamergate' that could be offerred.  The author handled discussion while I imagine having engaged in so many words any number of detailed omissions, or at least underscoring refrain in the audibly understood sense when it weren't that 'rape your dead corpse' hadn't cropped up in the supposed discussion, however, umpteenth number of times that it already had obfuscating the feed likely much unread.  I am surprised that more reasoned half were given to the other complex conspiratorial sides of things like 'feminist illuminati' ...here it seems that 'Feminism' and 'Illuminati' seem in some ways almost antithetical as it were a modern juxtaposition to be imagined by way of a title like Assassin's Creed, although my apologies, I don't think I've ever played once such a title.  One might be wondering where the clear lessons in history were ever served?  'Feminists' conspiratorial s holding ranks more often than not of the highest industrial positions in a given society fueling fire here, or that such foothold were ever so present, and the concept of glass ceiling were points of mythology.  The problem with all of this that I have had with this is that in so many words, a year or so ago, online social gaming appeared to trending south and I mean south, not that one should hear in any event among the crowd anything about vast conspiratorial social network webs in the discussion in as much as witnessing manifestations of these individuals.

    The less than coincidental rise of youth, or male parent alike, engaged in the manner of stating 'ah prom night, you know, she's not such a good date unless she's really drugged'.  Such a rise in trending social behavior weren't given to the draconian paroxysm, account bans or anything of this sort.  If it weren't enough that social dialogues, however, in any time given to the occasion given to the sort  of intermittent nature that it were, should have any number engaged in the supposed digressed cacophony of social chatter, making any more desirable muting a given channel.  The real problems of consequence, however, here in time weren't that 'mute' weren't enough, apparently it weren't enough when invasion of personal computing space commenced.  Apparently, for whomever, effectiveness in dealing, I'd imagine were given to the sort of brute force intimidation meant to silence individuals.  Of course, in some ways these people managed to run people out of games in so many words, and likely have secured their social place in gaming.   You deal with these sorts of social cooperative, and at times the cult like mistrust of one another, the impression these days are trends of a sort that one might sense were of an absoluteness.  If saying anything could be enough warrant of suspicion in driving another key logger, or some exploiter.  These Juarez/Isil impressed youth only seek understanding, as to their impressing plausibility of conspiracy, I'd leave it up to the reader for a closer read.  Dan Brown would have a much hard time selling a novel in this form.   I left an mmorpg running on close to a year ago because of the problems in that area of gaming, and generally saw much trending in just bad online social behavior coupled with any number of hacking incidents that I personally dealt with....if you are given to conspiracy, I'd offer its a rise more of these sad sick nut jobs.

    In the meantime, there is the issue of internet censorship for all one could tell, or if it couldn't be suggested enough, in efforts to another round of blaming the victim, that writing standards weren't up to par, or little understood, conspiracies undoubtedly are a given...here the sort of those engage with the wink and a nod cater much into all this.  At times, but its certainly not given to the outsider nerd rage davidians of the world faced down by feminist Goliaths, or in so many words Hooveresque sickos fill their lot with persecution mania only makes the charge even more laughable (so likely true for those engaged in systematic ways of persecuting others to feel persecuting...that is classic), likely they fill the world with something of a predominant hand, not the other way around more obviously at times, especially when big gaming corps cater in so many words with game play, and isn't that conspiracy theory more likely to ring true?