In recent years, soccer has been characterized by dynamic changes in the physical activity of players during the game. There are continuous, but unpredictable, changes occurring at different intensities throughout the match. Players must perform different types of speed-related movements (in place or moving), rapid movements of different parts of the body (e.g. the lower limbs), and must respond to various, potentially unpredictable situations occurring during the match. Speed-related movements include: the individual attack, returning to a defensive position, or, in one-on-one interactions, passing the defender, and unpredictable movements by the attacker to surprise the defender. In most cases these actions are preceded by starts from different positions and different directions.
Speed, as a motor function and ability in soccer, is based on running at a maximum sprint speed for less than a 30-m distance (96% of sprints during a soccer match), accelerating for less than 10-m (49% of sprints occurring during the match), and sprints with change of direction (COD) movements (every 2-4 seconds). CODs involve movements in different directions (left, right, forward, backward) and at different angles (Comfort et al., 2014; Little and Williams, 2005; Sporis et al., 2009; Stolen et al., 2005). Akenhead et al. (2013) found that the English Premier League soccer player, on average, sprints (>5.8 ms-2) for 2% of the overall distance traveled in the match, engages in high-speed running (>6.78 ms-2) for 5% of the total distance traveled in the match, covers 10% of the total distance in acceleration motions, and spends 8% of the match in stopping movements. In turn, professional players from the English FA Premier League can perform on average more than 8 CODs per minute during a match. Therefore, an effective soccer player (the attacker or defender) should have the ability to move at high speeds in a straight line, or most frequently, while performing COD movements or changes of running pace (Carling et al., 2008; Hachana et al., 2014). In contrast to short sprint episodes, multiple accelerations over short distances, frequent stop-movements, and repeated COD movements all require different repositioning techniques that are key with respect to soccer playing ability. Most often, these movements occur as a reaction to stimuli that the players are constantly experiencing throughout the game (Gonçalves et al., 2015; Šimonek et al., 2016).
The impact of COD on a soccer players' movements as their physical activity increases during the match remains a topic of current research and analysis, as researchers seek to identify the determinants of these movements. Numerous soccer studies have focused on the relationship between sprints, CODs, and jumping abilities; however, the results have been inconsistent. Some studies showed a strong correlation between these variables, while others showed poor relationships. In a study by Little and Williams (2005) on a group of 106 English soccer players, it was found that between COD speed (evaluated using the Zigzag test), starting speed (acceleration), and maximum speed achieved, there were statistically significant correlations. However, the determination coefficients between the tests were low (from 0.119 to 0.388). Based on these findings, the authors concludes that COD speed and straight sprints are characteristic and independent motor skills among soccer players (Little and Williams, 2005). Similarly, strong and moderate correlations between acceleration, maximum speed, and results of the Zigzag agility test were reported by Köklü et al. (2015), based on their investigation of 16-year-old soccer players.
The relationship between COD movements and vertical and horizontal jumps has also been explored. In the studies of Struzik et al. (2017), they investigated 12-year-old soccer players. They found no significant links between counter-movement jumps (CMJ) and CODs during sprints. Rouissi et al. (2017) found no significant correlation between standing broad jump (SBJ) and COD performance. In contrast, Young and Farrow (2006) and Lockie et al. (2014) indicated that leg power was an essential component of COD speed. It is believed that team players who achieve higher jump results will probably achieve faster times in multidirectional speed tests. The relationship between speed and jumping ability has also been investigated. However, according to Marques and Izquierdo (2014), the relationship between speed and strength of the lower limbs should be interpreted with caution.
Since the majority of COD runs in soccer matches occur at angles between 1° and 90°, which are specific to soccer, it is important to determine COD speeds at these angles (Faude et al., 2012; Hader et al., 2015). In addition, the defending player often moves away from the attacker for a short distance using controlled backward running followed by forward sprinting (Hammami et al., 2016). A high-level of skill is required to combine COD movements, changes of movement type, and re-accelerations. The backward, run as an unorthodox movement, occurred over 5.3% (± 2.4%) of the total match time, according to one study (Krustrup et al., 2009). Some researchers suggest that speed, COD and strength of the lower limbs should be measured and evaluated using separate tests (Buchheit et al., 2012; Cardoso de Araujo et al., 2018; Sheppard and Young, 2006; Silva-Junior et al., 2011). In turn Castagna et al. (2003) indicated that a strong differentiation between forward, backward, and sideways motion exists. Presumably, COD movements should be measured with various tests in which the subject would perform forward, backward, and sideways motions.
There are a small number of studies that have used multiple regression models to identify associations between sets of variables such as vertical and horizontal jumps (e.g., CMJ, SBJ), linear speed (e.g., 10-m sprint, 30-m sprint), COD sprints, and other patterns of movements in young soccer players. Determining the models of these variables will provide increased knowledge of the key determinants of motor behavior in young soccer players. It is helpful to evaluate motor ability levels using a battery of tests to optimize the training process (Northeast et al., 2017). Such models may contribute to a more effective selection and specification of the game performed by each player through enhanced physical preparation and skill acquisition (Köklü et al., 2015). Therefore, the purpose of these studies was to investigate the relationship between linear speed (straight-line sprinting) and jumping ability (lower extremity explosive power measured through horizontal and vertical jumping) on COD performance measures (COD-speed) in young soccer players. We aimed to determine the variables that can explain the effectiveness of COD speed using the 30-m ZigZag (cutting maneuver) under 60° and the 30-m sprint divided into forward-backward-forward movement. This is the first study defining the performance of change-of-directions under 60° based on times measured at 5m, 10m, 15m, 20m, 25m and 30m in the test. Additionally, the first research on the determination of performance change-of-direction forward-backward and backward-forward during the 30-meter distance was conducted.
We used a multiple regression model to identify associations between the set of variables to be developed that could determine the efficiency of COD movement patterns. We hypothesized that there is a strong relationship between the results of straight-line sprinting and jumps and the two tests defining COD speed in young soccer players.
Soccer players at different competitive levels were recruited to better generalize the results of the study. The research was conducted during the soccer season to avoid additional confounding variables. It included a wide battery of tests comprising maximal speed (30-m sprint), COD movements, and horizontal and vertical jumping tests (CMJs and SBJs), which are commonly used in soccer training. The experiment was carried out in the Chair of Ball Games Research Laboratory in the University School of Physical Education in Wroclaw, with an ISO 9001:2009 certification, in collaboration with the Lower Silesia Sport Federation in Wroclaw, Poland. The study was conducted over one afternoon.
We included 60 male soccer players from the Lower Silesian sports clubs, who participated in the Central League of Junior Championships in Poland. The mean age of the participants was 17.4 years (± 0.7 year), mean height was 176.3 cm (± 6.1 cm), and mean body weight was 68.1 kg, (± 8.9 kg). The average length of training experience of the players was 78.3 months (± 29.8). The general characteristics of the players are shown in Table 1. Before the tests, each participant was informed about the aims of the research and the benefits and risks of the investigation. In the case of minors, parents/guardians were informed about the purpose of the study and the benefits and risks of the investigation. The same procedure was carried out with the coaches. They were also aware that the study was approved by the Senate's Research Bioethics Commission at the University and that the procedures complied with the Declaration of Helsinki concerning human experimentation. The parents/guardians of the participants younger than 18 years provided written consent, and participants older than 18 years provided their own written consent for participation after being thoroughly informed about the study as described above.
30-m Sprint Test (30S): In each case, the participant took a high starting position behind the starting line with his preferred forward leg in position. The toes of the forward leg were close to the starting line and the rear foot was placed on a SMART JUMP mat (a reactive mat that captures false starts; a part of the Fusion Smart Speed System [Fusion Sport]) 30 cm from the starting line. When a specified light beam started flashing (the trial start time), the athlete began running as fast as possible to a cone that was placed 2 m beyond the final gate, which was located 30 m from the starting line. The fastest time of 3 trials was used in the data analysis. The participants were given a 3-min rest break between each of the trials, which was sufficient for the athlete to fully recover. The sprint times measured were: total 30-m sprint time, 10-m starting time, and peak sprint speed at each 5 m (5-m vSprint). The intraclass correlation coefficient (ICC) for the times recorded by the participants was 0.80 (95% Cl; 0.72-0.87) and the CV (coefficient of variation) was 6.11%.
Best time (5-m bCODS¹) was recorded as the best time at 5-m in the 30m CODS¹ test.
30 m COD² Sprinting Test (30CODS²): The 30CODS² test (30-m forward/backward/forward sprint) is a modified SBF test (9-3-6-3-9 sprint with backward and forward running). The SBF test was previously described in the literature by Hammami et al. (Hammami et al., 2017). The test was carried out using the same distances as in the 30S and 30CODS¹ and was divided into the following sections: a 15-m forward run, a 5-m backward run, and a 10-m forward run (Figure 2). The COD of the run was determined by crossing the lines of each section with both feet. The run was required to proceed in a straight line, or as straight as possible so as to limit the loss of time-trial (the execution time for the entire test). The following timing parameters were used to analyze the results: the 10-m starting speed time (10-m CODS²), the 10-m COD time (F&BCOD) which was the time of COD from forward to backward (measured between 10-m and 20-m of the entire 30-m distance), the 10-m COD time (B&FCOD), which was the time of COD from backward to forward (measured between 15-m and 25-m of the entire 30-m distance), and the 30-m final time (30-m CODS²). The ICC for the times recorded by the participants was 0.94 (95% Cl; 0.91 – 0.96) and the CV was 5.67%.
Counter-Movement Jump (CMJ): Players performed a vertical height jump with arm swing on a hard flat surface. We used an optical measurement system (Optojump; Microgate Engineering, Bolzano, Italy) to measure the height (cm) of the jumps. The participants performed three jumps and the best (the highest) was recorded for the analysis.
CMJs were performed starting from a standing position. Participants were instructed to keep their hands on their hips during the jump. Each player was instructed to jump as high as possible. Each jump was performed as an initially rapid preparatory downward eccentric action (Dello Iacono et al., 2016).
The height of each jump (CMJ) was calculated using the flight time. A minimum of 2 minutes of recovery was provided between each repetition and 5–6 min between each jump modality. The ICC for the scores recorded by the participants was 0.93 (95% Cl; 0.88 – 0.96) and the CV was 8,5%.
Standing Broad Jump (SBJ): From an erect position with the feet placed in parallel and with legs bent at the knee as close to a 90° angle as possible, the player performed the SBJ. He was instructed to jump as far as possible and land on both feet without falling backwards. The test result was measured from the start line to the rear heel edge, or whichever part of the body that was closest to the starting line after the jump (Rouissi et al., 2017). The jumping distance was measured to the nearest 1.0 cm. Three trials were executed by each participant and the longest distance was recorded for analysis. A minimum of 2 minutes of recovery was provided between each trial. The ICC for the scores recorded by the participants was 0.92 (95% Cl; 0.87 – 0.96) and the CV was 6,71%.
Overall, the test procedures did not specify the methods of starting and changing. The direction of the race was dependent on the individual's preferences and the unique skills and abilities of the players.
The data were processed using Statistica 13.0 for Microsoft Windows (Microsoft Corp., Redmond, WA, USA). Data are first presented as means ± standard deviations (SD), and 95% confidence intervals (Cl). The distribution of each variable was examined for the assumption of normality using the Kolmogorov-Smirnov test. Correlations were determined using Pearson's product moment-correlation coefficient (r). The magnitudes of the correlation coefficients were stratified into groups comprising: trivial (r < 0.1), small (0.1 < r < 0.3), moderate (0.3 < r < 0.5), large (0.5 < r < 0.7), very large (0.7 < r < 0.9), nearly perfect (r> 0.9) and perfect (r = 1.0) (26). A multiple stepwise regression analysis (forward and backward stepwise methods) was used to adjust the influence of the functional speed and the variations in the explosive power variables analyzed in the 30CODS¹ and 30CODS². In the multiple stepwise regression models, only independent variables were used and linear correlations with dependent variables were statistically significant (p <0.05). In addition, between the independent variables, a relationship between nearly perfect and very large correlation coefficients was not observed (non-co-linearity of variables). In addition, based on a residual regression analysis, the residuals were distributed normally.
Table 1 shows descriptive the means±SDs and 95% CIs of the maximum and minimum scores. Several significant correlations of different strengths were found in the studies (Table 2). A nearly perfect correlation was observed between the 30-m CODS1 and 5-m bCODS1 (r = 0.91, p <0.001). The 30-m CODS² was significantly correlated (p <0.001) with the 10-m CODS² (r = 0.75), F&BCOD (r = 0.71), B&FCOD (r = 0.80), 10-m sprint (r = 0.56) and the 30-m sprint (r = 0.60). The F&BCOD was significantly correlated with the B&FCOD (r = 0.72, p <0.001). A significantly (P <0.001) large and very large correlation existed between t10CODM and the 10-m sprint (r = 0.71) and the 30-m sprint (r = 0.65). The 30m sprint was significantly correlated (p <0.001) with the 10-m sprint (r = 0.86) and the 5-m vSprint (r = -0.77). A significantly large correlation existed between the 10-m sprint and the 5-m vSprint (r = -0.53, p <0.001). In addition, significantly large correlations were found between CMJ and SBJ (r = 0.57, p <0.001).
Other significant moderate or small correlations between variables were also observed (Table 2).
A multiple stepwise regression was developed and independent variables were used to determine the variance of the CODS² properties (Table 3).
The 10-m sprint variable explained 50% (p < 0.001) variation for the performances in the 10-m CODS², while the 30-m sprint variable explained 36% (p < 0.001) variation for the performances in the 30-m CODS². The 30-m sprint variable explained 51% (p < 0.001) variation of the performances in F&BCOD, whereas body mass was explained by an additional 7% (p = 0.003) variation. On the other hand, the variable for COD under 180° from backward sprint to forward spring was explained by a 10-m Sprint variable (12%, p = 0.006).
Reconstructed regression models were calculated to determine the most robust predictors of COD¹ (by 60°). The regression models created for the variables were explained (from 8% to 10%) by only one in the group of variables that were analyzed in this study. The variation for 5-m bCODS¹ was explained only by the SBJ (9%, p = 0.018). However, the variation for properties of the 30-m CODS1 variable based on the general time required for COD at a 60° angle was explained only by the 30-m CODS² variable (8%, p = .026). The SBJ variable explained the 10% variation (p = .015) in the performances of CODS¹dec (Table 4).
The fundamental goal of this study was to investigate the effects of linear speed and jumping ability (lower extremity explosive power) on COD agility performance measures, such as the 30-m CODS¹ and 30-m CODS². We noted that important relationships existed between the 30-m CODS² and the 30-m sprint. In both trials, the forward movement was the most common. However, the overall result of the 30CODS¹ test was strongly associated with the total time for the 30CODS² test and the best time at a distance of 5-m in the CODS¹ test. The results of the SBJ were negatively related to the results of the speed decrease or best time at a distance 5-m in the 30CODS¹ test and were positively relation to jump height in the CMJ. Also noteworthy is the lack of a significant relationship between CMJ height and other variables (exception: relation to 5-m vSprint). The relationships between the jumps and the 30CODS¹ test and 30CODS² indicate the need to carefully interpret these relationships. Similar recommendations were suggested by Marques and Izquierdo (2014).
The above relationships confirmed the results of other research. Köklü et al. (2015) studied 16-17-year-old soccer players (n=16) and found a moderate correlation between the Zigzag test without using a ball (COD under 100° angle) and the 10-m sprint. Similarly, the ZigZag agility test without the ball strongly correlated with 30-m sprint times (Little and Williams (2005), who analyzed England's professional soccer players found significant correlations between the 10-m Sprint and the ZigZag test (r = 0.346), and between the 20-m Sprint and the ZigZag test (r = 0.458). Sporiš et al. (2011) analyzed soccer players from the Serbian U-16 national team and also found correlations between the 30-m Sprint and the ZigZag test (r = 56, p < 0.01).
A secondary goal was to examine the potential for developing a multiple regression model that could identify associations between a set of variables to determine the efficiency of COD movement patterns. Based on the multiple regression models that have been created, it has been shown that the 30CODS¹ test time is most closely related to the test results for CODs from forward to reverse and vice versa. This proves the specifics of both tests in which the direction of the run changes. However, a prediction equation for the 30CODS¹dec test and the 5-m bCODS¹ are the most related to the results of the SBJ. Therefore, the type of test should be considered (e.g., CMJ or SBJ) when looking for relationships between COD movements and jump indicators. Based on the analysis of the relationship between COD² and the linear 30-m sprint, the pattern of backward movement performed between 15 and 20 m allows for the determination of the specific skills needed during a soccer match. During the 30CODS² test (from 10-m to 20-m), the participants changed their manner of running from forward (deceleration) to backward (re-acceleration). In addition, at 15 m, the players again slowed down the forward sprint and then accelerated in the second forward sprinting. This requires high-level motor abilities, which are of primary importance among all the skills (technical proficiencies) needed for COD.
It should be stressed that in numerous research papers the relationships between variables such as jumping, sprinting, or COD motions were calculated using simple linear correlations, as noted by Braz et al. (2017). This analytical method allows only two variables to be compared. Only with the forward stepwise method has it been possible to determine the extent of the influence of a set of variables on the effect of a motor action (as a dependent variable). In this study, we found that the 30CODS¹ test result was only 8% explained by the 15-5-10-m sprint test with backward and forward movement (30CODS² test). This shows that this COD pattern (forward/backward) is different from the CODS¹ at 60° angles; however, the results of the 30CODS¹ test and the 30CODS² are dependent upon each other. It can be assumed that variables other than acceleration, straight line sprints, or jumps will determine the results of 30CODS¹ tests in young soccer players. Furthermore, based on the prediction equation for CODS, shortening of the 30CODS² test time by 0.1 s may be important to reduce the 30CODS¹ test time by 0.05 s. Gains in repeated COD performance probably reflect mainly neuronal adaptations and enhanced coordination, which comprise the selective activation of motor units, better synchronization, selective activation and relaxation of muscle groups, and an increased recruitment of motor units (Pyne et al., 2008).
In studies conducted on Brazilian professional soccer players, Braz et al. (2017) investigated the relationship between sprints with and without COD. Based on the multiple regression models, 10-m and 20-m sprint variables showed low explanatory power (≤5%) for COD sprints. Little and Williams (2005) investigated male professional soccer players from the English League teams. They found that the ZigZag agility test was correlated with the 10-m speed test and the flying 20-m test for maximum speed (P<0.001). However, determinants showed that even in the most correlated tests, acceleration and maximum velocity accounted for only 39% of the common variance and should be analyzed separately for soccer players. Thomas and Nelson (2001) argued that if the common variation between two variables was less than 50%, they were specific or somewhat independent.
In the current study, SBJ explained only 9% variance in the regression models for the 5-m bCODS1 and 10% for the CODS¹dec. Prediction equations were prepared for the shortest time at 5-m and the drop-in speed during the 30-m CODS¹ test. A 1 cm increment in SBJ can mean shortening the time of the fastest 5-m CODS¹ and reducing the CODS¹dec by 15%. Hence, the jump associated with horizontal power is related to the rate of COD at which acceleration occurs (Lockie et al., 2014). On the other hand, the CMJ variable did not explain the variance in the regression models of the 30-m CODS¹ at 60°. In a study of 16-17-year-old soccer players by Köklü et al. (2015), a strong correlation was found between CMJ and ZigZag agility (angle100°) without the ball (r = -0.769, p = 0.01). Similar to that, Braz et al. (2017) conducted experiments on Brazilian professional soccer players and noticed significant correlations between CMJ and the ZigZag test. On this basis, multiple regression models were prepared and the results indicated that vertical jump variables including CMJ did not help explain the ZigZag test results (r2 = 11%).
The differences between the studies that determined correlations between jump or speed and COD speed can be explained in several ways. One is that the players have different levels of physical abilities and skills. Another may be related to the distance used in the sprint tests. In studies conducted with young athletes (Lloyd et al., 2013), it was shown that linear speed, strength and power in the lower limbs, anthropometric variables, asymmetry, and perception and decision-making processes may be important contributors to high agility outcomes. Furthermore, rounded and sharp patterns of COD techniques might influence athletic performances, according to Condello et al. (2013). In the literature, other factors including age, level of competitiveness, frequency, and volume of training in the sport, also affected COD speed in soccer players. Köklü et al. (2015) found that 16-year-old soccer players showed moderate to strong correlations between acceleration, maximum speed, and agility (10-m Sprint – 30-m Sprint, r = 0.714; 10-m Sprint - ZigZag, r = 0.567; 30-m Sprint - CMJ, r = 0.599; 30-m Sprint - ZigZag, r = 0.744; CMJ - ZigZag, r = 0.769, respectively).
Some limitations of this study should be acknowledged. First, the tests were conducted indoors to standardize the environmental conditions and the floor surface. Soccer matches are played on natural grass and the difference between the surfaces can affect the way the subjects move. A second limitation is that, although reliability was assessed in the modified tests (30CODS¹, 30CODS²), it is not known whether they have construct validity relative to the standards of play. Third, of the limited data available, comparisons between studies are further limited by the different methodologies used to asses COD ability (i.e. T-test, Illinois agility, 505, ZigZag test). Fourth, differences in the length of the lower limbs and body asymmetry have not been accounted for in this study, but these may be important to the speed and manner of COD. However, there are a small number of studies that have reported the determinants of COD movements at 60° angles and CODs of running forward to backward.
The results of the proposed predictive models for COD, the changes in the form of movement patterns (forward/backward), and the correlation between speed, agility and jump variables presented in this work indicate the constant need to determine these patterns and correlations. Studies have indicated that COD speed (at specified angles) should be analyzed separately from changes in the form of movement patterns because other variables can explain the results of tests determining their level. Variables determining COD were primarily explained by the variables that determined jumping ability. On the other hand, variables that determined speed changes in the form of movement patterns (forward/backward and vice versa) were explained by speed variables. Therefore, our hypothesis that there is a strong dependency between the results of straight-line sprinting and two agility tests used in young soccer players was proved only partially.
The results of this study provide further evidence to suggest that COD speed (CODS¹ under 45° to 60°), CODS² (forward/backward/forward sprint) and straight-line sprinting (30S) represent three different physical qualities in soccer players and probably in other team sport athletes, such as basketball and handball players. Therefore, we should determine these abilities via separate assessments. It is also important that the above-mentioned skills must be developed through a different type of conduction training. Jumping ability demonstrated a strong correlation with 30-m CODS¹, whereas straight-line sprinting was more associated with the 30-m CODS² (forward/backward/forward). Moreover, this study provided data on speed, COD and jumping among youth soccer players in Poland. Practitioners can use this information for comparative purposes, although further research will be necessary to compare the competition standards.
Research interests: The use of the "EDUball" educational ball in primary schools. Talent identification in team sports.
Research interests: Motor learning, motor skill acquisition processes, augmented feedback, swimming science.
Braz T.V., Nogueira J.W., de Assis Cruz W., Businari B.G., de Ornelas F., Brigatto F.A., Germano M.D., Sindorf M.A.G., da Silva J.F., Pellegrinotti I.L., Lopes C.R. (2017) Relation between different variables of vertical jumps and sprints in brazilian professional soccer players. Journal of Exercise Physiology Online 20, 33-46.
Buchheit M., Haydar B., Ahmaidi S. (2012) Repeated sprints with directional changes: do angles matter?. Journal of Sports Sciences 30, 555-562.
Cardoso de Araujo M., Baumgart C., Freiwald J., Hoppe M.W. (2018) Nonlinear sprint performance differentiates professional from young soccer players. Journal of Sports Medicine and Physical Fitness 58, 1204-1210.
Castagna C., D'Ottavio S., Abt G. (2003) Activity profile of young soccer players during actual match play. Journal of Strength and Conditioning Research 17, 775-780.
Comfort P., Stewart A., Bloom L., Clarkson B. (2014) Relationships between strength, sprint, and jump performance in well-trained youth soccer players. Journal of Strength and Conditioning Research 28, 173-177.
Condello G., Minganti C., Lupo C., Benvenuti C., Pacini D., Tessitore A. (2013) Evaluation of change-of-direction movements in young rugby players. International Journal of Sports Physiology and Performance 8, 52-56.
Dello Iacono A., Ardigo L.P., Meckel Y., Padulo J. (2016) Effect of Small-Sided Games and Repeated Shuffle Sprint Training on Physical Performance in Elite Handball Players. Journal of Strength and Conditioning Research 30, 830-840.
Faude O., Koch T., Meyer T. (2012) Straight sprinting is the most frequent action in goal situations in professional football. Journal of Sports Sciences 30, 625-31.
Gonçalves E., Gonzaga A.d.S., Cardoso F.d.S.L., Teoldo I. (2015) Anticipation in Soccer: A Systematic Review. Human Movement 16, 95-101.
Hachana Y., Chaabene H., Ben Rajeb G., Khlifa R., Aouadi R., Chamari K., Gabbett T.J. (2014) Validity and reliability of new agility test among elite and subelite under 14-soccer players. PLoS ONE 9, e95773.
Hader K., Palazzi D., Buchheit M. (2015) Change of direction speed in soccer: how much braking is enough?. Kinesiology 47, 67-74.
Hammami M., Negra Y., Aouadi R., Shephard R.J., Chelly M.S. (2016) Effects of an in-season plyometric training program on repeated change of direction and sprint performance in the junior soccer player. Journal of Strength and Conditioning Research 3, 3312-3320.
Hammami M., Negra Y., Shephard R.J., Chelly M.S. (2017) The effect of standard strength vs. contrast strength training on the Development of sprint, agility, repeated change of direction, and jump in junior male soccer players. Journal of Strength and Conditioning Research 31, 901-912.
Köklü Y., Alemdaroğlu U., Özkan A., Koz M., Ersöz G. (2015) The relationship between sprint ability, agility and vertical jump performance in young soccer players. Science & Sports 30, e1-e5.
Lloyd R.S., Read P., Oliver J.L., Meyers R.W., Nimphius S., Jeffreys I. (2013) Considerations for the development of agility during childhood and adolescence. Strength and Conditioning Journal 35, 2-11.
Lockie R.G., Callaghan S.J., Berry S.P., Cooke E.R., Jordan C.A., Luczo T.M., Jeffriess M.D. (2014) Relationship between unilateral jumping ability and asymmetry on multidirectional speed in team-sport athletes. Journal of Strength and Conditioning Research 28, 3557-3566.
Marques M.C., Izquierdo M. (2014) Kinetic and kinematic associations between vertical jump performance and 10-m Sprint time. Journal of Strength and Conditioning Research 28, 2366-2371.
Northeast, J., Russell, M., Shearer, D., Cook, C. and Kilduff, L. (2017) Predictors of linear and multidirectional acceleration in elite soccer players. Journal of Strength and Conditioning Research, DOI: 10.1519/JSC.0000000000001897.
Pyne D.B., Saunders P.U., Montgomery P.G., Hewitt A.J., Sheehan K. (2008) Relationships between repeated sprint testing, speed, and endurance. Journal of Strength and Conditioning Research 22, 1633-1637.
Rouissi M., Chtara M., Owen A., Burnett A., Chamari K. (2017) Change of direction ability in young elite soccer players: determining factors vary with angle variation. Journal of Sports Medicine and Physical Fitness 57, 960-968.
Ruscello B., Tozzo N., Briotti G., Padua E., Ponzetti F., D'Ottavio S. (2013) Influence of the number of trials and the exercise to rest ratio in repeated sprint ability, with changes of direction and orientation. Journal of Strength and Conditioning Research 27, 1904-1919.
Sheppard J.M., Young W.B. (2006) Agility literature review: classifications, training and testing. Journal of Sports Sciences 24, 919-932.
Silva-Junior C.J.d., Palma A., Costa P., Pereira-Junior P.P., Barroso R.d.C.L., Abrantes-Junior R.C., Barbosa M.A.M. (2011) Relationship between the sprint and vertical jumps' power in young soccer players. Motricidade 7, 9.
Sporis G., Jukic I., Ostojic S.M., Milanovic D. (2009) Fitness profiling in soccer: physical and physiologic characteristics of elite players. Journal of Strength and Conditioning Research 23, 1947-1953.
Sporiš G., Milanović Z., Trajković N., Joksimović A. (2011) Correlation between speed, agility and quickness (SAQ) in elite young soccer players. Acta Kinesiologica 5, 36-41.
Struzik A., Winiarski S., Popowczak M., Rokita A. (2017) Relationships between variables describing vertical jump and sprint time. South African Journal for Research in Sport, Physical Education and Recreation 39, 177-188.
Thomas, J.R. and Nelson, J.K. (2001) Research methods in physical activity. 4th edition. Champaign, IL: Humanics Kinetics.
Young W., Farrow D. (2006) A review of agility: practical applications for strength and conditioning. Strength and Conditioning Journal 28, 24-29.
Šimonek J., Horička P., Hianik J. (2016) Differences in pre-planned agility and reactive agility performance in sport games. Acta Gymnica 46, 68-73.


Impaired social recognition memory in recombination activating gene 1-deficient mice.
The recombination activating genes (RAGs) encode two enzymes that play key roles in the adaptive immune system. RAG1 and RAG2 mediate VDJ recombination, a process necessary for the maturation of B- and T-cells. Interestingly, RAG1 is also expressed in the brain, particularly in areas of high neural density such as the hippocampus, although its function is unknown. We tested evidence that RAG1 plays a role in brain function using a social recognition memory task, an assessment of the acquisition and retention of conspecific identity. In a first experiment, we found that RAG1-deficient mice show impaired social recognition memory compared to mice wildtype for the RAG1 allele. In a second experiment, by breeding to homogenize background genotype, we found that RAG1-deficient mice show impaired social recognition memory relative to heterozygous or RAG2-deficient littermates. Because RAG1 and RAG2 null mice are both immunodeficient, the results suggest that the memory impairment is not an indirect effect of immunological dysfunction. RAG1-deficient mice show normal habituation to non-socially derived odors and habituation to an open-field, indicating that the observed effect is not likely a result of a general deficit in habituation to novelty. These data trace the origin of the impairment in social recognition memory in RAG1-deficient mice to the RAG1 gene locus and implicate RAG1 in memory formation.


text:
Q: What is the difference between DirectorySeparatorChar and AltDirectorySeparatorChar System.io.DirectorySeparatorChar returns the character "\" while System.io.AltDirectorySeparatorChar returns "/"
to be more specific what is the job of System.Io.AltDirectorySeparatorChar and when we use it?

A: From the documentation (https://learn.microsoft.com/en-us/dotnet/api/system.io.path.altdirectoryseparatorchar)

Provides a platform-specific alternate character used to separate directory levels in a path string that reflects a hierarchical file system organization.

You can use alt separator in your path strings the same way as you use normal separator. Like this:
static void Main(string[] args)
{
        string[] pathStrings =
        {
            @"C:\dir\subdir\file.txt",
            "C:/dir/subdir/file.txt",
            "/dir/subdir/file.txt"
        };

        foreach (var p in pathStrings)
        {
            var dir = Path.GetDirectoryName(p);
            var file = Path.GetFileName(p);
            Console.WriteLine($"{dir} {file}");
        }

}

And the output:
C:\dir\subdir file.txt
C:\dir\subdir file.txt
\dir\subdir file.txt

A: My understanding is that DirectorySeparatorChar is platform-specific default separator, while AltDirectorySeparatorChar is platform-independent universal separator.
On Windows : DirectorySeparatorChar is backslash, AltDirectorySeparatorChar is forward slash
On Unix-based : Both are forward slash
It is because Windows natively prefers backslash but also supports forward slash, while Unix-based systems only support forward slash. Practically, it means you can use either one.
I would personally prefer DirectorySeparatorChar, because I simply prefer backslash on Windows. But perhaps the best is to use Path.Combine and let the choice up to this method.

redpajama_set_name: RedPajamaStackExchange


text:
Sociolinguística (380)
(Re-)Locating TESOL in an Age of Empire
J. Edge
descrição:Are TESOL professionals now fairly seen as agents of a new English-speaking empire? Or, if they wish to distance themselves from this role, are there ways of working and living that would make this differentiation clear? An international group of aut...
A Critical Discourse Analysis of South Asian Women...
Linda McLoughl...
descrição:This intriguing book applies Critical Discourse Analysis to a range of South Asian women's lifestyle magazines, exposing the disconnection between the magazines' representations of South Asian women and the lived realities of the target audience. The...
A Cultural Approach to Discourse
S. xu
descrição:Shi-xu critiques universalism in discourse studies in terms of the cultural consequences of its current white, western standpoint and advocates a culturally pluralist approach, a theory and research methodology from an innovative position between Eas...
A Sociolinguistic History of Early Identities in ...
National Institute...
descrição:What role does race, geography, religion, orthography and nationalism play in the crafting of identities? What are the origins of Singlish? This book offers a thorough investigation of old and new identities in Asia's most global city, examined throu...
A Study of Attitudes of Dialect Speakers Towards the...
Patrick Chin Leong...
descrição:This book makes an original contribution to the fields of sociolinguistics, language planning policy and Chinese language studies. It examines the effectiveness of the Singapore's Speak Mandarin Campaign in changing the language use of dialect speake...
Advances in Cultural Linguistics
Farzad Sharifi...
descrição:This groundbreaking collection represents the broad scope of cutting-edge research in Cultural Linguistics, a burgeoning field of interdisciplinary inquiry into the relationships between language and cultural cognition. The materials surveyed in its ...
Advertising as Multilingual Communication
H. Kelly-Holmes
descrição:Advertising has traditionally communicated messages to consumers with strong local and national identities. However, increasingly, products, producers, advertising agencies and media are becoming internationalized. In the development of strategies th...
African Youth Languages
Ellen Hurst-Harosh...
descrição:This book showcases current research on language in new media, the performing arts and music in Africa, emphasising the role that youth play in language change and development. The authors demonstrate how the efforts of young people to throw off old ...
Age and Foreign Language Learning in School
A. Lambelet; R....
descrição:This book discusses the empirical studies on how biological age influences foreign language learning in school. It provides a succinct overview of a complex field for both experts and researchers interested in the teaching and learning of foreign lan...
Analysing Sign Language Poetry
R. Sutton-Spen...
descrição:This new study is a major contribution to sign language study and to literature generally, looking at the complex grammatical, phonological and morphological systems of sign language linguistic structure and their role in sign language poetry and per...
Analyzing Digital Discourse
Patricia Bou-Franch...
descrição:This innovative edited collection presents new insights into emerging debates around digital communication practices. It brings together research by leading international experts to examine methods and approaches, multimodality, face and identity, ac...
Applied Conversation Analysis
C. Antaki
descrição:Much of everyday work is done through talk between practitioner and client. Conversation Analysis is the close inspection of people's use of language in interaction. The work reported in this collection shows how CA can be used to identify, and impro...

redpajama_set_name: RedPajamaCommonCrawl


text:
Bach: Violin Sonata & Partitas - Sebastian Bohren (CD)
Sebastian Bohren
Swiss violinist Sebastian Bohren and his recording of the complete Sonatas and Partitas for violin solo by Johann Sebastian Bach. On volume I the following works have been recorded: Partitas Nos. 2 and 3 in D minor / E Major, Violin Sonata No. 2 in A Minor. Bach's Sonatas and Partitas have an iconic status in the violin repertoire. Yet, little is known about the background of these fascinating works. Bach's autograph manuscript is dated in Köthen in 1720, and it is commonly considered as the year when the cycle was completed. In his booklet notes Sebastian Bohren offers new perspectives of these masterpieces. Sebastian Bohren is considered one of the world's most promising young violinists and maintains an extensive performing schedule.
Violin Partita No. 2 in D Minor, BWV 1004- I. Allemanda
Violin Partita No. 2 in D Minor, BWV 1004 - II. Corrente
Violin Partita No. 2 in D Minor, BWV 1004 - III. Sarabanda
Violin Partita No. 2 in D Minor, BWV 1004 - IV. Giga
Violin Partita No. 2 in D Minor, BWV 1004 - V. Ciaccona
Violin Sonata No. 3 in C Major, BWV 1005 - I. Adagio
Violin Sonata No. 3 in C Major, BWV 1005 - II. Fugue
Violin Sonata No. 3 in C Major, BWV 1005 - III. Largo
Violin Sonata No. 3 in C Major, BWV 005 - IV. Allegro assai
Violin Partita No. 3 in E Major, BWV 1006 - I. Preludio
Violin Partita No. 3 in E Major, BWV 1006 - II. Loure
Violin Partita No. 3 in E Major, BWV 1006 - III. Gavotte en Rondeaux
Violin Partita No. 3 in E Major, BWV 1006 - IV. Menuet 1 - V. Menuet 2
Violin Partita No. 3 in E Major, BWV 1006 - VI. Bourrée
Violin Partita No. 3 in E Major, BWV 1006 - VII. Gigue
Bach: Sonatas And Partitas For Solo Violin (CD)
Bach: Violin Sonatas & Partitas (CD)
Bach: Solo Violin Sonatas & Partitas (2CD)
Eugene Drucker
Bach: Sonatas & Partitas for Solo Violin (2SACD)


text:
College football 2015: Previewing every FBS conference
By duthman August 29, 2015 5:17 am
Ohio State celebrates the inaugural College Football Playoff championship. (Matt Emmons / USA TODAY Sports)
Ohio State is considered the favorite to win another college football national championship, but the 2015 season promises to be wide open and full of surprises. We've collected every one of our conference previews in one place and ordered them based on Paul Myerberg's conference power rankings, plus independents Notre Dame, BYU and Army.
1. The SEC
Despite the league's ongoing crisis of confidence — propelled by a two-year title drought — one thing remains obvious: The SEC's national reputation remains untarnished. Read more
Texas A&M sophomore Myles Garrett battles two SMU defenders. (Tim Heitman / USA TODAY Sports)
2. The Pac-12
Great teams beat elite teams in the Pac-12 Conference, good ones beat great ones, average ones beat good ones, and so on down the line. It's the equivalent of the SEC, without the chest-thumping braggadocio, and very clearly stands alongside that to-the-east doppelganger as the top leagues in college football. Read more
UCLA prepares to take the field against Cal last season. (Cary Edmondson / USA TODAY Sports)
3. The Big Ten
Suffice it to say: With Ohio State leading the charge, the rest of college football no longer has the Big Ten Conference to kick around. Read more
Jim Harbaugh's arrival at Michigan was one of the biggest stories of college football's offseason. (Rick Osentoski / USA TODAY Sports)
4. The Big 12
It's too soon to claim the sky is falling, and too early to assume that being left out of the inaugural Playoff field demands a substantial shift in how the Big 12 as a whole goes about its football-playing business — adding a conference championship game, for instance. Read more
TCU coach Gary Patterson (second from left) is expected to have a Big 12 favorite and Playoff contender this season. (Kevin Jairaj / USA TODAY Sports)
5. The ACC
The numbers speak for themselves, and they paint the ACC as not just a power conference by the definition of the word — as one of five leagues composing the Power Five landscape — by a power, period, if not quite to the level of the SEC and Pac-12 Conference. Read more
Florida State's Jalen Ramsey is one of the best defensive players not only in the ACC but in college football at large. (Steve Mitchell / USA TODAY Sports)
6. The Mountain West
This new postseason system continues to lean toward rewarding the power conferences at the expense of the smaller leagues, but that's life in the Football Bowl Subdivision. A closer look reveals that the Playoff has been as kind to the Mountain West as any development in the past decade of college football. And that's with a four-team playoff; just wait until we move to eight. Read more
Bryan Harsin led Boise State to a Fiesta Bowl win in his first season as the Broncos' head coach. (Mark J. Rebilas / USA TODAY Sports)
7. The American
It's easy — with the hubbub over the Big 12 Conference's exclusion from the top four as one example — to take early returns from the Playoff's existence and blow them out of proportion, hand-wringing over a single season's worth of evidence at the expense of the bigger picture. Your nearest researcher may call this "length bias," or the diagnosis of results before the onset of actual symptoms. Don't fall into that trap: Last year notwithstanding, there's room for optimism surrounding the American. Read more
Cincinnati's Gunner Kiel (11) figures to be one of the most prolific passers in FBS this season. (Tommy Gilligan / USA TODAY Sports)
8. Conference USA
Conference USA went 17-4 against non-conference Group of Five opponents last season, but to call this league top-heavy is an understatement. Read more
Running back Devon Johnson (47) and Marshall should contend for the C-USA title again in 2015. (Michael Shroyer / USA TODAY Sports)
9. The MAC
Among the many truths about the Mid-American Conference is this: When it comes to pure dominance of an FBS league, no program can match Northern Illinois' active five-year run in the MAC. Read more
Linebacker Trent Voss (43) will be a key defender for Toledo and coach Matt Campbell (left). (Kim Klement / USA TODAY Sports)
10. The Sun Belt
All broad-stroke statements are relative. Keep this in mind as we make the following claim: The Sun Belt Conference has never been better. Read more
Georgia Southern has been a strong additon to the Sun Belt lineup. (Dale Zanine / USA TODAY Sports)
That an unbeaten Notre Dame team would reach the College Football Playoff is not up for debate — not given the Fighting Irish's regular-season schedule, which, though not quite as loaded as in the recent past, remains loaded with prime-time opportunities for national exposure. Whether Notre Dame can get into the Playoff with one loss, on the other hand, may hinge on factors largely outside the program's control. Read more
Though somewhat overlooked, Notre Dame's Will Fuller is one of the best and most productive wide receivers in the FBs. (Brian Spurlock / USA TODAY Sports)
ACC, Big Ten, college football, College Football Playoff, Pac-12, SEC, southeastern conference, NCAAF


text:
Q: How to Parse MVC4 API Controller response in android using android-kSOAP2-example I am new to android and I am like to parse a web API response (This API created in MVC4 using Web API template). I hosted this service on my server you can have a look on it.
http://railapi.digiwebtech.com/api/values
I did some Google research and found some useful links,from that i got and idea how to parse .Net web service. But I am unable to parse MVC API Controller response.
These are the links which I got from search.
Parse Dot Net Web service 3.5
https://github.com/thira/blog-demos/tree/master/android-kSOAP2-example
This both examples are parsing Dot Net web service built in .Net 3.5 but I am using asp.net MVC4 Web API service which is not a ".asmx" type.
If anyone have any idea about how to parse this or any link. Please reply me.
Thanks in advance.


text:
Estate 2007 review
Chevrolet Captiva Estate (2007 - 2015) review
21 - 32 How much is it to insure?
A lot of car for the money, decent to drive, strong diesel engines
Brand lacks awareness in the UK, rough ride on poor roads, noisey diesel engines
Chevrolet Captiva rivals
Chevrolet has traditionally been associated with iconic muscle cars like the Corvette and Camaro, and the small band of ex-Daewoo products it inherited in 2005 have struggled to establish themselves in the budget car sector.
The Chevrolet Captiva is the first of the firm's products that doesn't have its origins in an earlier Daewoo-badged model. It was also the first Chevrolet to reach the UK with a diesel engine - and is offered with front- or four-wheel drive for modest off-road ability. The Captiva is available with seven seats and makes a decent car for a large family, but a few too many signs of cost cutting associated with budget brands are evident.
The Captiva was given an overhaul in early 2011 with new diesel engines, new automatic and manual gearboxes as well as some exterior and interior design tweaks. The latest engines offer more power than before, but are also cleaner meaning running costs are lowered. While an engaging drive is still not its forte, the new engines offer strong performance and practicality continues to be its trump card.
In 2013 the Captiva received a minor facelift again, featuring a redesigned front and rear including a new grille mesh and restyled fog lamps accompanied by new 18-inch alloy wheels.
Keyless entry and start has also been introduced as standard on upper trims, while inside, the Captiva boasts fresh seat colors, new fabrics and restyled trims in the instrument panel.
Chevrolet has established itself as a brand that offers good value for money, but the Captiva goes beyond this to be a car that is genuinely good value. This value stems not just from its competitive pricing and generous equipment levels compared to most rivals; it also comes from the five-year, 100,000-mile warranty offered by Chevy with all of its models. You also don't have to look far up the Captiva range to find four-wheel drive and leather seats as standard. Add in reasonable fuel economy for the manual gearbox models and the Captiva is worthy of consideration.
Mediocre drive
Further hampering the Captiva is a ride that soon loses its composure when the road goes from smooth to the more usual mix of ridges, ruts and repairs we have in the UK. There's also little feel to the steering, so the Captiva is more a car for taking it steady in than enjoying yourself. However, it does at least come with ESP and hill descent control as standard.
Practicality All Chevrolet Captiva reviews


text:
'Art Space Tokyo' relaunch provides a model for cross-platform digital publishing
Craig Mod and Ashley Rawlings' 'Art Space Tokyo' guide to Tokyo galleries launches today on various digital platforms, and Mod explains the decisions behind its comprehensive publishing.
By Sam Byford / @345triangle
Source Art Space Tokyo and Craig Mod
Aug 21, 2012, 12:13 PM UTC |
art space tokyo
Today sees the digital launch of Ashley Rawlings and Craig Mod's Art Space Tokyo, a guide to 12 galleries and other cultural spots in and around Japan's capital. The book is great; it's beautifully laid out and features insightful essays by and interviews with people who keep Tokyo's art scene ticking. Almost as absorbing as its contents, though, is the story of how it came to be.
Originally published as a hardcover book, Mod and Rawlings took to Kickstarter in 2010 to fund a reprint and iPad version. The funding was successful, but the eventual iBooks edition never showed up until today — and it's being joined by versions for Kindle and Nook along with a PDF and a free web version. A DRM-free $14.99 bundle of the ePub, mobi, and PDF files is also available.
In an essay entitled Platforming Books, Mod goes into the design process behind each of these versions and outlines how they were tuned to the advantages and limitations of their individual platforms. He also explains the rationale behind offering the book in full for free — the idea is that making such a rich resource of information available online will drive traffic to the point where more people pay for the book than if the content were locked away. It's an unusual business model, but Mod promises to let us know the results at a later date.
More from Apps
Uber's 'View as Delivery Person' shows how much of your info couriers get
Elon Musk's Twitter is caving to government censorship, just like he promised


text:
Slebech Old Church
A Scheduled Monument in Martletwy, Pembrokeshire (Sir Benfro)
OS Grid: SN032139
Mapcode National: GBR CQ.YJGP
Mapcode Global: VH1RN.S9T4
Entry Name: Slebech Old Church
Scheduled Date: 17 June 1952
Cadw Legacy ID: PE275
Schedule Class: Religious, Ritual and Funerary
Category: Church
County: Pembrokeshire (Sir Benfro)
Community: Martletwy
Traditional County: Pembrokeshire
The monument comprises the remains of a church, dating to the medieval period comprising chancel, nave, north and south transepts, and north porch with tower. Associated with the Commandery of the Knights Hospitaller it was in existence before 1152, when Worcester Abbey resigned its interest and granted the church to the Knights. It was not listed in the Taxatio of 1291. It became a parish church at the Dissolution. In the early 19th century it was replaced by a new church on the present A40 and was reduced to its present condition of a stable but roofless ruin for occasional open air services. Medieval effigies from the north porch, possibly of 15th century Sir John Wogan and wife were removed to the new church..
The monument is of national importance for its potential to enhance our knowledge of medieval ecclesiastical organisation. The monument forms an important element within the wider medieval context and the structure itself may be expected to contain archaeological information in regard to chronology, building techniques and functional detail.
Mounds on the Island
Martletwy
Sister's House
Castle Lake Camp
Uzmaston, Boulston and Slebech
Picton Castle Mound
Minwear Ringwork
Landshipping House Garden Remains
Blackpool Iron Furnace
Newton North Church


What's going to be next for Autism Speaks, I wonder... an endorsement from the Ku Klux Klan?
Since your comment (and others) on my post regarding Watson, I've been putting together a follow up post that goes into more detail regarding some of his eugenics views.
The fact that he has been allowed to continue to spout such things for years prior to now without any repurcussion simply astounds me.
I doubt that AS will take references to him off of their website.
I wonder why they don't get smart and try to target whiner money raising liars, woo practitioners, lie through their teeth politicians, pathological terrorists and some of the other folks we could really probably be better off without.
But then again, I shouldn't even let my mind go there, as even the creeps deserve a chance until they break the law.


text:
Robert Hauer
robert.hauer@immotrading.at
Effective area:
Investment in 1091 Budapest
A property built at the beginning of the 20th century and rebuilt several times is for sale in Budapest, in the 9th district, with a usable area of 2868 m2 and free usage rights for a further 492 m2 in the form of a 1/3 house share. The building has a long load-bearing wall structure with thick brick walls. The ceiling consists largely of reinforced concrete and is reinforced in some places with steel beams. The original doors and windows are made of wood. In the 1990s, the building was divided into two categories according to its function: - In an office building with a large entrance area / lobby and apartments. The apartments were sold to their residents. The office building was renovated and reconstructed according to requirements (therefore 1/3 of the house). The inner courtyard of the building was roofed with a glass dome, and an internal staircase was built to provide separate access to the offices and other rooms. The respective offices are accessible from the entrance and from the lobby, which was created by the glass roof construction of the inner courtyard. The rooms are heated by a gas central heating boiler. The boiler system was renewed in 2003 and its control system in 2019. Most offices have air conditioning. The office space has a lobby, a kitchenette and a toilet-toilet unit. The property was renovated and rebuilt in 2018-2019 and received its current design and function at that time. Parking facilities are available in the immediate vicinity. In addition to the usual operating and maintenance costs, the operating income also covers the insurance of the building. The owner of the property does not pay the common costs, but pays the common agent a symbolic fee (usually HUF 17,000, in the priority months HUF 100,000, but the average was HUF 30,271). Cleaning and maintenance costs are borne by the tenant of the hall for the entire residential complex, so there are no additional costs. The Internet is tailor-made for every office tenant. The
approx. 1905
Location: City centre
Project on green field in Budapest
€ 27,248,000.-
429,251.00 m²


"Keep on Moving: African Americans Living with MS", Saturday August 3rd, 2013. Mobility Supercenter is proud to participate in this event at the Hilton Garden Inn Airport- Charleston, S.C.
Alex Jackson wins mini Ipad from Mobility SVM at the Atlanta Abilities Expo.
Posted in Mobility SVM, Wheelchair Accessible Trucks, Wheelchair Accessible Vehicles	| Tagged Atlanta Abilities Expo, Charleston South Carolina, Chevy Truck, GM Truck, Mobility Supercenter, Mobility SVM, SC., Wheelchair Accessible Trucks	| Comments Off on Alex Jackson wins mini Ipad from Mobility SVM at the Atlanta Abilities Expo.


Look for sales when choosing Golden End Table ByCharlton Home. Usually furniture is wear selling. Should you need a certain piece, you save a lot of money by patiently expecting the cost to be lowered. You could ask your chosen Golden End Table ByCharlton Home retailer if the item is going to be designated on the cheap. If you require a new furniture, attempt locating one particular with a bit of fully covered cushions. These pillows go longer and can be flipped routinely. Preferably, you should get a sofa with removable addresses in order to very easily rinse them. Easily-removed covers can be substituted very easily just in case you cannot clean a blemish Purchase Golden End Table ByCharlton Home later on in the year. Following this current year, it is typical for retailers to obtain these sections away their showroom ground. This can bring about some good sales and special discounts.
And not pushy at all. We ended up investing in a couch, loveseat, recliner chair, and home with matress. Even in comparison costs online basically we looked, and may tell i was through an awesome offer. I would recommend this store more than living spaces or ashley furniture, which we had remaining to come right here.
I ended through the Publish after being completely disappointed by an online foam furniture purchase because I noticed several advertisements on CL talking about the great deals and the high quality household furniture for sale at a reasonable prices. I had been very astounded by Derek and the knowledge of the home furniture available, he demonstrated all the options available and that i know I will be going back in my next furniture purchase.
This option are true to life-savers. I'd a crazy roommate ruin my house when I was out of town and was in desperate require a new home furniture. A buddy gave me Derek's contact details and so i called him up and that he could not have been much more useful. He requested what sort of household furniture I had and what I wanted and returned an hour later having a better quality, lower priced established. They were able to deliver the very next day and that i absolutely LOVE the new household furniture. Everyone I worked with was friendly and professional as well as their high quality products are greatly priced. I certainly recommend this area to anyone looking for new furniture!
Copyright © Harper End Table ByPorthos Home in Side-table All Right Reserved.


text:
Gunman on the run after shooting teen multiple times near park in NW Harris County
HOUSTON, Texas (KTRK) -- A manhunt is underway for a suspect who shot a teenager multiple times in a northwest Harris County neighborhood.
Sheriff Ed Gonzalez says the 17-year-old victim is in critical condition after gunfire erupted around 7:30 p.m. Tuesday in the 15900 block of Oakendell at Blueberry Hill Drive. This is not far from Highway 6 and Keith Harrow Boulevard.
According to deputies, the suspect walked out of a nearby park and opened fire on the teen.
The victim was struck several times, but he managed to run about a block away to his home. His family dialed 911, and the teen was rushed to Cy-Fair Hospital in critical condition.
Deputies say the suspect, described only as a Hispanic male in his late teens or early 20s, ran away on foot to an abandoned apartment complex.
While running, deputies said the suspect also sprayed bullets at a group of teens, but no one was hit in the shooting.
The shooting is not believed to be random, but deputies said they still need to interview the victim once he is out of surgery.
For now, the search is on for the suspect, who was last seen wearing a white shirt, long black shorts and white tennis shoes.
If you have seen the suspect, you are urged to call the Harris County Sheriff's Office.
Victim in critical condition, being treated at the hospital. Shooter possibly a Hispanic male, late teens-early 20's, wearing a white shirt, long black shorts, white tennis shoes. Actively searching for the suspect(s). #hounews https://t.co/waaHxmGLnL
— Ed Gonzalez (@SheriffEd_HCSO) August 29, 2018
Deputies are actively searching for multiple individuals who fled after a teen male suffered multiple gunshot wounds this evening in the 15900 block of Oakendell in NW Harris Co. #HouNews pic.twitter.com/bVsGSprpaN
— HCSOTexas (@HCSOTexas) August 29, 2018
houstonshootingteen shotteenagerinvestigation


text:
/**
 * This class is generated by jOOQ
 */
package eu.fbk.fm.alignments.index.db;

import eu.fbk.fm.alignments.index.db.tables.Alignments;
import eu.fbk.fm.alignments.index.db.tables.UserIndex;
import eu.fbk.fm.alignments.index.db.tables.UserObjects;
import eu.fbk.fm.alignments.index.db.tables.UserSg;
import eu.fbk.fm.alignments.index.db.tables.UserText;

import javax.annotation.Generated;

/**
 * Convenience access to all tables in public
 */
@Generated(
    value = {
        "http://www.jooq.org",
        "jOOQ version:3.8.4"
    },
    comments = "This class is generated by jOOQ"
)
@SuppressWarnings({ "all", "unchecked", "rawtypes" })
public class Tables {

    /**
     * The table public.alignments.
     */
    public static final Alignments ALIGNMENTS = eu.fbk.fm.alignments.index.db.tables.Alignments.ALIGNMENTS;

    /**
     * The table public.user_index.
     */
    public static final UserIndex USER_INDEX = eu.fbk.fm.alignments.index.db.tables.UserIndex.USER_INDEX;

    /**
     * The table public.user_objects.
     */
    public static final UserObjects USER_OBJECTS = eu.fbk.fm.alignments.index.db.tables.UserObjects.USER_OBJECTS;

    /**
     * The table public.user_sg.
     */
    public static final UserSg USER_SG = eu.fbk.fm.alignments.index.db.tables.UserSg.USER_SG;

    /**
     * The table public.user_text.
     */
    public static final UserText USER_TEXT = eu.fbk.fm.alignments.index.db.tables.UserText.USER_TEXT;
}

redpajama_set_name: RedPajamaGithub


Provides the latest information on technology, software, computer technology, internet, semiconductor, telecom and technology technology. The Department of Computer plus Information Technology provides educational opportunities that will apply information technology to solve societal difficulties. From cyber forensics and Large Data, to databases and analytics, impactful research is improving society plus enriching the constantly updated educational programs.
Computer and information study scientists invent and design brand new approaches to computing technology and find revolutionary uses for existing technology. They will study and solve complex troubles in computing for business, technology, medicine, and other fields.
Some personal computer scientists may work on teams along with electrical engineers, computer hardware engineers, as well as other specialists on multidisciplinary projects. Computer and information research researchers create and improve computer software plus hardware. The Computer Technology Computer plus Graphics Technology program is designed mainly for students seeking employment along with organizations that use computers to procedure, design, manage, and communicate details.


text:
#include "GrBezierEffect.h"

#include "gl/GrGLProcessor.h"
#include "gl/GrGLSL.h"
#include "gl/GrGLGeometryProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"

struct ConicBatchTracker {
    GrGPInput fInputColorType;
    GrColor fColor;
    uint8_t fCoverageScale;
    bool fUsesLocalCoords;
};

class GrGLConicEffect : public GrGLGeometryProcessor {
public:
    GrGLConicEffect(const GrGeometryProcessor&,
                    const GrBatchTracker&);

    void emitCode(const EmitArgs&) SK_OVERRIDE;

    static inline void GenKey(const GrGeometryProcessor&,
                              const GrBatchTracker&,
                              const GrGLCaps&,
                              GrProcessorKeyBuilder*);

    virtual void setData(const GrGLProgramDataManager& pdman,
                         const GrPrimitiveProcessor& primProc,
                         const GrBatchTracker& bt) SK_OVERRIDE {
        this->setUniformViewMatrix(pdman, primProc.viewMatrix());

        const ConicBatchTracker& local = bt.cast<ConicBatchTracker>();
        if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
            GrGLfloat c[4];
            GrColorToRGBAFloat(local.fColor, c);
            pdman.set4fv(fColorUniform, 1, c);
            fColor = local.fColor;
        }
        if (0xff != local.fCoverageScale && fCoverageScale != local.fCoverageScale) {
            pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(local.fCoverageScale));
            fCoverageScale = local.fCoverageScale;
        }
    }

private:
    GrColor fColor;
    uint8_t fCoverageScale;
    GrPrimitiveEdgeType fEdgeType;
    UniformHandle fColorUniform;
    UniformHandle fCoverageScaleUniform;

    typedef GrGLGeometryProcessor INHERITED;
};

GrGLConicEffect::GrGLConicEffect(const GrGeometryProcessor& processor,
                                 const GrBatchTracker& bt)
    : fColor(GrColor_ILLEGAL), fCoverageScale(0xff) {
    const GrConicEffect& ce = processor.cast<GrConicEffect>();
    fEdgeType = ce.getEdgeType();
}

void GrGLConicEffect::emitCode(const EmitArgs& args) {
    GrGLGPBuilder* pb = args.fPB;
    GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
    const GrConicEffect& gp = args.fGP.cast<GrConicEffect>();
    const ConicBatchTracker& local = args.fBT.cast<ConicBatchTracker>();

    GrGLVertToFrag v(kVec4f_GrSLType);
    args.fPB->addVarying("ConicCoeffs", &v);
    vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inConicCoeffs()->fName);

    // Setup pass through color
    this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputColor, NULL,
                                &fColorUniform);

    // setup coord outputs
    vsBuilder->codeAppendf("%s = %s;", vsBuilder->positionCoords(), gp.inPosition()->fName);
    vsBuilder->codeAppendf("%s = %s;", vsBuilder->localCoords(), gp.inPosition()->fName);

    // setup uniform viewMatrix
    this->addUniformViewMatrix(pb);

    // setup position varying
    vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", vsBuilder->glPosition(), this->uViewM(),
                           gp.inPosition()->fName);

    GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
    fsBuilder->codeAppend("float edgeAlpha;");

    switch (fEdgeType) {
        case kHairlineAA_GrProcessorEdgeType: {
            SkAssertResult(fsBuilder->enableFeature(
                    GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
            fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", v.fsIn());
            fsBuilder->codeAppendf("vec3 dklmdy = dFdy(%s.xyz);", v.fsIn());
            fsBuilder->codeAppendf("float dfdx ="
                                   "2.0 * %s.x * dklmdx.x - %s.y * dklmdx.z - %s.z * dklmdx.y;",
                                   v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppendf("float dfdy ="
                                   "2.0 * %s.x * dklmdy.x - %s.y * dklmdy.z - %s.z * dklmdy.y;",
                                   v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppend("vec2 gF = vec2(dfdx, dfdy);");
            fsBuilder->codeAppend("float gFM = sqrt(dot(gF, gF));");
            fsBuilder->codeAppendf("float func = %s.x*%s.x - %s.y*%s.z;", v.fsIn(), v.fsIn(),
                                   v.fsIn(), v.fsIn());
            fsBuilder->codeAppend("func = abs(func);");
            fsBuilder->codeAppend("edgeAlpha = func / gFM;");
            fsBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);");
            // Add line below for smooth cubic ramp
            // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);");
            break;
        }
        case kFillAA_GrProcessorEdgeType: {
            SkAssertResult(fsBuilder->enableFeature(
                    GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
            fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", v.fsIn());
            fsBuilder->codeAppendf("vec3 dklmdy = dFdy(%s.xyz);", v.fsIn());
            fsBuilder->codeAppendf("float dfdx ="
                                   "2.0 * %s.x * dklmdx.x - %s.y * dklmdx.z - %s.z * dklmdx.y;",
                                   v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppendf("float dfdy ="
                                   "2.0 * %s.x * dklmdy.x - %s.y * dklmdy.z - %s.z * dklmdy.y;",
                                   v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppend("vec2 gF = vec2(dfdx, dfdy);");
            fsBuilder->codeAppend("float gFM = sqrt(dot(gF, gF));");
            fsBuilder->codeAppendf("float func = %s.x * %s.x - %s.y * %s.z;", v.fsIn(), v.fsIn(),
                                   v.fsIn(), v.fsIn());
            fsBuilder->codeAppend("edgeAlpha = func / gFM;");
            fsBuilder->codeAppend("edgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);");
            // Add line below for smooth cubic ramp
            // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);");
            break;
        }
        case kFillBW_GrProcessorEdgeType: {
            fsBuilder->codeAppendf("edgeAlpha = %s.x * %s.x - %s.y * %s.z;", v.fsIn(), v.fsIn(),
                                   v.fsIn(), v.fsIn());
            fsBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);");
            break;
        }
        default:
            SkFAIL("Shouldn't get here");
    }

    if (0xff != local.fCoverageScale) {
        const char* coverageScale;
        fCoverageScaleUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                          kFloat_GrSLType,
                                          kDefault_GrSLPrecision,
                                          "Coverage",
                                          &coverageScale);
        fsBuilder->codeAppendf("%s = vec4(%s * edgeAlpha);", args.fOutputCoverage, coverageScale);
    } else {
        fsBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage);
    }
}

void GrGLConicEffect::GenKey(const GrGeometryProcessor& processor,
                             const GrBatchTracker& bt,
                             const GrGLCaps&,
                             GrProcessorKeyBuilder* b) {
    const GrConicEffect& ce = processor.cast<GrConicEffect>();
    const ConicBatchTracker& local = bt.cast<ConicBatchTracker>();
    uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
    key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0;
    key |= 0xff != local.fCoverageScale ? 0x8 : 0x0;
    key |= local.fUsesLocalCoords && processor.localMatrix().hasPerspective() ? 0x10 : 0x0;
    b->add32(key);
}

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

GrConicEffect::~GrConicEffect() {}

void GrConicEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                      const GrGLCaps& caps,
                                      GrProcessorKeyBuilder* b) const {
    GrGLConicEffect::GenKey(*this, bt, caps, b);
}

GrGLGeometryProcessor* GrConicEffect::createGLInstance(const GrBatchTracker& bt) const {
    return SkNEW_ARGS(GrGLConicEffect, (*this, bt));
}

GrConicEffect::GrConicEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage,
                             GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix)
    : INHERITED(color, viewMatrix, localMatrix)
    , fCoverageScale(coverage)
    , fEdgeType(edgeType) {
    this->initClassID<GrConicEffect>();
    fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
    fInConicCoeffs = &this->addVertexAttrib(GrAttribute("inConicCoeffs",
                                                        kVec4f_GrVertexAttribType));
}

bool GrConicEffect::onIsEqual(const GrGeometryProcessor& other) const {
    const GrConicEffect& ce = other.cast<GrConicEffect>();
    return (ce.fEdgeType == fEdgeType);
}

void GrConicEffect::initBatchTracker(GrBatchTracker* bt, const InitBT& init) const {
    ConicBatchTracker* local = bt->cast<ConicBatchTracker>();
    local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
    local->fCoverageScale = fCoverageScale;
    local->fUsesLocalCoords = init.fUsesLocalCoords;
}

bool GrConicEffect::onCanMakeEqual(const GrBatchTracker& m,
                                   const GrGeometryProcessor& that,
                                   const GrBatchTracker& t) const {
    const ConicBatchTracker& mine = m.cast<ConicBatchTracker>();
    const ConicBatchTracker& theirs = t.cast<ConicBatchTracker>();
    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                   that, theirs.fUsesLocalCoords) &&
           CanCombineOutput(mine.fInputColorType, mine.fColor,
                            theirs.fInputColorType, theirs.fColor) &&
           mine.fCoverageScale == theirs.fCoverageScale;
}

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

GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrConicEffect);

GrGeometryProcessor* GrConicEffect::TestCreate(SkRandom* random,
                                               GrContext*,
                                               const GrDrawTargetCaps& caps,
                                               GrTexture*[]) {
    GrGeometryProcessor* gp;
    do {
        GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                                                    random->nextULessThan(kGrProcessorEdgeTypeCnt));
        gp = GrConicEffect::Create(GrRandomColor(random), GrProcessorUnitTest::TestMatrix(random),
                                   edgeType, caps,
                                   GrProcessorUnitTest::TestMatrix(random));
    } while (NULL == gp);
    return gp;
}

//////////////////////////////////////////////////////////////////////////////
// Quad
//////////////////////////////////////////////////////////////////////////////

struct QuadBatchTracker {
    GrGPInput fInputColorType;
    GrColor fColor;
    uint8_t fCoverageScale;
    bool fUsesLocalCoords;
};

class GrGLQuadEffect : public GrGLGeometryProcessor {
public:
    GrGLQuadEffect(const GrGeometryProcessor&,
                   const GrBatchTracker&);

    void emitCode(const EmitArgs&) SK_OVERRIDE;

    static inline void GenKey(const GrGeometryProcessor&,
                              const GrBatchTracker&,
                              const GrGLCaps&,
                              GrProcessorKeyBuilder*);

    virtual void setData(const GrGLProgramDataManager& pdman,
                         const GrPrimitiveProcessor& primProc,
                         const GrBatchTracker& bt) SK_OVERRIDE {
        this->setUniformViewMatrix(pdman, primProc.viewMatrix());

        const QuadBatchTracker& local = bt.cast<QuadBatchTracker>();
        if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
            GrGLfloat c[4];
            GrColorToRGBAFloat(local.fColor, c);
            pdman.set4fv(fColorUniform, 1, c);
            fColor = local.fColor;
        }
        if (0xff != local.fCoverageScale && local.fCoverageScale != fCoverageScale) {
            pdman.set1f(fCoverageScaleUniform, GrNormalizeByteToFloat(local.fCoverageScale));
            fCoverageScale = local.fCoverageScale;
        }
    }

private:
    GrColor fColor;
    uint8_t fCoverageScale;
    GrPrimitiveEdgeType fEdgeType;
    UniformHandle fColorUniform;
    UniformHandle fCoverageScaleUniform;

    typedef GrGLGeometryProcessor INHERITED;
};

GrGLQuadEffect::GrGLQuadEffect(const GrGeometryProcessor& processor,
                               const GrBatchTracker& bt)
    : fColor(GrColor_ILLEGAL), fCoverageScale(0xff) {
    const GrQuadEffect& ce = processor.cast<GrQuadEffect>();
    fEdgeType = ce.getEdgeType();
}

void GrGLQuadEffect::emitCode(const EmitArgs& args) {
    GrGLGPBuilder* pb = args.fPB;
    GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
    const GrQuadEffect& gp = args.fGP.cast<GrQuadEffect>();
    const QuadBatchTracker& local = args.fBT.cast<QuadBatchTracker>();

    GrGLVertToFrag v(kVec4f_GrSLType);
    args.fPB->addVarying("HairQuadEdge", &v);
    vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inHairQuadEdge()->fName);

    // Setup pass through color
    this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputColor, NULL,
                                &fColorUniform);

    // setup coord outputs
    vsBuilder->codeAppendf("%s = %s;", vsBuilder->positionCoords(), gp.inPosition()->fName);
    vsBuilder->codeAppendf("%s = %s;", vsBuilder->localCoords(), gp.inPosition()->fName);

    // setup uniform viewMatrix
    this->addUniformViewMatrix(pb);

    // setup position varying
    vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", vsBuilder->glPosition(), this->uViewM(),
                           gp.inPosition()->fName);

    GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
    fsBuilder->codeAppendf("float edgeAlpha;");

    switch (fEdgeType) {
        case kHairlineAA_GrProcessorEdgeType: {
            SkAssertResult(fsBuilder->enableFeature(
                    GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
            fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn());
            fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", v.fsIn());
            fsBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.y,"
                                   "               2.0 * %s.x * duvdy.x - duvdy.y);",
                                   v.fsIn(), v.fsIn());
            fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppend("edgeAlpha = sqrt(edgeAlpha * edgeAlpha / dot(gF, gF));");
            fsBuilder->codeAppend("edgeAlpha = max(1.0 - edgeAlpha, 0.0);");
            // Add line below for smooth cubic ramp
            // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);");
            break;
        }
        case kFillAA_GrProcessorEdgeType: {
            SkAssertResult(fsBuilder->enableFeature(
                    GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
            fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn());
            fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", v.fsIn());
            fsBuilder->codeAppendf("vec2 gF = vec2(2.0 * %s.x * duvdx.x - duvdx.y,"
                                   "               2.0 * %s.x * duvdy.x - duvdy.y);",
                                   v.fsIn(), v.fsIn());
            fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppend("edgeAlpha = edgeAlpha / sqrt(dot(gF, gF));");
            fsBuilder->codeAppend("edgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);");
            // Add line below for smooth cubic ramp
            // fsBuilder->codeAppend("edgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);");
            break;
        }
        case kFillBW_GrProcessorEdgeType: {
            fsBuilder->codeAppendf("edgeAlpha = (%s.x * %s.x - %s.y);", v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppend("edgeAlpha = float(edgeAlpha < 0.0);");
            break;
        }
        default:
            SkFAIL("Shouldn't get here");
    }

    if (0xff != local.fCoverageScale) {
        const char* coverageScale;
        fCoverageScaleUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                          kFloat_GrSLType,
                                          kDefault_GrSLPrecision,
                                          "Coverage",
                                          &coverageScale);
        fsBuilder->codeAppendf("%s = vec4(%s * edgeAlpha);", args.fOutputCoverage, coverageScale);
    } else {
        fsBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage);
    }
}

void GrGLQuadEffect::GenKey(const GrGeometryProcessor& processor,
                            const GrBatchTracker& bt,
                            const GrGLCaps&,
                            GrProcessorKeyBuilder* b) {
    const GrQuadEffect& ce = processor.cast<GrQuadEffect>();
    const QuadBatchTracker& local = bt.cast<QuadBatchTracker>();
    uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
    key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x0;
    key |= 0xff != local.fCoverageScale ? 0x8 : 0x0;
    key |= local.fUsesLocalCoords && processor.localMatrix().hasPerspective() ? 0x10 : 0x0;
    b->add32(key);
}

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

GrQuadEffect::~GrQuadEffect() {}

void GrQuadEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                     const GrGLCaps& caps,
                                     GrProcessorKeyBuilder* b) const {
    GrGLQuadEffect::GenKey(*this, bt, caps, b);
}

GrGLGeometryProcessor* GrQuadEffect::createGLInstance(const GrBatchTracker& bt) const {
    return SkNEW_ARGS(GrGLQuadEffect, (*this, bt));
}

GrQuadEffect::GrQuadEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t coverage,
                           GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix)
    : INHERITED(color, viewMatrix, localMatrix)
    , fCoverageScale(coverage)
    , fEdgeType(edgeType) {
    this->initClassID<GrQuadEffect>();
    fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
    fInHairQuadEdge = &this->addVertexAttrib(GrAttribute("inHairQuadEdge",
                                                        kVec4f_GrVertexAttribType));
}

bool GrQuadEffect::onIsEqual(const GrGeometryProcessor& other) const {
    const GrQuadEffect& ce = other.cast<GrQuadEffect>();
    return (ce.fEdgeType == fEdgeType);
}

void GrQuadEffect::initBatchTracker(GrBatchTracker* bt, const InitBT& init) const {
    QuadBatchTracker* local = bt->cast<QuadBatchTracker>();
    local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
    local->fCoverageScale = fCoverageScale;
    local->fUsesLocalCoords = init.fUsesLocalCoords;
}

bool GrQuadEffect::onCanMakeEqual(const GrBatchTracker& m,
                                  const GrGeometryProcessor& that,
                                  const GrBatchTracker& t) const {
    const QuadBatchTracker& mine = m.cast<QuadBatchTracker>();
    const QuadBatchTracker& theirs = t.cast<QuadBatchTracker>();
    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                   that, theirs.fUsesLocalCoords) &&
           CanCombineOutput(mine.fInputColorType, mine.fColor,
                            theirs.fInputColorType, theirs.fColor) &&
           mine.fCoverageScale == theirs.fCoverageScale;
}

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

GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrQuadEffect);

GrGeometryProcessor* GrQuadEffect::TestCreate(SkRandom* random,
                                              GrContext*,
                                              const GrDrawTargetCaps& caps,
                                              GrTexture*[]) {
    GrGeometryProcessor* gp;
    do {
        GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                random->nextULessThan(kGrProcessorEdgeTypeCnt));
        gp = GrQuadEffect::Create(GrRandomColor(random),
                                  GrProcessorUnitTest::TestMatrix(random),
                                  edgeType, caps,
                                  GrProcessorUnitTest::TestMatrix(random));
    } while (NULL == gp);
    return gp;
}

//////////////////////////////////////////////////////////////////////////////
// Cubic
//////////////////////////////////////////////////////////////////////////////

struct CubicBatchTracker {
    GrGPInput fInputColorType;
    GrColor fColor;
    bool fUsesLocalCoords;
};

class GrGLCubicEffect : public GrGLGeometryProcessor {
public:
    GrGLCubicEffect(const GrGeometryProcessor&,
                    const GrBatchTracker&);

    void emitCode(const EmitArgs&) SK_OVERRIDE;

    static inline void GenKey(const GrGeometryProcessor&,
                              const GrBatchTracker&,
                              const GrGLCaps&,
                              GrProcessorKeyBuilder*);

    virtual void setData(const GrGLProgramDataManager& pdman,
                         const GrPrimitiveProcessor& primProc,
                         const GrBatchTracker& bt) SK_OVERRIDE {
        this->setUniformViewMatrix(pdman, primProc.viewMatrix());

        const CubicBatchTracker& local = bt.cast<CubicBatchTracker>();
        if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
            GrGLfloat c[4];
            GrColorToRGBAFloat(local.fColor, c);
            pdman.set4fv(fColorUniform, 1, c);
            fColor = local.fColor;
        }
    }

private:
    GrColor fColor;
    GrPrimitiveEdgeType fEdgeType;
    UniformHandle fColorUniform;

    typedef GrGLGeometryProcessor INHERITED;
};

GrGLCubicEffect::GrGLCubicEffect(const GrGeometryProcessor& processor,
                                 const GrBatchTracker&)
    : fColor(GrColor_ILLEGAL) {
    const GrCubicEffect& ce = processor.cast<GrCubicEffect>();
    fEdgeType = ce.getEdgeType();
}

void GrGLCubicEffect::emitCode(const EmitArgs& args) {
    GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
    const GrCubicEffect& gp = args.fGP.cast<GrCubicEffect>();
    const CubicBatchTracker& local = args.fBT.cast<CubicBatchTracker>();

    GrGLVertToFrag v(kVec4f_GrSLType);
    args.fPB->addVarying("CubicCoeffs", &v, kHigh_GrSLPrecision);
    vsBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inCubicCoeffs()->fName);

    // Setup pass through color
    this->setupColorPassThrough(args.fPB, local.fInputColorType, args.fOutputColor, NULL,
                                &fColorUniform);

    // setup coord outputs
    vsBuilder->codeAppendf("%s = %s;", vsBuilder->positionCoords(), gp.inPosition()->fName);
    vsBuilder->codeAppendf("%s = %s;", vsBuilder->localCoords(), gp.inPosition()->fName);

    // setup uniform viewMatrix
    this->addUniformViewMatrix(args.fPB);

    // setup position varying
    vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", vsBuilder->glPosition(), this->uViewM(),
                           gp.inPosition()->fName);

    GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();

    GrGLShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, kHigh_GrSLPrecision);
    GrGLShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, kHigh_GrSLPrecision);
    GrGLShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, kHigh_GrSLPrecision);
    GrGLShaderVar dfdx("dfdx", kFloat_GrSLType, 0, kHigh_GrSLPrecision);
    GrGLShaderVar dfdy("dfdy", kFloat_GrSLType, 0, kHigh_GrSLPrecision);
    GrGLShaderVar gF("gF", kVec2f_GrSLType, 0, kHigh_GrSLPrecision);
    GrGLShaderVar gFM("gFM", kFloat_GrSLType, 0, kHigh_GrSLPrecision);
    GrGLShaderVar func("func", kFloat_GrSLType, 0, kHigh_GrSLPrecision);

    fsBuilder->declAppend(edgeAlpha);
    fsBuilder->declAppend(dklmdx);
    fsBuilder->declAppend(dklmdy);
    fsBuilder->declAppend(dfdx);
    fsBuilder->declAppend(dfdy);
    fsBuilder->declAppend(gF);
    fsBuilder->declAppend(gFM);
    fsBuilder->declAppend(func);

    switch (fEdgeType) {
        case kHairlineAA_GrProcessorEdgeType: {
            SkAssertResult(fsBuilder->enableFeature(
                    GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
            fsBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), v.fsIn());
            fsBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), v.fsIn());
            fsBuilder->codeAppendf("%s = 3.0 * %s.x * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;",
                                   dfdx.c_str(), v.fsIn(), v.fsIn(), dklmdx.c_str(), v.fsIn(),
                                   dklmdx.c_str(), v.fsIn(), dklmdx.c_str());
            fsBuilder->codeAppendf("%s = 3.0 * %s.x * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;",
                                   dfdy.c_str(), v.fsIn(), v.fsIn(), dklmdy.c_str(), v.fsIn(),
                                   dklmdy.c_str(), v.fsIn(), dklmdy.c_str());
            fsBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str());
            fsBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", gFM.c_str(), gF.c_str(), gF.c_str());
            fsBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;",
                                   func.c_str(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppendf("%s = abs(%s);", func.c_str(), func.c_str());
            fsBuilder->codeAppendf("%s = %s / %s;",
                                   edgeAlpha.c_str(), func.c_str(), gFM.c_str());
            fsBuilder->codeAppendf("%s = max(1.0 - %s, 0.0);",
                                   edgeAlpha.c_str(), edgeAlpha.c_str());
            // Add line below for smooth cubic ramp
            // fsBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);",
            //                        edgeAlpha.c_str(), edgeAlpha.c_str(), edgeAlpha.c_str(),
            //                        edgeAlpha.c_str());
            break;
        }
        case kFillAA_GrProcessorEdgeType: {
            SkAssertResult(fsBuilder->enableFeature(
                    GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
            fsBuilder->codeAppendf("%s = dFdx(%s.xyz);", dklmdx.c_str(), v.fsIn());
            fsBuilder->codeAppendf("%s = dFdy(%s.xyz);", dklmdy.c_str(), v.fsIn());
            fsBuilder->codeAppendf("%s ="
                                   "3.0 * %s.x * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;",
                                   dfdx.c_str(), v.fsIn(), v.fsIn(), dklmdx.c_str(), v.fsIn(),
                                   dklmdx.c_str(), v.fsIn(), dklmdx.c_str());
            fsBuilder->codeAppendf("%s = 3.0 * %s.x * %s.x * %s.x - %s.y * %s.z - %s.z * %s.y;",
                                   dfdy.c_str(), v.fsIn(), v.fsIn(), dklmdy.c_str(), v.fsIn(),
                                   dklmdy.c_str(), v.fsIn(), dklmdy.c_str());
            fsBuilder->codeAppendf("%s = vec2(%s, %s);", gF.c_str(), dfdx.c_str(), dfdy.c_str());
            fsBuilder->codeAppendf("%s = sqrt(dot(%s, %s));", gFM.c_str(), gF.c_str(), gF.c_str());
            fsBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;",
                                   func.c_str(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppendf("%s = %s / %s;",
                                   edgeAlpha.c_str(), func.c_str(), gFM.c_str());
            fsBuilder->codeAppendf("%s = clamp(1.0 - %s, 0.0, 1.0);",
                                   edgeAlpha.c_str(), edgeAlpha.c_str());
            // Add line below for smooth cubic ramp
            // fsBuilder->codeAppendf("%s = %s * %s * (3.0 - 2.0 * %s);",
            //                        edgeAlpha.c_str(), edgeAlpha.c_str(), edgeAlpha.c_str(),
            //                        edgeAlpha.c_str());
            break;
        }
        case kFillBW_GrProcessorEdgeType: {
            fsBuilder->codeAppendf("%s = %s.x * %s.x * %s.x - %s.y * %s.z;",
                                   edgeAlpha.c_str(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn(), v.fsIn());
            fsBuilder->codeAppendf("%s = float(%s < 0.0);", edgeAlpha.c_str(), edgeAlpha.c_str());
            break;
        }
        default:
            SkFAIL("Shouldn't get here");
    }

    fsBuilder->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, edgeAlpha.c_str());
}

void GrGLCubicEffect::GenKey(const GrGeometryProcessor& processor,
                             const GrBatchTracker& bt,
                             const GrGLCaps&,
                             GrProcessorKeyBuilder* b) {
    const GrCubicEffect& ce = processor.cast<GrCubicEffect>();
    const CubicBatchTracker& local = bt.cast<CubicBatchTracker>();
    uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
    key |= kUniform_GrGPInput == local.fInputColorType ? 0x4 : 0x8;
    key |= local.fUsesLocalCoords && processor.localMatrix().hasPerspective() ? 0x10 : 0x0;
    b->add32(key);
}

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

GrCubicEffect::~GrCubicEffect() {}

void GrCubicEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                      const GrGLCaps& caps,
                                      GrProcessorKeyBuilder* b) const {
    GrGLCubicEffect::GenKey(*this, bt, caps, b);
}

GrGLGeometryProcessor* GrCubicEffect::createGLInstance(const GrBatchTracker& bt) const {
    return SkNEW_ARGS(GrGLCubicEffect, (*this, bt));
}

GrCubicEffect::GrCubicEffect(GrColor color, const SkMatrix& viewMatrix,
                             GrPrimitiveEdgeType edgeType)
    : INHERITED(color, viewMatrix), fEdgeType(edgeType) {
    this->initClassID<GrCubicEffect>();
    fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
    fInCubicCoeffs = &this->addVertexAttrib(GrAttribute("inCubicCoeffs",
                                                        kVec4f_GrVertexAttribType));
}

bool GrCubicEffect::onIsEqual(const GrGeometryProcessor& other) const {
    const GrCubicEffect& ce = other.cast<GrCubicEffect>();
    return (ce.fEdgeType == fEdgeType);
}

void GrCubicEffect::initBatchTracker(GrBatchTracker* bt, const InitBT& init) const {
    CubicBatchTracker* local = bt->cast<CubicBatchTracker>();
    local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
    local->fUsesLocalCoords = init.fUsesLocalCoords;
}

bool GrCubicEffect::onCanMakeEqual(const GrBatchTracker& m,
                                   const GrGeometryProcessor& that,
                                   const GrBatchTracker& t) const {
    const CubicBatchTracker& mine = m.cast<CubicBatchTracker>();
    const CubicBatchTracker& theirs = t.cast<CubicBatchTracker>();
    return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                   that, theirs.fUsesLocalCoords) &&
           CanCombineOutput(mine.fInputColorType, mine.fColor,
                            theirs.fInputColorType, theirs.fColor);
}

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

GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrCubicEffect);

GrGeometryProcessor* GrCubicEffect::TestCreate(SkRandom* random,
                                               GrContext*,
                                               const GrDrawTargetCaps& caps,
                                               GrTexture*[]) {
    GrGeometryProcessor* gp;
    do {
        GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(
                                                    random->nextULessThan(kGrProcessorEdgeTypeCnt));
        gp = GrCubicEffect::Create(GrRandomColor(random),
                                   GrProcessorUnitTest::TestMatrix(random), edgeType, caps);
    } while (NULL == gp);
    return gp;
}