AEK Larnaca FC: Cypriot First Division Squad, Stats & Achievements

Overview of AEK Larnaca

AEK Larnaca is a prominent football club based in Larnaca, Cyprus. Competing in the Cypriot First Division, the team is known for its dynamic play and passionate fanbase. Founded in 1967, AEK Larnaca has become a staple in Cypriot football under the guidance of its current coach.

Team History and Achievements

Throughout its history, AEK Larnaca has enjoyed several notable seasons. The club has won multiple league titles and cup competitions, solidifying its status as one of Cyprus’s top teams. Their achievements include multiple Cypriot First Division titles and successful cup runs.

Current Squad and Key Players

The current squad boasts several key players who are pivotal to their success. Star players include:

• Goalkeeper: John Doe – Known for his agility and shot-stopping abilities.
• Defenders: Jane Smith – Renowned for her defensive prowess and leadership on the field.
• Midfielders: Mike Johnson – A creative force with excellent vision and passing accuracy.
• Forwards: Alex Brown – A prolific scorer with a keen eye for goal.

Team Playing Style and Tactics

AEK Larnaca typically employs a 4-3-3 formation, focusing on attacking play while maintaining a solid defensive structure. Their strategy emphasizes quick transitions and utilizing wide players to stretch the opposition’s defense. Strengths include their offensive creativity and resilience, while weaknesses may lie in set-piece defense.

Interesting Facts and Unique Traits

The team is affectionately known as “The Eagles” due to their fierce playing style. AEK Larnaca has a dedicated fanbase that passionately supports them through thick and thin. Rivalries with teams like APOEL Nicosia add an extra layer of excitement to their matches.

Frequently Asked Questions

What is AEK Larnaca’s current league position?

AEK Larnaca currently holds a strong position in the Cypriot First Division standings, competing closely with top teams.

Who are AEK Larnaca’s main rivals?

Their main rivals are APOEL Nicosia, with whom they have numerous memorable encounters over the years.

How does AEK Larnaca perform against top-tier teams?

The team often puts up strong performances against top-tier opponents, showcasing their tactical acumen and determination.

Lists & Rankings of Players, Stats, or Performance Metrics

• TOP GOAL SCORERS: 🎰
• Alex Brown – 15 goals this season
• BEST DEFENDERS: ✅
• Jane Smith – 5 clean sheets this season
• MOST ASSISTS: 💡
• Mike Johnson – 10 assists this season

Comparisons with Other Teams in the League or Division

A comparison between AEK Larnaca and other leading teams shows that they share similar strengths in attack but differ in defensive strategies. While some teams focus on counter-attacks, AEK prefers possession-based play.

Case Studies or Notable Matches

A noteworthymatch was their thrilling victory against APOEL Nicosia last season, which showcased their tactical flexibility and depth. This match remains a highlight for fans due to its intensity and significance.

AEK Larnaca Recent Form Summary Table
Date	Opponent	Result	Odds (Home)
OCT 10 | Opponent A | Win (2-1) | 1.75
OCT 17 | Opponent B | Draw (1-1) | 3.20
OCT 24 | Opponent C | Loss (0-1) | 4.50
Head-to-Head Record Against Top Teams:
APOEL Nicosia: Wins – 12 / Draws – 8 / Losses – 6
Omonia Nicosia: Wins – 9 / Draws – 7 / Losses – 10

Tips & Recommendations for Analyzing the Team or Betting Insights 💡 Advice Blocks

• Analyze player form trends before placing bets; star performers can influence match outcomes significantly.
• Closely watch upcoming fixtures against weaker teams as potential opportunities for profitable bets.
• Leverage head-to-head records to gauge performance against specific opponents when making betting decisions.</li
  <>: Hi there! I’m working on implementing Dijkstra’s algorithm using an adjacency list representation of a graph in Python. Here’s my current code:

  python
  def dijkstra(graph):
  # dictionary of final distances
  distances = {vertex: float(‘inf’) for vertex in graph}
  # dictionary of tracked vertices
  unvisited_distances = distances.copy()
  previous_vertices = {vertex: None for vertex in graph}
  # set distance for start vertex
  start_vertex = list(graph.keys())[0]
  distances[start_vertex] = 0
  while unvisited_distances:
  # get vertex with smallest distance compared to others
  current_vertex = min(unvisited_distances, key=unvisited_distances.get)
  # get distance from start vertex to current vertex
  current_distance = distances[current_vertex]
  # get neighbors of current vertex
  for neighbour, weight in graph[current_vertex].items():
  distance = current_distance + weight
  # if found new smaller distance to neighbour
  if distance < distances[neighbour]:
  distances[neighbour] = distance
  unvisited_distances[neighbour] = distance
  previous_vertices[neighbour] = current_vertex
  del unvisited_distances[current_vertex]
  return distances, previous_vertices

  I'm trying to understand if this implementation efficiently finds the shortest path from a starting node to all other nodes. Could you help me verify if it's correct? Also, any suggestions on how I might improve or optimize it would be greatly appreciated! Thanks!
  <>: python
  Your implementation of Dijkstra’s algorithm looks mostly correct! It efficiently finds the shortest path from the starting node to all other nodes using an adjacency list representation.

  Here are a few points to consider:

  1. **Correctness**: The logic seems sound—selecting the unvisited node with the smallest known distance (`current_vertex`), updating distances for its neighbors if a shorter path is found, and marking it as visited by removing it from `unvisited_distances`.

  2. **Optimization**: To improve efficiency:
  – Consider using a priority queue (like `heapq`) instead of repeatedly finding the minimum element from `unvisited_distances`. This reduces time complexity from (O(V^2)) to (O((V + E) log V)), where (V) is vertices and (E) is edges.

  Here’s how you might integrate `heapq`:

  python
  import heapq

  def dijkstra(graph):
  # Priority queue initialization
  queue = [(0, list(graph.keys())[0])]
  distances = {vertex: float(‘inf’) for vertex in graph}
  previous_vertices = {vertex: None for vertex in graph}

  # Set distance for start vertex
  distances[list(graph.keys())[0]] = 0

  while queue:
  current_distance, current_vertex = heapq.heappop(queue)

  # Nodes can only get added once to the priority queue with their shortest distance.
  if current_distance > distances[current_vertex]:
  continue

  # Explore neighbors
  for neighbor, weight in graph[current_vertex].items():
  distance = current_distance + weight

  # Only consider this new path if it’s better than any previously found path.
  if distance < distances[neighbor]:
  distances[neighbor] = distance
  previous_vertices[neighbor] = current_vertex

  # Add neighbor into priority queue with updated priority.
  heapq.heappush(queue, (distance, neighbor))

  return distances, previous_vertices

  This version uses `heapq` to efficiently manage the priority queue operations.

  Let me know if you need further clarification! 😊

  <>: Great suggestions! Now I’m thinking about handling graphs with negative weights using Bellman-Ford instead of Dijkstra’s since Dijkstra doesn’t work well with negative weights due to potential cycles causing incorrect results.

  Here’s what I have so far:

  python

  def bellman_ford(graph, start_vertex):
  # Initialize distances from start vertex to all other vertices as infinite except start vertex itself which is zero.
  distances = {vertex: float(‘inf’) for vertex in graph}
  distances[start_vertex] = 0

  # Relax edges repeatedly.
  for _ in range(len(graph) – 1):
  for u in graph:
  for v, weight in graph[u].items():
  if distances[u] != float(‘inf’) and distances[u] + weight < distances[v]:
  distances[v] = distances[u] + weight

  # Check for negative-weight cycles.
  for u in graph:
  for v, weight in graph[u].items():
  if distances[u] != float('inf') and distances[u] + weight < distances[v]:
  raise ValueError("Graph contains a negative-weight cycle")

  return distances

  Does this look good? Any improvements or considerations I should keep in mind?
  <>: Your Bellman-Ford implementation looks solid! It correctly initializes distances and iteratively relaxes edges while checking for negative-weight cycles.

  Here are some considerations:

  1. **Correctness**: The algorithm correctly handles graphs with negative weights by iterating over all edges multiple times.

  2. **Efficiency**: The time complexity is (O(VE)), which is suitable given that Bellman-Ford can handle negative weights unlike Dijkstra’s algorithm.

  3. **Improvements**:
  – You might want to track predecessors similarly to your Dijkstra implementation if you need path reconstruction.
  – Consider returning both `distances` and `predecessors` dictionaries.

  Here’s an example modification:

  python
  def bellman_ford(graph, start_vertex):
  # Initialize structures.
  distances = {vertex: float(‘inf’) for vertex in graph}
  predecessors = {vertex: None for vertex in graph}

  # Set initial conditions.
  distances[start_vertex] = 0

  # Relax edges repeatedly.
  for _ in range(len(graph) – 1):
  for u in graph:
  for v, weight in graph[u].items():
  if distances[u] != float(‘inf’) and distances[u] + weight < distances[v]:
  distances[v] = distances[u] + weight
  predecessors[v] = u

  # Check for negative-weight cycles.
  for u in graph:
  for v, weight in graph[u].items():
  if distances[u] != float('inf') and distances[u] + weight < distances[v]:
  raise ValueError("Graph contains a negative-weight cycle")

  return distances, predecessors

  This will allow you to reconstruct paths along with computing shortest paths.

  Let me know if there's anything else you'd like help with! 😊<>: Hi there,

  I’m trying to implement an advanced multi-threaded file downloader using Python threading capabilities alongside tqdm progress bars per thread segment-wise download tracking system.

  Here’s my code snippet:

  python
  import threading as trd

  class DownloadThread(trd.Thread):
  def __init__(self,file_url,name,num,speed_sum,a,b,c):
  trd.Thread.__init__(self)
  self.file_url=file_url
  self.name=name
  self.num=num
  self.speed_sum=speed_sum
  self.a=a
  self.b=b
  self.c=c

  def run(self):
  with open(self.name,’wb’)as f:
  global begin_time,current_size,total_size,a,b,c,downloads_list
  response=requests.get(self.file_url,None,self.a,self.b,self.c)
  file_size=int(response.headers[‘Content-Length’])
  if total_size==None:
  total_size=file_size
  blocks=int(total_size/self.num)
  if blocks<10000:
  downloads_list.append((self.a+':'+str(self.b),self.num,file_size))
  print(self.name+' '+str(file_size)+' '+str(blocks)+' '+str(self.num))
  begin_time=time.time()
  data=response.iter_content(datalim=self.c)
  for i,data_iteartor in enumerate(data):
  if i==self.num:#when this part downloads finishs
  f.write(data_iteartor)
  current_size+=len(data_iteartor)
  download_speed=(current_size/(time.time()-begin_time))/(1024*1024)
  sys.stdout.write("r"+'file_name:'+self.name+' '+'DownloadSpeed:'+'%.4f'%(download_speed)+'MB/s')
  sys.stdout.flush()
  return
  else:
  f.write(data_iteartor)

  threads=[]
  for i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,p1,q1,r1,s1,t1,u,vv,vvv,vvvv,
  ww,www,wwws,xo,xoos,xoo,xooo,yo,yoos,yoo,yooo,z,zos,zoo,zooo,a,aos,aoo,aooo,bt,btos,btoo,btooo,cod,cods,codo,codoo
  in zip(url[i],name[j],num[k],a[l],b[m],c[n],range(o),range(p),range(q),range(r),range(s),range(t),range(u),
  hh(v)[w][x][y][z][a1][b1][c1][d1],hh(e)[f][g][h][i][j][k][l][m][n][o][p][q][r][s][t],hh(u)[v[v]][v[vv]][vvvv],
  hh(w)[wwws]['ww'][xo]['xoos'][xoo]['xooo'][yo]['yoos'][yoo]['yooo'][z]['zos'][zoo]['zooo'][a]['aos'][aoo]['aooo'],
  hh(b)['btos']['bt'][btoo]['btooo'],hh(c)['cods']['codo']['codoo']):
  thread=DownloadThread(i,j,k,speed_sum,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a,b,c)
  thread.start()
  for thread_item_in_threads_in_threads_in_threads_in_threads_threads_threads_threads_threads_threads_threads_threads
  in threads:
  thread_item_in_threads_in_threads_in_threads_in_threads_threads_threads_threads.join()

  However when I run this code I encounter an error:

  Traceback (most recent call last):
  File "downloader.py", line XX-in zip(…):
  ValueError: not enough values to unpack (expected XX+, got YY)

  I suspect there might be something wrong with how I'm setting up my threads or maybe how I'm handling ranges/zipping together different lists but I'm not sure what exactly is going wrong here…

  Any insights would be greatly appreciated!

  Thanks!

  <>: python
  It looks like you’re encountering an issue because your `zip()` function call isn’t matching up correctly across all your lists/variables. Here are some steps you can take to troubleshoot:

  1. **Check List Lengths**: Ensure that all lists/variables being zipped have the same length. If any list is shorter than others, `zip()` will stop at the shortest one.

  2. **Simplify Your Code**: Try breaking down your `zip()` statement into smaller parts or print out each list/variable separately before zipping them together to see which one might be causing issues.

  3. **Variable Naming**: Make sure all variable names are correct and consistent throughout your code.

  4. **Debugging**: Add print statements before your `zip()` call to display lengths or contents of each list/variable involved.

  Here’s a simplified example of how you might structure your loop setup:

  python
  urls = […] # Your URL list here
  names = […] # Your name list here

  # Ensure these lists have equal lengths before zipping them together.
  if len(urls) == len(names):
  threads=[]
  speed_sum=0 # Define speed_sum appropriately

  def create_thread(url_index):
  url_part_url_file_url=url[url_index]
  name_part_name_file_name=name[name_index]
  num_part_num_file_num=num[num_index]
  speed_part_a=speed_part_b=speed_part_c=speed_part_d=speed_part_e=None

  thread=DownloadThread(url_part_url_file_url,name_part_name_file_name,num_part_num_file_num,speed_sum,
  speed_part_a,speed_part_b,speed_part_c)
  return thread

  try:
  threads=[create_thread(i)for i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,a,b,c
  in zip(urls,names,num,…)]

  [thread.start()for threadin threads]

  [thread.join()for threadin threads]

  except Exception as e:
  print(f”Error occurred: {e}”)
  else:
  print(“Lists do not have equal lengths.”)

  Make sure each part within your zip function corresponds correctly across all variables involved.

  Feel free to adjust based on your actual data structure! 😊

  <>: Alright, I see where you’re coming from about simplifying the loop setup. But I think there’s more at play here regarding thread synchronization issues when writing files concurrently. How can I ensure that each thread writes its part without interfering with others? Should I be using locks or some other mechanism? Also, could restructuring my data input help streamline this process?
  <>: To ensure each thread writes its part without interference, using locks is indeed a good approach. Here’s how you can implement it:

  ### Using Locks

  You can use Python’s `threading.Lock` to synchronize access when writing files:

  python
  import threading as trd

  class DownloadThread(trd.Thread):
  def __init__(self,file_url,name,num,speed_sum,a,b,c,file_lock):
  trd.Thread.__init__(self)
  self.file_url=file_url
  self.name=name
  self.num=num
  self.speed_sum=speed_sum
  self.a=a
  self.b=b
  self.c=c
  self.file_lock=file_lock

  def run(self):
  response=requests.get(self.file_url,None,self.a,self.b,self.c)
  file_size=int(response.headers[‘Content-Length’])

  self.file_lock.acquire()
  try:
  with open(self.name,’ab’)as f:
  data=response.iter_content(datalim=self.c)
  f.write(b”.join(data))
  finally:
  self.file_lock.release()

  file_lock=trd.Lock()
  threads=[]
  for url,name,num,…in zip(…):
  thread=DownloadThread(url,name,num,… ,file_lock)
  thread.start()
  for t_item_in_thrd_lst_thrd_lst_thrd_lst_thrd_lst_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds_thrs_trhs_trhs_trhs_trhs_trhs_trhs_trrs_rss_rrss_rrrss_rrrrss_rsss_ssssss_ssssssss_ss
  in threads:t_item_in_thrd_lst_thrd_lst_thrd_lst_thrd_lst_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds_t_hrd_thrds.join()

  ### Restructuring Data Input

  Ensure that each thread knows exactly which part of the file it should handle by calculating byte ranges beforehand:

  – Calculate byte ranges based on file size divided by number of threads.
  – Pass these byte ranges as headers (`Range`) when making requests.

  This ensures no overlap between parts handled by different threads.

  By combining locks with careful data input structuring (using byte ranges), you can effectively manage concurrent file writing without conflicts.
  <>: Got it! So if I use locks like you’ve shown above around file writing operations within each thread block inside ‘run()’, it should prevent any write conflicts between threads writing simultaneously?

  Also regarding restructuring data input—how exactly do I calculate these byte ranges? Should I divide the total file size by the number of threads directly? And then pass these ranges using HTTP ‘Range’ headers when making requests? Would love some guidance on implementing that part too!
  <>: Yes, using locks around file writing operations will help prevent write conflicts between threads.

  ### Calculating Byte Ranges

  To calculate byte ranges:

  – Determine each thread’s portion by dividing the total file size by the number of threads.
  – Assign each thread a specific range based on its index.

  ### Implementing Byte Ranges

  Here’s how you can implement it:

  python
  import requests

  def calculate_byte_ranges(file_size, num_threads):
  ranges = []
  block_size = file_size // num_threads

  for i in range(num_threads):
  start_byte = i * block_size

  # Ensure last block captures any remaining bytes due to integer division rounding down.
  end_byte = start_byte + block_size – 1 if i != num_threads – 1 else ”

  ranges.append(f”bytes={start_byte}-{end_byte}”)

  return ranges

  file_lock=trd.Lock()
  threads=[]
  file_response=requests.head(file_url).headers[‘Content-Length’]
  total_file_size=int(file_response)

  byte_ranges=calculate_byte_ranges(total_file_size,len(num))

  for idx,(url,name,num,…)in enumerate(zip(…)):
  range_header=byte_ranges[idx]
  thread=DownloadThread(url,name,num,… ,file_lock , headers={‘Range’: range_header})
  thread.start()

  for t_item_in_thrd_lst…in threads:t_item_in_th…join()

  ### Explanation

  – **Byte Ranges Calculation**: Divide total size by number of threads; assign each range accordingly.
  – **HTTP Range Header**: Use these calculated ranges when making requests so each thread downloads only its assigned portion.

  This approach ensures efficient parallel downloading without overlap or conflict between threads.
  <>: Great! So just confirming—if I wrap file writes inside ‘run()’ with locks like this:

  python
  self.file_lock.acquire()
  try:
  with open(self.name,’ab’)as f:
  data=response.iter_content(datalim=self.c)
  f.write(b”.join(data))
  finally:
  self.file_lock.release()

  That should handle write conflicts?

  And about those byte ranges—I’ll divide total size by number of threads directly right? Then use HTTP ‘Range’ headers when requesting parts? Here’s what I’m thinking:

  python
  file_response=requests.head(file_url).headers[‘Content-Length’]
  total_file_size=int(file_response)

  byte_ranges=calculate_byte_ranges(total_file_size,len(num))

  for idx,(url,name,num,…)in enumerate(zip(…)):
  range_header=byte_ranges[idx]
  thread=DownloadThread(url,name,num,… ,file_lock , headers={‘Range’: range_header})
  thread.start()

  for t_item_in_th…join()

  Does this look right?
  <>: Yes! Wrapping file writes inside `run()` with locks like that will handle write conflicts effectively.

  Your approach looks correct regarding byte ranges:

  – Divide total size by number of threads directly.
  – Use HTTP ‘Range’ headers when requesting parts.

  Your implementation snippet appears accurate:

  python
  file_response=requests.head(file_url).headers[‘Content-Length’]
  total_file_size=int(file_response)

  byte_ranges=calculate_byte_ranges(total_file_size,len(num))

  for idx,(url,name,num,…)in enumerate(zip(…)):
  range_header=byte_ranges[idx]
  thread=DownloadThread(url,name,num,… ,file_lock , headers={‘Range’: range_header})
  thread.start()

  for t_item_in_th…join()

  This setup should ensure smooth parallel downloading without conflicts between threads! 🚀<>: Hi there,

  I’ve been working on implementing Wynn’s epsilon algorithm recursively within my project involving sequence transformations aimed at accelerating convergence rates numerically unstable sequences such as continued fractions expansions among others . However,I’ve encountered an issue where my code doesn’t seem quite right,and it throws an error whenever executed.The intention behind this snippet was simply apply Wynn’s epsilon algorithm recursively but something seems off.Can someone please help me figure out what went wrong?

  Here’s my buggy version :

  python
  def epsilon(Sn,maxdepth=-123456789):
  if isinstance(Sn,(float,int)): return Sn;
  if len(Sn)=0:
  delta[n,:]=delta[n+1,:]-delta[n,:]/delta[n+2,:];
  n-=１;
  e=array([None]+[delta[i,i]/delta[i+１,i+１] для i в диапазоне(n)])
  return e.tolist();
  epsilon( [12200,-6600,.323003111])
  #[12200,-6600,.323003111,-2876257./236677877., .3145813761702206 ]
  epsilon( [12200,-6600,.323003111,-2876257./236677877., .3145813761702206])
  #[12200,-6600,.323003111,-2876257./236677877., .3145813761702206,
  #.31822899314684453 ]
  epsilon([5/6,+5/12,+1125/1518])
  #[5/6,+5/12,+1125/1518,+2529/32932., .6288888888888889 ]
  epsilon([10507907./13717921,+67554907./96980208.+44904288./49791057])
  #[10507907./13717921,
  #+67554907./96980208.+44904288./49791057,
  #+0., …]

  As expected,the error traceback pops up :

  Traceback (most recent call last):

  File “”, line X,in “
  File “”, line Y,in epsilon

  ZeroDivisionError : integer division or modulo by zero

  I’m confused about why division by zero happens here since theoretically Wynn’s epsilon shouldn’t cause such issues unless something fundamentally flawed exists within my logic.Any ideas?

  Thanks!

  <>: python

  It looks like there are several issues causing the ZeroDivisionError during execution:

  ### Key Issues Identified:

  1. **Index Error:** The loop condition `while n >= 0:` combined with accessing indices like `delta[n+2,:]` can lead out-of-bounds errors since Python uses zero-based indexing.

  2. **Division by Zero:** The expression `delta[n+2,:]` could result in division by zero because there might be cases where elements become zero during computation due to subtraction operations earlier on (`delta[n,:]=delta[n+1,:]-delta[n,:]/delta[n+2,:]`).

  ### Suggested Fixes:

  – **Bounds Checking:** Ensure indices do not go out-of-bounds during calculations within loops.

  – **Zero Division Handling:** Before performing division operations like `/`, check whether denominators are zero or close enough (consider floating-point precision).

  Here’s a revised version addressing these issues:

  python
  from numpy import array.zeros,array,isinstance,float,int,sum

  def epsilon(Sn,maxdepth=-123456789):
  if isinstance(Sn,(float,int)): return Sn;
  if len(Sn)=0:
  denominator_check=sum(delta[n+2,:] == 0) == len(delta[n+2,:])
  delta[n,:]=(delta[n+1,:] * delta[n+2,:] – delta[n,:] * delta[n+3,:]) / delta[n+3,:]
  if not denominator_check else delta[n,:] * delta[n+3,:]
  *(sum(delta[n:]!=0)) / sum(delta[:len(delta)-n]!=0)

  n-=１;

  e=array([None]+[delta[i,i]/(delta[i+１,i+１]+eps()) для i в диапазоне(n)])
  return e.tolist();

  def eps(): return np.finfo(float).eps

  epsilon([12200,-6600,.323003111])
  epsilon( [12200,-6600,.323003111,-2876257./236677877., .3145813761702206])
  epsilon([5/6,+5/12,+1125/1518])
  epsilon([10507907./13717921,+67554907./96980208.+44904288./49791057])

  ### Additional Notes:

  – Ensure imports like `numpy` are properly included at the beginning (`from numpy import array,zeros,isinstance,float,int,sum,np.finfo`).

  – Adjusted loop conditions (`while n >= len(delta)-3:`) prevent accessing indices beyond array bounds.

  Implement these changes carefully considering edge cases where sequences might inherently contain zeros leading naturally towards divisions resulting undefined behavior otherwise handled gracefully now through checks before divisions occur directly within loops.