| DOSE: |
125 mg |
insufflated |
Methylone |
(powder / crystals) |
Description of Mindset & Setting:
In a word, reluctant. I had some 1000 mg of methylone in my possession and was excited about *eventually* exploring this relatively rare and structurally intriguing phenethylamine, though it had not been in my plans the day the experiment took place. I had mentioned the fact that I had acquired some methylone to a friend who shares my interests in entheogens, whereupon persistent pleading to 'bring some out' commenced. After a few hours, during which time my resistance and better judgement was weakened by the consumption of a few beers, I eventually acquiesced and brought out approximately 250 mgs of the material.
Details of any preparations made for the experience:
As a sort of 'compromise', we decided to insufflate 125 mgs each. This might not seem like much of a 'compromise' to some, but my friend and I are a couple of hard heads who usually require heroic doses of any substance in order to attain significant effects. Had this been a planned excursion into altered states, we would have started early in the evening with a large oral dose (perhaps 250-400 mgs). However, it was already relatively late (around 11:00 P.M.), so we 'reasoned' that 125 mgs insufflated would enable us to have a real sense of the material's potential without committing ourselves to a long experience.
Dosage & Timing Information:
The material was a fine, white powder with that delicious root beer/licorice like odor that so often accompanies chemicals of this class. The insufflation was quick and painless, leaving a pleasant after taste.
There was the usual apprehension one feels after consumption but prior to first alerts, which were noticed at around the 10 minute mark. I wasn't expecting much from this material, having heard from several sources that its effects were comparable to MBDB, a substance I am familiar with and do not find particularly interesting. I was shortly to find myself rather pleasantly surprised by the unexpected place this chemical took me.
What, if anything, you learned from the experience:
The experience was entirely satisfying. Like many experienced entheogen users, it had been a long time since I experienced any of the magical qualities associated with a memorable dose of MDMA.
While there was certainly none of the 'all out bliss' or coveted 'state of grace' afforded by MDMA, I found that methylone did neverthless present, in its own reserved manner, a significant degree of those qualities that I had been so sorely missing.
Like MDMA, it creates a sense of 'entactogenisis'; at some point, I stop asking yourself 'am I liking this?' or comparing the effects to MDMA, and simply accept what the drug has to offer. I acknowledge what it is *not doing* (ie. it is *not visual*, it is not *intensely euphoric*), but these 'shortcomings' are increasingly irrelevant, as I find that *what it is doing* is entirely satisfactory. Consideration of its relative place in the pantheon -- its relative strengths and weaknesses -- is something that can wait for *after* the effects have worn off. While it lasts, its *perfect* -- I don't need anything else.
While, as I have noted, the overwhelming euphoria of MDMA was not present, I was nevertheless struck by how profound the sense of 'everything is *perfect* just as it is' was; I had not experienced this degree of contentment and 'entactogenisis' since my first few ecstasy experiences. I noted at the time that this suggests that the entactogenic effect apparently can be divorced from the 'hyper-euphoric' effect, suggesting that different aspects of brain chemistry are involved.
Both thought and communication flowed effortlessly, and I found I was able to see myself objectively -- my psychological strengths and weaknesses -- in a way that was more productive and meaningful than similar experiences on MDMA.
On MDMA, there is more of a sense of being *stoned* -- not entirely 'myself'- and especially, not entirely in control of my emotions. I often find on MDMA that it is not possible to indulge in such self reflection without occasionally being overwhelmed by feelings of sadness or guilt -- as well as *bliss* and *grace* of course ;)
On methylone however, you are in complete control of your emotions. You can examine the shortcomings in yourself and your relationships without fear of crippling pangs of guilt or sadness, and you can acknowledge and appreciate your strengths and the strengths of others in a manner that seems much more lucid and meaningful. I think this material may have considerably more therapeutic potential than MDMA, as it seems to allow the same sorts of valuable insights and critical self analysis, but it does so in a clear headed manner which seems far more 'real' and more likely to be productively integrated into ones every day life afterwards.
I also found that the material was valuable as an empathogen, in a manner that is far more subtle than MDMA but no less profound.
On MDMA, you may find yourself spontaneously 'in love' with all of humanity, yet if you were to be asked *why* you suddenly felt this empathy, you'd likely just stare blankly, smiling. On methylone however, I found that I had *reasons* for my feelings of empathy. Specifically, it occurred to me that the fact that we are all impacted upon by the same fundamental crisis -- the trauma of mortal existence in an enigmatic universe -- was more than sufficent rational justification for unbound empathy.
It occurred to me how incongruous it is that most of us will overlook someone's transgressions and extend to them a *special kindness* upon hearing, say, that they had just been given 6 months to live, failing to recognize that at the same time, here we are -- all of us -- living out our lives under the death sentence handed to us at birth: *We are all* deserving of that *special kindness*, all the time, and we all have something quite profound and intimate in common -- the enigmatic, tragic beauty of existence itself. How can I not love them all? One thought recurred to me again and again as I felt this 'rational empathy', which seemed to sum it all up -- there is no such thing as a stranger.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Writing a code generator (Part 1): Introduction
For some time now I’ve been working on writing a game in C from scratch (using OpenGL and GLFW). To make my life easier and to prevent some mistakes I have developed a generator and a custom made scripting language to create C-files.
I think the whole process could be interesting to some people out there, so I decided to explain what I have done step by step in this and the next few posts. In this part I will give an overview of the language we will implement and give a general outlook what to expect.
During development I often needed to access specific array elements. The easiest way to do so is to define an enum which constants corresponds with the index of the element in the array. The only shortcoming of this method the manual, error prone process to fill the array.
To register a new component type to the ECS I have to call a function with component specific arguments. So the order in which the components are added has to match the order defined in the enum which contains all component types. Doing so manual is tedious and error prone. Every time I want to register a new component type the type needs to be added to the enum and the array insertion needs to happen in the right order. A far better way is to automate the process of adding new components and let a code generator do the work.
The main idea is that the enum constant and the arguments for the insert function are stored in the same array and the tool generates a enum and a function that fills the array in the right order. Additionally the tool can generate functions to convert enum constants to strings and back for serialisation purposes.
My first attempt, while producing the desired result, was rather bad and not very extensible. Nothing where I could add new features as I needed them. So I rewrote everything. For my second attempt I refined the syntax for the scripting language used to generate the code, with what I learned from my prior mistake. And with the help of Bob Nystrom’s book Crafting Interpreters I managed to create a program that satisfied my requirements.
Disclaimer: This is not the only or best way to do this. This is just how I have done it. I am by no means an expert. Maybe it helps with your project or maybe you get inspired to do something better.
Since this tool is written for my game which is written in C the language this tool will generate to will be C. But if you need to generate code for another language the changes you need to make to this tool are mostly trivial, as long as the language supports some kind of enums.
The Scripting Language
Before we can start programming we should first talk about the language. The single purpose of the language is to tell the generator how the C file should look. So there is no need to support any arithmetic operations. As a result the language is more of a markup language, that tells the generator how the C file should look.
I have no idea how to name this language so I’m just gonna call it the language, until I come up with something better.
The syntax and the features of the language are heavilly dependent on the target language the generator should generate. During development of the generator the language underwent many changes (mostly during the first attempt) and like every other programming language the scripting language will continue to be in (nearly) constant development. So the language will mature and evolve with time, but for now it does everything I need.
Let’s start with the syntax of the language. The first thing to know is the language ignores whitespaces like newlines and tabs, so indentation doesn’t matter and you can format the code whatever way you like the most. The language also supports comments. A comment starts with a ‘#’ and continue to the end of the line.
For now the generator ignores comments, but it could be useful to just copy them into the header file.
In C (and C++) header files should have a way to avoid double inclusion and we want to stay standard (so no #pragma once), we need some way to define an include guard. And I dont think automatically generating the name for the guard is worth the effort. So the first line of every script must be define followed by an identifier representing the name.
1
define ECS_LOADER_H
If you need to include header files into the generated code (which in most cases will be necessary) you can pack them all together into one include statement. Inside the block the several include statements are represented by multiple strings seperated by commas. An include block could look something like this:
1
2
3
4
5
6
7
8
include
{
"Ecs/Ecs.h"
"Components/Transform.h",
"Components/RigidBody.h",
"Components/Animator.h",
"Components/Sprite.h"
}
The Core of the language
The core of the language are enums and generate expressions. A new enum is defined with the keyword enum followed by a name. They are the only thing close to a data type in the language. The body of an enum is a collection of arrays encapsuled by braces. Arrays are comma separated values between brackets. And each of these arrays contains a name, which will be translated to a constant in the resulting C-enum, and an optional list of arguments for the generate function.
Enums are the only thing close to a data type. They are used to generate functions which is explained below.
1
2
3
4
5
6
7
enum ComponentType
{
[ COMPONENT_TRANSFORM, $SIZE(Transform), NULL ],
[ COMPONENT_RIGID_BODY, $SIZE(RigidBody), NULL ],
[ COMPONENT_ANIMATOR, $SIZE(Animator), AnimatorFree ],
[ COMPONENT_SPRITE, $SIZE(Sprite), NULL ]
}
Each enum will automatically be translated into a C-enum. For everything else we need to use the generate keyword. This keyword is used to generate functions and can be used in two different ways.
If generate is followed by a specific keyword (for now only strings) a predefined function will be generated. E.g. generate strings will generate two functions to allow the conversion from a string to an enum constant and back.
1
generate strings: ComponentType
If generate is followed by any other identifier the generator will generate a function with the name given by the identifier which calls the function specified after the arrow operator (‘->’) for every element of the enum specified before the arrow.
1
generate RegisterComponents(Ecs* ecs): ComponentType -> EcsRegisterComponent(ecs)
The function declaration with all of its parameter is defined right after the generate keyword. After the colon is the enum with which the function shoud be generated. After the arrow operator the function, which should be called with the arguments of each enum element (excluding the name of the element), is defined. The arguments inside the parentheses after the to-be-called function are placed infront of the argument of the enum element.
A possibly useful upgrade would be a way to specify which argument of an enum element is needed in what order. This would allow to have multiple generate calls for one enum.
To fully understand how the generate keyword works, let’s just take a look at what the output for our example looks:
1
2
3
4
5
6
7
void RegisterComponents(Ecs* ecs)
{
EcsRegisterComponent(ecs, sizeof(Transform), NULL);
EcsRegisterComponent(ecs, sizeof(RigidBody), NULL);
EcsRegisterComponent(ecs, sizeof(Animator), AnimatorFree);
EcsRegisterComponent(ecs, sizeof(Sprite), NULL);
}
If there are still things unclear just wait until we implement the generator (probably part 4).
Macros
The above example already uses another feature. Namely macros. They are defined by ‘$’ followed by an identifier. Currently the only macro supported is $SIZE, which translates to the C-operator sizeof. But the way macros are implemented makes it pretty easy to add more.
Macros are used to have function calls as arguments inside an enum. The arguments of an macro are just getting copied to the the output file, so nested macros are not possible. Also Macros can have any number of arguments as long as they match the C-function they correspond to.
In a later version it will probably be possible for the user to define macros. But for now it is easier to just add new macros manually.
Annotations
Annotations are a way to change the behaviour of an enum. They are defined before an enum with @AnnotationName. An annotation is a name with an asociated value inside parentheses. Currently the only annotations are COUNT and START. COUNT defines a constant after the enum, which has the number of constants in the enum as value. The value of COUNT has to be a string and sets the name of the constant. START sets the value of the first constant in the enum to the value of START. The value of START has to be an integer.
1
2
3
4
5
6
7
8
9
@START(3)
@COUNT("NUM_COMPONENTS")
enum ComponentType
{
[ COMPONENT_TRANSFORM, $SIZE(Transform), NULL ],
[ COMPONENT_RIGID_BODY, $SIZE(RigidBody), NULL ],
[ COMPONENT_ANIMATOR, $SIZE(Animator), AnimatorFree ],
[ COMPONENT_SPRITE, $SIZE(Sprite), NULL ]
}
The above defined enum would translate to the following C-enum:
1
2
3
4
5
6
7
8
9
typedef enum
{
COMPONENT_TRANSFORM = 3,
COMPONENT_RIGID_BODY,
COMPONENT_ANIMATOR,
COMPONENT_SPRITE
} ComponentType;
#define NUM_COMPONENTS 4 /* size of ComponentType */
What’s next
Thats all for this part. There are various ways this language and the generator could be improved. But these features are either too complicated or are simply not needed for now.
In the next part I will talk about how we can parse the script file into a more manageable format. I will explain the concept of Tokens and I will show how I implemented a scanner to tokenize the script file.
If something was unclear or you have some (constructive) critisim, feel free to leave a comment or write me on twitter.


?HŽrbario
del
Colegio
de
San
Pablo
/
a.
S'’i'isf.
Nom.
vulgar-----------------------
Co
I
./ê!2tL-Ÿ;.k
Fecln...........M’ttL’±ÀJL.
1605180
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


|
transwarp
|
Static Public Member Functions | |
| template<typename Result , typename Task , typename... ParentResults> | |
| static Result | work (std::size_t task_id, const Task &task, const std::tuple< std::shared_ptr< transwarp::task< ParentResults >>... > &parents) |
|
inlinestatic |
Use first type as reference


{{ post.title }}
{{ post.content | truncatewords:40}}
Read More about {{ post.title }}
--- layout: default ---
Abandon all hope, ye who enter here. Seriously though, the view expressed in these posts should only be taken at face value if you agree with them completely. If not then I was joking, hahaha. I am funny.


Syntax:
first list => object
second list => object
third list => object
fourth list => object
fifth list => object
sixth list => object
seventh list => object
eighth list => object
ninth list => object
tenth list => object
(setf (first list) new-object)
(setf (second list) new-object)
(setf (third list) new-object)
(setf (fourth list) new-object)
(setf (fifth list) new-object)
(setf (sixth list) new-object)
(setf (seventh list) new-object)
(setf (eighth list) new-object)
(setf (ninth list) new-object)
(setf (tenth list) new-object)
Arguments and Values:
list---a list, which might be a dotted list or a circular list.
object, new-object---an object.
Description:
The functions first, second, third, fourth, fifth, sixth, seventh, eighth, ninth, and tenth access the first, second, third, fourth, fifth, sixth, seventh, eighth, ninth, and tenth elements of list, respectively.  The same equivalences apply. For example:
(setf (fifth list) new-object) == (setf (car (cddddr list)) new-object)
Examples:
(setq lst '(1 2 3 (4 5 6) ((V)) vi 7 8 9 10)) => (1 2 3 (4 5 6) ((V)) VI 7 8 9 10) (first lst) => 1 (tenth lst) => 10 (fifth lst) => ((V)) (second (fourth lst)) => 5 (sixth '(1 2 3)) => NIL (setf (fourth lst) "four") => "four" lst => (1 2 3 "four" ((V)) VI 7 8 9 10)
Side Effects: None.
Affected By: None.
Exceptional Situations: None.
See Also:
Notes:
first is functionally equivalent to car, second is functionally equivalent to cadr, third is functionally equivalent to caddr, and fourth is functionally equivalent to cadddr.
The ordinal numbering used here is one-origin, as opposed to the zero-origin numbering used by nth:
(fifth x) == (nth 4 x)


A cloud-native solutions architect and software engineer. Specialises in modernising distributed applications and serverless architectures.


{#include AdvisorOpenshift/insightsEmailBody} {#content-title}OpenShift - Advisor Instant Notification - {action.timestamp.format('d MMM uuuu')}{/content-title} {#content-body}
|
|
Your cluster {action.context.display_name} has {action.events.size()} new recommendations. |
|
|
|
New recommendations affecting
{action.context.display_name} |
|


Medical Tutor Laboratory at DBMI, University of Pittsburgh
SlideTutor
About SlideTutor
Use SlideTutor
Documentation
FAQ
Feedback
Laboratory
People
Research
Publications
Acknowledgements
Awards
Funding
Contact Us
Last Updated: 05/11/2006 | Supported by:
NCI
,
NLM
|
UPMC
|
Contact Us


Wayne Bennett's England record to be considered in RFL Lions tour review
by PA MediaWayne Bennett's track record as England coach will be taken into consideration when the Rugby Football League conduct an inquest into this winter's disastrous Great Britain tour.
Bennett's contract with the RFL ran out at the end of the Lions' winless tour of the Southern Hemisphere and chief executive Ralph Rimmer confirmed a decision on the Australian's future will not be made until the new year.
Before then, Rimmer and RFL director of rugby Kevin Sinfield will lead a wide-ranging review into the tour, with input from all stakeholders including the players and most likely Bennett himself.
Rimmer insists Bennett remains keen to take England into the 2021 World Cup and that performances on the Lions tour will not be the only factor in the review.
"We shouldn't forget what Wayne has done up until this point," Rimmer said. "Yes, we had a poor year on the field and nobody can deny that.
"We all hurt - the players, coaching staff and everybody involved in it hurt - but until this point we have progressed really well. We came very close to a World Cup and we beat the Kiwis last year.
"We're doing the review now - it's important that it's considered, reflective and not reactionary to come up with the right answers.
"We'll take until the end of the year and there will be some recommendations from that which will go to the RFL board in the New Year. We want to win a World Cup in 2021 and need to make sure we're on track to do that"Ralph Rimmer
"We'll take until the end of the year and there will be some recommendations from that which will go to the RFL board in the New Year. We want to win a World Cup in 2021 and need to make sure we're on track to do that."
Bennett has been heavily criticised following the Lions' defeats by Papua New Guinea, New Zealand and a Tonga Invitational XIII and fingers have also been pointed at Sinfield, who combines his RFL role with that of director of rugby at Leeds.
Asked if Sinfield's position with the governing body is under threat, Rimmer said: "No, it's not something we have to consider. Kevin is doing the review with me and that's it."
Bennett said the absence of a mid-season Test was partly to blame for Great Britain's defeats and Rimmer says talks are ongoing over a fixture for England next June, ahead of the visit of Australia for next year's three-Test series.
That game is likely to take place in the Southern Hemisphere, with either the Kiwis or Samoa providing the opposition.
Rimmer, who ruled out a return of the Exiles team, also said midweek fixtures for the Australian tourists in 2020 remain a possibility.


 The /live/update/liquidate
API accepts requests in the following format:
LiquidateLiveAlgorithmRequest Model - Request to liquidate a live algorithm. |
|
|---|---|
| projectId | integer Project Id for the live instance we want to liquidate. |
| Example |
{ "projectId": 0 } |


Everyone is trying to guess these cryptic Liverpool place names
The list has gone viral on social media
by Sophie McCoidA list of cryptic Liverpool place names has gone viral, with hundreds of people trying to guess where the clues relate to.
The list of 20 clues posted to twitter, has got hundreds of people scrambling to figure out what places the clues point to.
Posted to social media by @80mandymoo, she said: "Whereabouts in Liverpool are u?"
The first clue was "Shake a Bush" which some clever commenters deciphered as Wavertree.
Other clues included "Wet Toilet" - Waterloo, "The Execution of a reptile" - Croxteth, and "Talk" - Speke.
But others simply eluded people on Twitter, with many commenting on how difficult some of the clues were.
Hannah said: "This is proper hurting my head."
@joer_j said: "Can only get about 5 of them."
But Lee Mc said: "These are boss." and asked if Mandy had anymore to share.
Others were sad there was no clue for Fazakerley - although we're unsure what that would have possibly been.
How did you get on? Let us know in the comments.